shiro源码分析（二）Subject和Session

继续上一篇文章的案例，第一次使用SecurityUtils.getSubject()来获取Subject时 

Java代码  

1. public static Subject getSubject() {  
2.         Subject subject = ThreadContext.getSubject();  
3.         if (subject == null) {  
4.             subject = (new Subject.Builder()).buildSubject();  
5.             ThreadContext.bind(subject);  
6.         }  
7.         return subject;  
8.     }  

  
使用ThreadLocal模式来获取，若没有则创建一个并绑定到当前线程。此时创建使用的是Subject内部类Builder来创建的，Builder会创建一个SubjectContext接口的实例DefaultSubjectContext，最终会委托securityManager来根据SubjectContext信息来创建一个Subject，下面详细说下该过程，在DefaultSecurityManager的createSubject方法中： 

Java代码  

1. public Subject createSubject(SubjectContext subjectContext) {  
2.         SubjectContext context = copy(subjectContext);  
3.   
4.         context = ensureSecurityManager(context);  
5.   
6.         context = resolveSession(context);  
7.   
8.         context = resolvePrincipals(context);  
9.   
10.         Subject subject = doCreateSubject(context);  
11.   
12.         save(subject);  
13.   
14.         return subject;  
15.     }  

首先就是复制SubjectContext，SubjectContext 接口继承了Map<String, Object>，然后加入了几个重要的SecurityManager、SessionId、Subject、PrincipalCollection、Session、boolean authenticated、boolean sessionCreationEnabled、Host、AuthenticationToken、AuthenticationInfo等众多信息。 

然后来讨论下接口设计： 

 

讨论1：首先是SubjectContext为什么要去实现Map<String, Object>？ 
SubjectContext提供了常用的get、set方法，还提供了一个resolve方法，以SecurityManager为例： 

Java代码  

1. SecurityManager getSecurityManager();  
2.   
3.  void setSecurityManager(SecurityManager securityManager);  
4.   
5.  SecurityManager resolveSecurityManager();  

这些get、set方法则用于常用的设置和获取，而resolve则表示先调用getSecurityManager，如果获取不到，则使用其他途径来获取，如DefaultSubjectContext的实现： 

Java代码  

1. public SecurityManager resolveSecurityManager() {  
2.         SecurityManager securityManager = getSecurityManager();  
3.         if (securityManager == null) {  
4.             if (log.isDebugEnabled()) {  
5.                 log.debug("No SecurityManager available in subject context map.  " +  
6.                         "Falling back to SecurityUtils.getSecurityManager() lookup.");  
7.             }  
8.             try {  
9.                 securityManager = SecurityUtils.getSecurityManager();  
10.             } catch (UnavailableSecurityManagerException e) {  
11.                 if (log.isDebugEnabled()) {  
12.                     log.debug("No SecurityManager available via SecurityUtils.  Heuristics exhausted.", e);  
13.                 }  
14.             }  
15.         }  
16.         return securityManager;  
17.     }  

如果getSecurityManager获取不到，则使用SecurityUtils工具来获取。 
再如resolvePrincipals 

Java代码  

1. public PrincipalCollection resolvePrincipals() {  
2.         PrincipalCollection principals = getPrincipals();  
3.   
4.         if (CollectionUtils.isEmpty(principals)) {  
5.             //check to see if they were just authenticated:  
6.             AuthenticationInfo info = getAuthenticationInfo();  
7.             if (info != null) {  
8.                 principals = info.getPrincipals();  
9.             }  
10.         }  
11.   
12.         if (CollectionUtils.isEmpty(principals)) {  
13.             Subject subject = getSubject();  
14.             if (subject != null) {  
15.                 principals = subject.getPrincipals();  
16.             }  
17.         }  
18.   
19.         if (CollectionUtils.isEmpty(principals)) {  
20.             //try the session:  
21.             Session session = resolveSession();  
22.             if (session != null) {  
23.                 principals = (PrincipalCollection) session.getAttribute(PRINCIPALS_SESSION_KEY);  
24.             }  
25.         }  
26.   
27.         return principals;  
28.     }  

