7.SessionManager(session生命周期管理)

SessionManager负责管理shiro自己封装的session的生命周期。
为什么shiro要自己封装session？
1.可以为任意应用提供session支持，不依赖于底层容器
2.简单扩容session管理容器，可以实现任何数据源（redis，ehcache）来管理session，而不必担心jvm内存溢出

1.SessionManager

public interface SessionManager {

    //根据指定的上下文SessionContext交由SessionFactory初始化个新的session
    Session start(SessionContext context);

    //根据指定的上下文信息（SessonId..）获取一个session，如果不存在返回null，如果存在但是失效，则抛出异常SessionException
    Session getSession(SessionKey key) throws SessionException;
}

2.AbstractSessionManager

/**AbstractSessionManager是SessionManager的顶层抽象类，主要提供Session存活时间管理的支持,
默认session存活时间是30分钟

deprecate this class (see SHIRO-240):
这个类主要为子类提供一个常用的属性“globalSessionTimeout”的支持，最初设计是为ServletContainerSessionManager
和AbstractNativeSessionManager提供session存活时间管理支持，但是ServletContainerSessionManager的实现并没有
使用该“globalSessionTimeout”，这意味着只有AbstractNativeSessionManager需要使用。所以该类没有存在必要了。
https://issues.apache.org/jira/browse/SHIRO-240
**/
public abstract class AbstractSessionManager implements SessionManager {

    protected static final long MILLIS_PER_SECOND = 1000;
    protected static final long MILLIS_PER_MINUTE = 60 * MILLIS_PER_SECOND;
    protected static final long MILLIS_PER_HOUR = 60 * MILLIS_PER_MINUTE;

    /**
     * Default main session timeout value, equal to {@code 30} minutes.
     */
    public static final long DEFAULT_GLOBAL_SESSION_TIMEOUT = 30 * MILLIS_PER_MINUTE;
    //默认为30分钟
    private long globalSessionTimeout = DEFAULT_GLOBAL_SESSION_TIMEOUT;

    public AbstractSessionManager() {
    }


    public long getGlobalSessionTimeout() {
        return this.globalSessionTimeout;
    }

    //覆盖默认session存活时间30分钟
    public void setGlobalSessionTimeout(long globalSessionTimeout) {
        this.globalSessionTimeout = globalSessionTimeout;
    }
}

3.AbstractNativeSessionManager

/**
该类基础父类AbstractSessionManager和实现NativeSessionManager接口（session操作方法规范）,提供
session的start、stop、Expiration状态的触发通知。
**/
public abstract class AbstractNativeSessionManager extends AbstractSessionManager implements NativeSessionManager {

    private static final Logger log = LoggerFactory.getLogger(AbstractSessionManager.class);
    //SESSION状态的触发通知（start、stop、Expiration）
    private Collection listeners;

    public AbstractNativeSessionManager() {
        this.listeners = new ArrayList();
    }

    public void setSessionListeners(Collection listeners) {
        this.listeners = listeners != null ? listeners : new ArrayList();
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public Collection getSessionListeners() {
        return this.listeners;
    }
    //实现SessionManager接口的start方法
    public Session start(SessionContext context) {
        //创建session
        Session session = createSession(context);
    //设置session过期时间
        applyGlobalSessionTimeout(session);
    //模板方法，子类对创建session后作出反应
        onStart(session, context);
    //创建session成功，迭代SessionListener执行onStart通知
        notifyStart(session);
        //返回一个包装过客户端层session，
        return createExposedSession(session, context);
    }

    //根据上下文SessionContext创建Session，返回的session需要持久化状态，方便以后获取使用
    protected abstract Session createSession(SessionContext context) throws AuthorizationException;
    //设置session过期时间
    protected void applyGlobalSessionTimeout(Session session) {
        session.setTimeout(getGlobalSessionTimeout());
    //session改变模板方法，子类对session改变作出反应。如：保存改变后的session
        onChange(session);
    }

    //模板方法：子类对session start后作出反应
    protected void onStart(Session session, SessionContext context) {
    }
    //根据sessionKey获取Session
    public Session getSession(SessionKey key) throws SessionException {
        Session session = lookupSession(key);
        return session != null ? createExposedSession(session, key) : null;
    }

    private Session lookupSession(SessionKey key) throws SessionException {
        if (key == null) {
            throw new NullPointerException("SessionKey argument cannot be null.");
        }
        return doGetSession(key);
    }
    //获取session，如果session为null则抛异常UnknownSessionException
    private Session lookupRequiredSession(SessionKey key) throws SessionException {
        Session session = lookupSession(key);
        if (session == null) {
            String msg = "Unable to locate required Session instance based on SessionKey [" + key + "].";
            throw new UnknownSessionException(msg);
        }
        return session;
    }
    //子类实现抽象方法根据sessonKey获取session
    protected abstract Session doGetSession(SessionKey key) throws InvalidSessionException;
    //封装返回客户端层session
    protected Session createExposedSession(Session session, SessionContext context) {
        return new DelegatingSession(this, new DefaultSessionKey(session.getId()));
    }
    //封装返回客户端层session
    protected Session createExposedSession(Session session, SessionKey key) {
        return new DelegatingSession(this, new DefaultSessionKey(session.getId()));
    }

    //当session过期或者停止时，需要调用通知。再调用通知前先包装下session为不可变session，防止SessionListener修改
    protected Session beforeInvalidNotification(Session session) {
        //ImmutableProxiedSession的实现即对session凡是有修改意向的方法进行重写为抛异常。
        return new ImmutableProxiedSession(session);
    }

    //session start创建后调用SessionListener的onStart通知
    protected void notifyStart(Session session) {
        for (SessionListener listener : this.listeners) {
            listener.onStart(session);
        }
    }
    //session stop后调用SessionListener的onStop通知
    protected void notifyStop(Session session) {
        Session forNotification = beforeInvalidNotification(session);
        for (SessionListener listener : this.listeners) {
            listener.onStop(forNotification);
        }
    }
    //session Expiration后调用SessionListener的onExpiration通知
    protected void notifyExpiration(Session session) {
        Session forNotification = beforeInvalidNotification(session);
        for (SessionListener listener : this.listeners) {
            listener.onExpiration(forNotification);
        }
    }
    //根据sessionKey 获取session的创建时间
    public Date getStartTimestamp(SessionKey key) {
        return lookupRequiredSession(key).getStartTimestamp();
    }
    //根据sessionKey 获取session最后访问时间
    public Date getLastAccessTime(SessionKey key) {
        return lookupRequiredSession(key).getLastAccessTime();
    }
    //根据sessionKey 获取session过期时间.  负数：则永远不过期 正数：毫秒内有效
    public long getTimeout(SessionKey key) throws InvalidSessionException {
        return lookupRequiredSession(key).getTimeout();
    }
    //根据sessionKey设置session过期时间
    public void setTimeout(SessionKey key, long maxIdleTimeInMillis) throws InvalidSessionException {
        Session s = lookupRequiredSession(key);
        s.setTimeout(maxIdleTimeInMillis);
        onChange(s);
    }
    //根据sessionKey修改session最后访问时间
    public void touch(SessionKey key) throws InvalidSessionException {
        Session s = lookupRequiredSession(key);
        s.touch();
        onChange(s);
    }
    //根据sessionKey获取session 访问IP..
    public String getHost(SessionKey key) {
        return lookupRequiredSession(key).getHost();
    }
    //根据sessionKey 获取session里的设置的属性
    public Collection