Shiro中Subject对象的创建与绑定流程分析

    public static Subject getSubject()
    {
        return SecurityUtils.getSubject();
    }

    protected void doFilterInternal(Servletrequest servletrequest, ServletResponse servletResponse, final FilterChain chain)
            throws ServletException, IOException {

        Throwable t = null;

        try {
            final Servletrequest request = prepareServletrequest(servletrequest, servletResponse, chain);
            final ServletResponse response = prepareServletResponse(request, servletResponse, chain);

            //创建Subject
            final Subject subject = createSubject(request, responsE);

            //执行Subject绑定
            //noinspection unchecked
            subject.execute(new Callable() {
                public Object call() throws Exception {
                    updateSessionLastAccessTime(request, responsE);
                    executeChain(request, response, chain);
                    return null;
                }
            });
        } catch (ExecutionException eX) {
            t = ex.getCause();
        } catch (Throwable throwablE) {
            t = throwable;
        }

        if (t != null) {
            if (t instanceof ServletException) {
                throw (ServletException) t;
            }
            if (t instanceof IOException) {
                throw (IOException) t;
            }
            //otherwise it's not one of the two exceptions expected by the filter method signature - wrap it in one:
            String msg = "Filtered request failed.";
            throw new ServletException(msg, t);
        }
    }

    protected WebSubject createSubject(Servletrequest request, ServletResponse responsE) {
        return new WebSubject.builder(getSecuritymanager(), request, responsE).buildWebSubject();
    }

         */
        public Builder(Securitymanager securitymanager, Servletrequest request, ServletResponse responsE) {
            super(securitymanager);
            if (request == null) {
                throw new IllegalArgumentexception("Servletrequest argument cAnnot be null.");
            }
            if (response == null) {
                throw new IllegalArgumentexception("ServletResponse argument cAnnot be null.");
            }
            setrequest(request);
            setResponse(responsE);
        }

        public WebSubject buildWebSubject() {
            Subject subject = super.buildSubject();//父类build方法
            if (!(subject instanceof WebSubject)) {
                String msg = "Subject implementation returned from the Securitymanager was not a " +
                        WebSubject.class.getName() + " implementation.  Please ensure a Web-enabled Securitymanager " +
                        "has been configured and made available to this builder.";
                throw new IllegalStateException(msg);
            }
            return (WebSubject) subject;
        }

        public Subject buildSubject() {
            return this.securitymanager.createSubject(this.subjectContext);
        }

    public Subject createSubject(SubjectContext subjectContext) {
        //create a copy so we don't modify the argument's BACking map:
        SubjectContext context = copy(subjectContext); //复制一个SubjectContext对象

        //ensure that the context has a Securitymanager instance, and if not, add one:
        context = ensureSecuritymanager(context); // 检查并初始化Securitymanager对象

        //Resolve an associated Session (usually based on a referenced session ID), and place it in the context before
        //sending to the SubjectFactory.  The SubjectFactory should not need to know how to acquire sessions as the
        //process is often environment specific - better to shield the SF from these details:
        context = resolveSession(context);//解析获取Sesssion信息

        //Similarly, the SubjectFactory should not require any concept of RememberMe - translate that here first
        //if possible before handing off to the SubjectFactory:
        context = resolvePrincipals(context);//解析获取resolvePrincipals信息

        Subject subject = doCreateSubject(context);//创建Subject

        //save this subject for future reference if necessary:
        //(this is needed here in case rememberMe principals were resolved and they need to be stored in the
        //session, so we don't constantly rehydrate the rememberMe PrincipalCollection on every operation).
        //Added in 1.2:
        save(subject);

        return subject;
    }

    protected Subject doCreateSubject(SubjectContext context) {
        return getSubjectFactory().createSubject(context);
    }

    public Subject createSubject(SubjectContext context) {
        //SHIRO-646
        //check if the exisTing subject is NOT a WebSubject. If it isn't, then call super.createSubject instead.
        //CreaTing a WebSubject from a non-web Subject will cause the Servletrequest and ServletResponse to be null, which wil fail when creaTing a session.
        Boolean isnotBasedOnWebSubject = context.getSubject() != null && !(context.getSubject() instanceof WebSubject);
        if (!(context instanceof WebSubjectContext) || isnotBasedOnWebSubject) {
            return super.createSubject(context);
        }
        //获取上下文对象中的信息
        WebSubjectContext wsc = (WebSubjectContext) context;
        Securitymanager securitymanager = wsc.resolveSecuritymanager();
        Session session = wsc.resolveSession();
        Boolean sessionEnabled = wsc.isSessionCreationEnabled();
        PrincipalCollection principals = wsc.resolvePrincipals();
        Boolean authenticated = wsc.resolveAuthenticated();
        String host = wsc.resolveHost();
        Servletrequest request = wsc.resolveServletrequest();
        ServletResponse response = wsc.resolveServletResponse();

        //构造返回WebDelegaTingSubject对象
        return new WebDelegaTingSubject(principals, authenticated, host, session, sessionEnabled,
                request, response, securitymanager);
    }

         //执行Subject绑定
            //noinspection unchecked
            subject.execute(new Callable() {
                public Object call() throws Exception {
                    updateSessionLastAccessTime(request, responsE);
                    executeChain(request, response, chain);
                    return null;
                }
            });

    public <V> V execute(Callable<V> callablE) throws ExecutionException {
        Callable<V> associated = associateWith(callablE);//初始化一个SubjectCallable对象，并把回调方法传进去
        try {
            return associated.call();
        } catch (Throwable t) {
            throw new ExecutionException(t);
        }
    }


    public <V> Callable<V> associateWith(Callable<V> callablE) {
        return new SubjectCallable<V>(this, callablE);
    }