普通的getPrincipals()获取不到，尝试使用其他属性来获取。 
讨论2：此时就有一个问题，有必要再对外公开getPrincipals方法吗？什么情况下外界会去调用getPrincipals方法而不会去调用resolvePrincipals方法？ 

然后我们继续回到上面的类图设计上： 
DefaultSubjectContext继承了MapContext，MapContext又实现了Map<String, Object>，看下此时的MapContext有什么东西： 

Java代码  

1. public class MapContext implements Map<String, Object>, Serializable {  
2.   
3.     private static final long serialVersionUID = 5373399119017820322L;  
4.   
5.     private final Map<String, Object> backingMap;  
6.   
7.     public MapContext() {  
8.         this.backingMap = new HashMap<String, Object>();  
9.     }  
10.   
11.     public MapContext(Map<String, Object> map) {  
12.         this();  
13.         if (!CollectionUtils.isEmpty(map)) {  
14.             this.backingMap.putAll(map);  
15.         }  
16.     }  
17.   //略  
18. }  

MapContext内部拥有一个类型为HashMap的backingMap属性，大部分方法都由HashMap来实现，然后仅仅更改某些行为，MapContext没有选择去继承HashMap，而是使用了组合的方式，更加容易去扩展，如backingMap的类型不一定非要选择HashMap，可以换成其他的Map实现，一旦MapContext选择继承HashMap，如果想对其他的Map类型进行同样的功能增强的话，就需要另写一个类来继承它然后改变一些方法实现，这样的话就会有很多重复代码。这也是设计模式所强调的少用继承多用组合。但是MapContext的写法使得子类没法去替换HashMap，哎，心塞 。 
MapContext又提供了如下几个返回值不可修改的方法： 

Java代码  

1. public Set<String> keySet() {  
2.         return Collections.unmodifiableSet(backingMap.keySet());  
3.     }  
4.   
5.     public Collection<Object> values() {  
6.         return Collections.unmodifiableCollection(backingMap.values());  
7.     }  
8.   
9.     public Set<Entry<String, Object>> entrySet() {  
10.         return Collections.unmodifiableSet(backingMap.entrySet());  
11.     }  

有点扯远了。继续回到DefaultSecurityManager创建Subject的地方： 

Java代码  

1. public Subject createSubject(SubjectContext subjectContext) {  
2.         //create a copy so we don't modify the argument's backing map:  
3.         SubjectContext context = copy(subjectContext);  
4.   
5.         //ensure that the context has a SecurityManager instance, and if not, add one:  
6.         context = ensureSecurityManager(context);  
7.   
8.         //Resolve an associated Session (usually based on a referenced session ID), and place it in the context before  
9.         //sending to the SubjectFactory.  The SubjectFactory should not need to know how to acquire sessions as the  
10.         //process is often environment specific - better to shield the SF from these details:  
11.         context = resolveSession(context);  
12.   
13.         //Similarly, the SubjectFactory should not require any concept of RememberMe - translate that here first  
14.         //if possible before handing off to the SubjectFactory:  
15.         context = resolvePrincipals(context);  
16.   
17.         Subject subject = doCreateSubject(context);  
18.   
19.         //save this subject for future reference if necessary:  
20.         //(this is needed here in case rememberMe principals were resolved and they need to be stored in the  
21.         //session, so we don't constantly rehydrate the rememberMe PrincipalCollection on every operation).  
22.         //Added in 1.2:  
23.         save(subject);  
24.   
25.         return subject;  
26.     }  

对于context，把能获取到的参数都凑齐，SecurityManager、Session。resolveSession尝试获取context的map中获取Session，若没有则尝试获取context的map中的Subject，如果存在的话，根据此Subject来获取Session，若没有再尝试获取sessionId,若果有了sessionId则构建成一个DefaultSessionKey来获取对应的Session。 
整个过程如下; 

Java代码  

1. protected SubjectContext resolveSession(SubjectContext context) {  
2.         if (context.resolveSession() != null) {  
3.             log.debug("Context already contains a session.  Returning.");  
4.             return context;  
5.         }  
6.         try {  
7.             //Context couldn't resolve it directly, let's see if we can since we have direct access to   
8.             //the session manager:  
9.             Session session = resolveContextSession(context);  
10.             if (session != null) {  
11.                 context.setSession(session);  
12.             }  
13.         } catch (InvalidSessionException e) {  
14.             log.debug("Resolved SubjectContext context session is invalid.  Ignoring and creating an anonymous " +  
15.                     "(session-less) Subject instance.", e);  
16.         }  
17.         return context;  
18.     }  

