Shiro-Subject 分析

Subject反正就好像呈现的视图。所有Subject 都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
对于上面这句话的理解呢？怎么去理解这个很重要，看看别人的代码设计的流程也是比较的清楚的，Subject都绑定到了SecurityManager，因此我们在创建Subject的时候，必须给框架的内部绑定了一个SecurityManager，在前一个博客，我们已经基本的看了SecurityManager，大致的主要的架构，现在来看看Subject的主要的源码，学习一下别人这么写的用意何在？自己也是多多的总结很有很好，看看别人的优秀代码。
和上一个一样的
shrio.ini

[users]
zhang=123
wang=123

  Factory.apache.shiro.mgt.SecurityManager> factory =
                new IniSecurityManagerFactory("classpath:shiro.ini");

        //2、得到SecurityManager实例 并绑定给SecurityUtils
        org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);


        //3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");

        try {
            //4、登录，即身份验证
            subject.login(token);
        } catch (AuthenticationException e) {
            //5、身份验证失败
        }

        Assert.assertEquals(true, subject.isAuthenticated()); //断言用户已经登录

        //6、退出
        subject.logout();

SecurityUtils:是一个非常关键的类，这里可以获取到我们的全局的资源，和当前的线程相关的，放置在ThreadLocal里面的，Subject也是如此哦，和当前的环境相关

package org.apache.shiro;

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.ThreadContext;


/**
 * Accesses the currently accessible 
 {@code Subject} for the calling code
 depending on runtime environment.
 *获取Subject，和当前的环境相关
 * @since 0.2
 */
public abstract class SecurityUtils {

    /**
     *ThreadContext 这里保存的是和线程相关的东西，这里只是个备份
     *感觉作用不是很大，这里只是用作在单线程的环境中
     * ONLY used as a 'backup' in VM Singleton environments 
     (that is, standalone environments), since the
     * ThreadContext should always be the primary
         source for Subject instances when possible.
     */
    private static SecurityManager securityManager;

    public static Subject getSubject() {
        Subject subject = ThreadContext.getSubject();
        if (subject == null) {
            subject = (new Subject.Builder()).buildSubject();
            ThreadContext.bind(subject);
        }
        return subject;
    }
    //这里一般都是只在单线程中使用的，
    //获取这个一般在ThreadLoacal中获取，而不是这里哦
    public static void setSecurityManager(SecurityManager securityManager) {
        SecurityUtils.securityManager = securityManager;
    }
    //每次都是先去找线程相关的，然后没有在去在备份的static
    public static SecurityManager getSecurityManager()
            throws UnavailableSecurityManagerException {
        SecurityManager securityManager = ThreadContext.getSecurityManager();
        if (securityManager == null) {
            securityManager = SecurityUtils.securityManager;
        }
        if (securityManager == null) {

            throw new UnavailableSecurityManagerException(msg);
        }
        return securityManager;
    }
}

如我们所知道的，设置securityManager，之后才能绑定到.子进程共享父进程的信息 ThreadLoacl http://blog.csdn.net/jiafu1115/article/details/7548605 这里讲的还不错。http://blog.csdn.net/feier7501/article/details/19088905 这里的例子 笔者也去试了一下子，这种用法太高级了。

public abstract class ThreadContext {

    // 这种唯一的Key设置值得学习一下哦，通过名字
    public static final String SECURITY_MANAGER_KEY = ThreadContext.class.getName() + "_SECURITY_MANAGER_KEY";
    public static final String SUBJECT_KEY = ThreadContext.class.getName() + "_SUBJECT_KEY";

    //这里使用了InheritableThreadLocalMap
    //子线程会接收所有可继承的线程局部变量的初始值，
    //以获得父线程所具有的值。通常，子线程的值与父线程的值是一致的
    //这个就是比较高级的用法了，让子线程也可以获取到
    private static final ThreadLocal> resources = new InheritableThreadLocalMap>();
    protected ThreadContext() {
    }
    //这个每次获取的都是新的哦，线程安全的。
    public static Map getResources() {
        return resources != null ? new HashMap(resources.get()) : null;
    }


    private static Object getValue(Object key) {
        return resources.get().get(key);
    }

    public static Object get(Object key) {
        Object value = getValue(key);        
        return value;
    }


    public static void put(Object key, Object value) {
        if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        }
        if (value == null) {
            remove(key);
            return;
        }
        resources.get().put(key, value);
    }
    public static Object remove(Object key) {
        Object value = resources.get().remove(key);
        return value;
    }
    public static void remove() {
        resources.remove();
    }
    //获取总管家
    public static SecurityManager getSecurityManager() {
        return (SecurityManager) get(SECURITY_MANAGER_KEY);
    }

    public static void bind(SecurityManager securityManager) {
        if (securityManager != null) {
            put(SECURITY_MANAGER_KEY, securityManager);
        }
    }
    public static SecurityManager unbindSecurityManager() {
        return (SecurityManager) remove(SECURITY_MANAGER_KEY);
    }
    public static Subject getSubject() {
        return (Subject) get(SUBJECT_KEY);
    }
    public static void bind(Subject subject) {
        if (subject != null) {
            put(SUBJECT_KEY, subject);
        }
    }

    private static final class InheritableThreadLocalMap> extends InheritableThreadLocal> {
        protected Map initialValue() {
            return new HashMap();
        }

        /**
         * This implementation was added to address a
         * 
         * user-reported issue.
         * @param parentValue the parent value, a HashMap as defined in the {@link #initialValue()} method.
         * @return the HashMap to be used by any parent-spawned child threads (a clone of the parent HashMap).
         */
        @SuppressWarnings({"unchecked"})
        protected Map childValue(Map parentValue) {
            if (parentValue != null) {
                return (Map) ((HashMap) parentValue).clone();
            } else {
                return null;
            }
        }
    }
}