public class SubjectCallable<V> implements Callable<V> {

    protected final ThreadState threadState;
    private final Callable<V> callable;

    public SubjectCallable(Subject subject, Callable<V> delegatE) {
        this(new SubjectThreadState(subject), delegatE);//初始化构造方法
    }

    protected SubjectCallable(ThreadState threadState, Callable<V> delegatE) {
        if (threadState == null) {
            throw new IllegalArgumentexception("ThreadState argument cAnnot be null.");
        }
        this.threadState = threadState;//SubjectThreadState对象
        if (delegate == null) {
            throw new IllegalArgumentexception("Callable delegate instance cAnnot be null.");
        }
        this.callable = delegate;//回调对象
    }

    public V call() throws Exception {
        try {
            threadState.bind();//执行绑定操作
            return doCall(this.callablE);//执行回调操作
        } finally {
            threadState.restore();
        }
    }

    protected V doCall(Callable<V> target) throws Exception {
        return target.call();
    }
} 

    public void bind() {
        Securitymanager securitymanager = this.securitymanager;
        if ( securitymanager == null ) {
            //try just in case the constructor didn't find one at the time:
            securitymanager = ThReadContext.getSecuritymanager();
        }
        this.originalresources = ThReadContext.getresources();
        ThReadContext.remove();//首先执行remove操作

        ThReadContext.bind(this.subject);//执行绑定操作
        if (securitymanager != null) {
            ThReadContext.bind(securitymanager);
        }
    }

    private static final ThreadLocal<Map<Object, Object>> resources = new InheritableThreadLocalMap<Map<Object, Object>>();//定义一个InheritableThreadLocalMap

    public static void bind(Subject subject) {
        if (subject != null) {
            put(SUBjeCT_KEY, subject);//向InheritableThreadLocalMap中放入Subject对象
        }
    }


    public static void put(Object key, Object value) {
        if (key == null) {
            throw new IllegalArgumentexception("key cAnnot be null");
        }

        if (value == null) {
            remove(key);
            return;
        }

        ensureresourcesInitialized();
        resources.get().put(key, value);

        if (log.isTraceEnabled()) {
            String msg = "Bound value of type [" + value.getClass().getName() + "] for key [" +
                    key + "] to thread " + "[" + Thread.currentThread().getName() + "]";
            log.trace(msg);
        }
    }