先看下context.resolveSession()： 

Java代码  

1. public Session resolveSession() {  
2.   //这里则是直接从map中取出Session  
3.         Session session = getSession();  
4.         if (session == null) {  
5.             //try the Subject if it exists:  
6.            //若果没有，尝试从map中取出Subject   
7.             Subject existingSubject = getSubject();  
8.             if (existingSubject != null) {  
9.                 //这里就是Subject获取session的方法，需要详细看下  
10.                 session = existingSubject.getSession(false);  
11.             }  
12.         }  
13.         return session;  
14.     }  

existingSubject.getSession(false)：通过Subject获取Session如下 

Java代码  

1. public Session getSession(boolean create) {  
2.         if (log.isTraceEnabled()) {  
3.             log.trace("attempting to get session; create = " + create +  
4.                     "; session is null = " + (this.session == null) +  
5.                     "; session has id = " + (this.session != null && session.getId() != null));  
6.         }  
7.   
8.         if (this.session == null && create) {  
9.   
10.             //added in 1.2:  
11.             if (!isSessionCreationEnabled()) {  
12.                 String msg = "Session creation has been disabled for the current subject.  This exception indicates " +  
13.                         "that there is either a programming error (using a session when it should never be " +  
14.                         "used) or that Shiro's configuration needs to be adjusted to allow Sessions to be created " +  
15.                         "for the current Subject.  See the " + DisabledSessionException.class.getName() + " JavaDoc " +  
16.                         "for more.";  
17.                 throw new DisabledSessionException(msg);  
18.             }  
19.   
20.             log.trace("Starting session for host {}", getHost());  
21.             SessionContext sessionContext = createSessionContext();  
22.             Session session = this.securityManager.start(sessionContext);  
23.             this.session = decorate(session);  
24.         }  
25.         return this.session;  
26.     }  

getSession（）的参数表示是否创建session，如果Session为空，并且传递的参数为true，则会创建一个Session。然而这里传递的是false，也就是说不会在创建Subject的时候来创建Session，所以把创建Session过程说完后，再回到此处是要记着不会去创建一个Session。但是我们可以来看下是如何创建Session的，整体三大步骤，先创建一个SessionContext ，然后根据SessionContext 来创建Session，最后是装饰Session,由于创建Session过程内容比较多，先说说装饰Session。 

Java代码  

1. protected Session decorate(Session session) {  
2.         if (session == null) {  
3.             throw new IllegalArgumentException("session cannot be null");  
4.         }  
5.         return new StoppingAwareProxiedSession(session, this);  
6.     }  

装饰Session就是讲Session和DelegatingSubject封装起来。 
然后来说Session的创建过程，这和Subject的创建方式差不多。 
同样是SessionContext的接口设计： 

 
和SubjectContext相当雷同。 
看下SessionContext的主要内容: 

Java代码  

1. void setHost(String host);  
2.     String getHost();  
3.   
4.     Serializable getSessionId();  
5.   
6.     void setSessionId(Serializable sessionId);  

主要两个内容，host和sessionId。 
接下来看下如何由SessionContext来创建Session: 

Java代码  

1. protected Session doCreateSession(SessionContext context) {  
2.         Session s = newSessionInstance(context);  
3.         if (log.isTraceEnabled()) {  
4.             log.trace("Creating session for host {}", s.getHost());  
5.         }  
6.         create(s);  
7.         return s;  
8.     }  
9.   
10.     protected Session newSessionInstance(SessionContext context) {  
11.         return getSessionFactory().createSession(context);  
12.     }  

和Subject一样也是由一个SessionFactory根据SessionContext来创建出一个Session，看下默认的SessionFactory SimpleSessionFactory的创建过程： 

Java代码  

1. public Session createSession(SessionContext initData) {  
2.         if (initData != null) {  
3.             String host = initData.getHost();  
4.             if (host != null) {  
5.                 return new SimpleSession(host);  
6.             }  
7.         }  
8.         return new SimpleSession();  
9.     }  