上面的当前线程的值，保存了总管家了，和Subject的信息。Subject和总管家之间的关系如何呢？这个看看创建Subject的时候怎么去处理的。一步步的解开谜底。
之前已经绑定总管家了

 //3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）
        Subject subject = SecurityUtils.getSubject();

–>下一步从当前线程中获取Subject有没有？没有创建一个，通过Subject自己的Build设计模式，创建一个Subject，此时我们跟进Subject里面去看看。public interface Subject，Subject是个接口，Builder是一个内部静态类。这种用法你不会使用吧

public static Subject getSubject() {
        Subject subject = ThreadContext.getSubject();
        if (subject == null) {
            subject = (new Subject.Builder()).buildSubject();
            ThreadContext.bind(subject);
        }
        return subject;
    }

Subject内部结构图可以看到Builder中和管家绑定有关系吧！而且这个接口有很多的权限的查看信息这个和管家里面的继承结构那有关系的，哈哈，代理的模式估计应该就是那样的。这种定义build可以值得学习，用起来比较爽，比如Okhttp好像也是这样的，模式哦很多的默认的参数，也可以自己设置自己喜欢的模式，进行处理。这个就是优点，比如android里面的Dialog的参数设置，你可以自己设置，也可以使用默认的参数。

  public static class Builder {

        /**
         * Hold all contextual data via the Builder instance's method invocations to be sent to the
         * {@code SecurityManager} during the {@link #buildSubject} call.
         数据保持器，在最后调用buildSubject的时候被使用。
         */
        private final SubjectContext subjectContext;
        private final SecurityManager securityManager;

        /**
         * Constructs a new {@link Subject.Builder} instance, 
         using the {@code SecurityManager} instance available
         */
        //这里使用了管家 SubjectContext 保存数据？被
        // sent to the {@code SecurityManager} to create a new {@code Subject} instance.
        public Builder() {
            this(SecurityUtils.getSecurityManager());
        }

        public Builder(SecurityManager securityManager) {
            if (securityManager == null) {
                throw new NullPointerException("null.");
            }
            this.securityManager = securityManager;
            this.subjectContext = newSubjectContextInstance();
            if (this.subjectContext == null) {
                throw new IllegalStateException("newSubjectContextInstance' " +
                        "cannot be null.");
            }
            //这个有点意思了，保存当前管家的一个引用。
            this.subjectContext.setSecurityManager(securityManager);
        }

        /**
         * Creates a new {@code SubjectContext} instance to
         be used to populate with subject contextual data that
         * will then be sent to the {@code SecurityManager}
         to create a new {@code Subject} instance.
         * @return a new {@code SubjectContext} instance
         */
         //这个有点意思，放置在管家中去创建一个Subject
        protected SubjectContext newSubjectContextInstance() {
            return new DefaultSubjectContext();
        }
        //让后代使用
        protected SubjectContext getSubjectContext() {
            return this.subjectContext;
        }

        public Builder sessionId(Serializable sessionId) {
            if (sessionId != null) {
                this.subjectContext.setSessionId(sessionId);
            }
            return this;
        }

        public Builder host(String host) {
            if (StringUtils.hasText(host)) {
                this.subjectContext.setHost(host);
            }
            return this;
        }

        ......
       //这里才是真正的返回实例，这里调用了管家创建的方法
       //SubjectContext 创建的信息，反应到当前的信息当中去处理
        public Subject buildSubject() {
            return this.securityManager.createSubject(this.subjectContext);
        }
    }

DefaultSubjectContext的结构又是如何的？
public class DefaultSubjectContext extends MapContext implements SubjectContext
DefaultSubjectContext 中的信息字段是由MapContext这个类型安全的来维护的，DefaultSubjectContext 中的所有的字段的信息都是放置在Map中的去维护的，且可以指定返回类型的安全性，如果非法，触发异常。MapContext中主要是维护DefaultSubjectContext 中定义的字段的信息。

简单介绍 DefaultSubjectContext 中的信息维护都是这样的类型

//这样可以指定返回的类型哦，不对的话，触发异常
 public SecurityManager getSecurityManager() {
        return getTypedValue(SECURITY_MANAGER, SecurityManager.class);
    }
//非空插入哦
    public void setSecurityManager(SecurityManager securityManager) {
        nullSafePut(SECURITY_MANAGER, securityManager);
    }

MapContext设置得也是比较的精巧，获取的成员变量backingMap 是不允许直接引用的哦

    private final Map backingMap;
    public MapContext() {
        this.backingMap = new HashMap();
    }

不让外面直接的就引用，修改值。

public Set keySet() {
        return Collections.unmodifiableSet(backingMap.keySet());
    }

    public Collection