如果SessionContext有host信息，就传递给Session，然后就是直接new一个Session接口的实现SimpleSession，先看下Session接口有哪些内容： 

Java代码  

1. public interface Session {  
2.     Serializable getId();  
3.     Date getStartTimestamp();  
4.     Date getLastAccessTime();  
5.     long getTimeout() throws InvalidSessionException;  
6.     void setTimeout(long maxIdleTimeInMillis) throws InvalidSessionException;  
7.     String getHost();  
8.     void touch() throws InvalidSessionException;  
9.     void stop() throws InvalidSessionException;  
10.     Collection<Object> getAttributeKeys() throws InvalidSessionException;  
11.     Object getAttribute(Object key) throws InvalidSessionException;  
12.     void setAttribute(Object key, Object value) throws InvalidSessionException;  
13.     Object removeAttribute(Object key) throws InvalidSessionException;  
14. }  

id:Session的唯一标识，创建时间、超时时间等内容。 
再看SimpleSession的创建过程： 

Java代码  

1. public SimpleSession() {  
2.         this.timeout = DefaultSessionManager.DEFAULT_GLOBAL_SESSION_TIMEOUT;  
3.         this.startTimestamp = new Date();  
4.         this.lastAccessTime = this.startTimestamp;  
5.     }  
6.   
7.     public SimpleSession(String host) {  
8.         this();  
9.         this.host = host;  
10.     }  

设置下超时时间为DefaultSessionManager.DEFAULT_GLOBAL_SESSION_TIMEOUT 30分钟，startTimestamp 和lastAccessTime设置为现在开始。就这样构建出了一个Session的实例，然后就是需要将该实例保存起来： 

Java代码  

1. protected Session doCreateSession(SessionContext context) {  
2.         Session s = newSessionInstance(context);  
3.         if (log.isTraceEnabled()) {  
4.             log.trace("Creating session for host {}", s.getHost());  
5.         }  
6.         create(s);  
7.         return s;  
8.     }  
9. protected void create(Session session) {  
10.         if (log.isDebugEnabled()) {  
11.             log.debug("Creating new EIS record for new session instance [" + session + "]");  
12.         }  
13.         sessionDAO.create(session);  
14.     }  

即该进行create(s)操作了，又和Subject极度的相像，使用sessionDAO来保存刚才创建的Session。再来看下SessionDAO接口： 

Java代码  

1. public interface SessionDAO {  
2.     Serializable create(Session session);  
3.     Session readSession(Serializable sessionId) throws UnknownSessionException;  
4.     void update(Session session) throws UnknownSessionException;  
5.     void delete(Session session);  
6.     Collection<Session> getActiveSessions();  
7. }  

也就是对所有的Session进行增删该查，SessionDAO 接口继承关系如下： 

 
AbstractSessionDAO：有一个重要的属性SessionIdGenerator，它负责给Session创建sessionId，SessionIdGenerator接口如下： 

Java代码  

1. public interface SessionIdGenerator {  
2.     Serializable generateId(Session session);  
3. }  

很简单，参数为Session，返回sessionId。SessionIdGenerator 的实现有两个JavaUuidSessionIdGenerator、RandomSessionIdGenerator。而AbstractSessionDAO默认采用的是JavaUuidSessionIdGenerator，如下： 

Java代码  

1. public AbstractSessionDAO() {  
2.         this.sessionIdGenerator = new JavaUuidSessionIdGenerator();  
3.     }  

MemorySessionDAO继承了AbstractSessionDAO，它把Session存储在一个ConcurrentMap<Serializable, Session> sessions集合中，key为sessionId，value为Session。 
CachingSessionDAO：主要配合在别的地方存储session。先不介绍，之后的文章再详细说。 
对于本案例来说SessionDAO为MemorySessionDAO。至此整个Session的创建过程就走通了。 

刚才虽然说了整个Session的创建过程，回到上文所说的，不会去创建Session的地方。在创建Subject搜集session信息时，使用的此时的Subject的Session、sessionId都为空，所以获取不到Session。然后就是doCreateSubject： 

Java代码  

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

就是通过SubjectFactory工厂接口来创建Subject的，而DefaultSecurityManager默认使用的 
SubjectFactory是DefaultSubjectFactory： 

Java代码  

1. public DefaultSecurityManager() {  
2.         super();  
3.         this.subjectFactory = new DefaultSubjectFactory();  
4.         this.subjectDAO = new DefaultSubjectDAO();  
5.     }  

继续看DefaultSubjectFactory是怎么创建Subject的： 

Java代码  

1. public Subject createSubject(SubjectContext context) {  
2.         SecurityManager securityManager = context.resolveSecurityManager();  
3.         Session session = context.resolveSession();  
4.         boolean sessionCreationEnabled = context.isSessionCreationEnabled();  
5.         PrincipalCollection principals = context.resolvePrincipals();  
6.         boolean authenticated = context.resolveAuthenticated();  
7.         String host = context.resolveHost();  
8.   
9.         return new DelegatingSubject(principals, authenticated, host, session, sessionCreationEnabled, securityManager);  
10.     }  

仍然就是将这些属性传递给DelegatingSubject，也没什么好说的。创建完成之后，就需要将刚创建的Subject保存起来，仍回到： 

Java代码  

1. public Subject createSubject(SubjectContext subjectContext) {  
2.         //create a copy so we don't modify the argument's backing map:  
3.         SubjectContext context = copy(subjectContext);  
4.   
5.         //ensure that the context has a SecurityManager instance, and if not, add one:  
6.         context = ensureSecurityManager(context);  
7.   
8.         //Resolve an associated Session (usually based on a referenced session ID), and place it in the context before  
9.         //sending to the SubjectFactory.  The SubjectFactory should not need to know how to acquire sessions as the  
10.         //process is often environment specific - better to shield the SF from these details:  
11.         context = resolveSession(context);  
12.   
13.         //Similarly, the SubjectFactory should not require any concept of RememberMe - translate that here first  
14.         //if possible before handing off to the SubjectFactory:  
15.         context = resolvePrincipals(context);  
16.   
17.         Subject subject = doCreateSubject(context);  
18.   
19.         //save this subject for future reference if necessary:  
20.         //(this is needed here in case rememberMe principals were resolved and they need to be stored in the  
21.         //session, so we don't constantly rehydrate the rememberMe PrincipalCollection on every operation).  
22.         //Added in 1.2:  
23.         save(subject);  
24.   
25.         return subject;  
26.     }  

来看下save方法： 

Java代码  

1. protected void save(Subject subject) {  
2.         this.subjectDAO.save(subject);  
3.     }  

可以看到又是使用另一个模块来完成的即SubjectDAO，SubjectDAO接口如下： 

Java代码  

1. public interface SubjectDAO {  
2.     Subject save(Subject subject);  
3.     void delete(Subject subject);  
4. }  

很简单，就是保存和删除一个Subject。我们看下具体的实现类DefaultSubjectDAO是如何来保存的： 

Java代码  

1. public Subject save(Subject subject) {  
2.         if (isSessionStorageEnabled(subject)) {  
3.             saveToSession(subject);  
4.         } else {  
5.             log.trace("Session storage of subject state for Subject [{}] has been disabled: identity and " +  
6.                     "authentication state are expected to be initialized on every request or invocation.", subject);  
7.         }  
8.   
9.         return subject;  
10.     }  

首先就是判断isSessionStorageEnabled，是否要存储该Subject的session来 
DefaultSubjectDAO：有一个重要属性SessionStorageEvaluator，它是用来决定一个Subject的Session来记录Subject的状态，接口如下 

Java代码  

1. public interface SessionStorageEvaluator {  
2.     boolean isSessionStorageEnabled(Subject subject);  
3. }  

其实现为DefaultSessionStorageEvaluator： 

Java代码  

1. public class DefaultSessionStorageEvaluator implements SessionStorageEvaluator {  
2.   
3.     private boolean sessionStorageEnabled = true;  
4.   
5.     public boolean isSessionStorageEnabled(Subject subject) {  
6.         return (subject != null && subject.getSession(false) != null) || isSessionStorageEnabled();  
7.     }  

决定策略就是通过DefaultSessionStorageEvaluator 的sessionStorageEnabled的true或false 和subject是否有Session对象来决定的。如果允许存储Subject的Session的话，下面就说具体的存储过程： 

Java代码  

1. protected void saveToSession(Subject subject) {  
2.         //performs merge logic, only updating the Subject's session if it does not match the current state:  
3.         mergePrincipals(subject);  
4.         mergeAuthenticationState(subject);  
5.     }  
6. protected void mergePrincipals(Subject subject) {  
7.         //merge PrincipalCollection state:  
8.   
9.         PrincipalCollection currentPrincipals = null;  
10.   
11.         //SHIRO-380: added if/else block - need to retain original (source) principals  
12.         //This technique (reflection) is only temporary - a proper long term solution needs to be found,  
13.         //but this technique allowed an immediate fix that is API point-version forwards and backwards compatible  
14.         //  
15.         //A more comprehensive review / cleaning of runAs should be performed for Shiro 1.3 / 2.0 +  
16.         if (subject.isRunAs() && subject instanceof DelegatingSubject) {  
17.             try {  
18.                 Field field = DelegatingSubject.class.getDeclaredField("principals");  
19.                 field.setAccessible(true);  
20.                 currentPrincipals = (PrincipalCollection)field.get(subject);  
21.             } catch (Exception e) {  
22.                 throw new IllegalStateException("Unable to access DelegatingSubject principals property.", e);  
23.             }  
24.         }  
25.         if (currentPrincipals == null || currentPrincipals.isEmpty()) {  
26.             currentPrincipals = subject.getPrincipals();  
27.         }  
28.   
29.         Session session = subject.getSession(false);  
30.   
31.         if (session == null) {  
32.            //只有当Session为空，并且currentPrincipals不为空的时候才会去创建Session  
33.            //Subject subject = SecurityUtils.getSubject()此时两者都是为空的，  
34.            //不会去创建Session  
35.             if (!CollectionUtils.isEmpty(currentPrincipals)) {  
36.                 session = subject.getSession();  
37.                 session.setAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY, currentPrincipals);  
38.             }  
39.             //otherwise no session and no principals - nothing to save  
40.         } else {  
41.             PrincipalCollection existingPrincipals =  
42.                     (PrincipalCollection) session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);  
43.   
44.             if (CollectionUtils.isEmpty(currentPrincipals)) {  
45.                 if (!CollectionUtils.isEmpty(existingPrincipals)) {  
46.                     session.removeAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);  
47.                 }  
48.                 //otherwise both are null or empty - no need to update the session  
49.             } else {  
50.                 if (!currentPrincipals.equals(existingPrincipals)) {  
51.                     session.setAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY, currentPrincipals);  
52.                 }  
53.                 //otherwise they're the same - no need to update the session  
54.             }  
55.         }  
56.     }  

上面有我们关心的重点，当subject.getSession(false)获取的Session为空时（它不会去创建Session），此时就需要去创建Session，subject.getSession()则默认调用的是subject.getSession(true),则会进行Session的创建，创建过程上文已详细说明了。 
在第一次创建Subject的时候 

Java代码  

1. Subject subject = SecurityUtils.getSubject();    

虽然Session为空，但此时还没有用户身份信息，也不会去创建Session。案例中的subject.login(token)，该过程则会去创建Session，具体看下过程： 

Java代码  

1. public Subject login(Subject subject, AuthenticationToken token) throws AuthenticationException {  
2.         AuthenticationInfo info;  
3.         try {  
4.             info = authenticate(token);  
5.         } catch (AuthenticationException ae) {  
6.             try {  
7.                 onFailedLogin(token, ae, subject);  
8.             } catch (Exception e) {  
9.                 if (log.isInfoEnabled()) {  
10.                     log.info("onFailedLogin method threw an " +  
11.                             "exception.  Logging and propagating original AuthenticationException.", e);  
12.                 }  
13.             }  
14.             throw ae; //propagate  
15.         }  
16.          //在该过程会进行Session的创建  
17.         Subject loggedIn = createSubject(token, info, subject);  
18.   
19.         onSuccessfulLogin(token, info, loggedIn);  
20.   
21.         return loggedIn;  
22.     }  

对于验证过程上篇文章已经简单说明了，这里不再说明，重点还是在验证通过后，会设置Subject的身份，即用户名： 

Java代码  

1. protected Subject createSubject(AuthenticationToken token, AuthenticationInfo info, Subject existing) {  
2.         SubjectContext context = createSubjectContext();  
3.         context.setAuthenticated(true);  
4.         context.setAuthenticationToken(token);  
5.         context.setAuthenticationInfo(info);  
6.         if (existing != null) {  
7.             context.setSubject(existing);  
8.         }  
9.         return createSubject(context);  
10.     }  

有了认证成功的AuthenticationInfo信息，SubjectContext在resolvePrincipals便可以获取用户信息，即通过AuthenticationInfo的getPrincipals()来获得。 

Java代码  

1. public PrincipalCollection resolvePrincipals() {  
2.         PrincipalCollection principals = getPrincipals();  
3.   
4.         if (CollectionUtils.isEmpty(principals)) {  
5.             //check to see if they were just authenticated:  
6.             AuthenticationInfo info = getAuthenticationInfo();  
7.             if (info != null) {  
8.                 principals = info.getPrincipals();  
9.             }  
10.         }  
11.   
12.         if (CollectionUtils.isEmpty(principals)) {  
13.             Subject subject = getSubject();  
14.             if (subject != null) {  
15.                 principals = subject.getPrincipals();  
16.             }  
17.         }  
18.   
19.         if (CollectionUtils.isEmpty(principals)) {  
20.             //try the session:  
21.             Session session = resolveSession();  
22.             if (session != null) {  
23.                 principals = (PrincipalCollection) session.getAttribute(PRINCIPALS_SESSION_KEY);  
24.             }  
25.         }  
26.   
27.         return principals;  
28.     }  

PrincipalCollection不为空了，在save(subject)的时候会得到session为空，同时PrincipalCollection不为空，则会执行Session的创建。也就是说在认证通过后，会执行Session的创建，Session创建完成之后会进行一次装饰，即用StoppingAwareProxiedSession将创建出来的session和subject关联起来，然后又进行如下操作： 

Java代码  

1. public void login(AuthenticationToken token) throws AuthenticationException {  
2.         clearRunAsIdentitiesInternal();  
3.         //这里的Subject则是经过认证后创建的并且也含有刚才创建的session，类型为  
4.         //StoppingAwareProxiedSession，即是该subject本身和session的合体。  
5.         Subject subject = securityManager.login(this, token);  
6.   
7.         PrincipalCollection principals;  
8.   
9.         String host = null;  
10.   
11.         if (subject instanceof DelegatingSubject) {  
12.             DelegatingSubject delegating = (DelegatingSubject) subject;  
13.             //we have to do this in case there are assumed identities - we don't want to lose the 'real' principals:  
14.             principals = delegating.principals;  
15.             host = delegating.host;  
16.         } else {  
17.             principals = subject.getPrincipals();  
18.         }  
19.   
20.         if (principals == null || principals.isEmpty()) {  
21.             String msg = "Principals returned from securityManager.login( token ) returned a null or " +  
22.                     "empty value.  This value must be non null and populated with one or more elements.";  
23.             throw new IllegalStateException(msg);  
24.         }  
25.         this.principals = principals;  
26.         this.authenticated = true;  
27.         if (token instanceof HostAuthenticationToken) {  
28.             host = ((HostAuthenticationToken) token).getHost();  
29.         }  
30.         if (host != null) {  
31.             this.host = host;  
32.         }  
33.         Session session = subject.getSession(false);  
34.         if (session != null) {  
35.             //在这里可以看到又进行了一次装饰  
36.             this.session = decorate(session);  
37.         } else {  
38.             this.session = null;  
39.         }  
40.     }  

subject 创建出来之后，暂且叫内部subject，就是把认证通过的内部subject的信息和session复制给我们外界使用的subject.login(token)的subject中，这个subject暂且叫外部subject，看下session的赋值，又进行了一次装饰，这次装饰则把session(类型为StoppingAwareProxiedSession，即是内部subject和session的合体)和外部subject绑定到一起。 
最后来总结下，首先是Subject和Session的接口类图： 


然后就是Subject subject = SecurityUtils.getSubject()的一个简易的流程图： 


最后是subject.login(token)的简易流程图：