文档章节

Shiro源码分析(2) - 会话管理器(SessionManager)

xiaoqiyiye
 xiaoqiyiye
发布于 2018/02/04 21:58
字数 4747
阅读 526
收藏 1
本文在于分析Shiro源码,对于新学习的朋友可以参考
[开涛博客](http://jinnianshilongnian.iteye.com/blog/2018398)进行学习。

本文对Shiro中的SessionManager进行分析,SessionManager用于管理Shiro中的Session信息。Session也就是我们通常说的会话,会话是用户在使用应用程序一段时间内携带的数据。传统的会话一般是基于Web容器(如:Tomcat、EJB环境等)。Shiro提供的Session可以在任何环境中使用,不再依赖于其他容器。

Shiro还提供了一些其他的特性:

  • 基于POJO/J2SE:Session和SessionManager都是基于接口实现的,可以通过POJO来进行实现。可以使用任务JavaBean兼容的格式(如:Json,YAML,spring xml或类似机制)来轻松配置所有会话组件。能够根据需要完全地扩展会话组件。
  • 会话存储:因为Shiro的Session对象是基于POJO的,所以会话数据可以容易地存储在任何数据源中。 这允许您精确定制应用程序的会话数据所在的位置,例如文件系统,企业缓存,关系数据库或专有数据存储。
  • 简单强大的集群:Shiro的Session可以通过缓存来实现集群功能,这样的Session并不会依赖于Web容器,不需要对Web容器进行特殊的配置。
  • 事件监听:事件监听器允许在会话生命周期中接受生命周期事件,可以监听这些事件并对自定义应用程序行为做出反应。例如,在会话过期时更新用户记录。
  • 主机地址保留:会记录Session创建时的IP地址。
  • 会话过期:会话由于预期的不活动而过期,但如果需要,可以通过touch()方法延长活动以保持活动状态。

Session接口定义

Shiro提供的Session和Servlet中的Session其实是一样的作用,只是Shiro中的Sesion不需要再依赖于WEB容器存在。下面是Session接口提供的方法:

/**
 * 返回表示Session的唯一ID
 */
Serializable getId();

/**
 * 返回Session的开始时间
 */
Date getStartTimestamp();

/**
 * 返回最近使用的时间
 */
Date getLastAccessTime();

/**
 * 返回还有多久Session过期(毫秒)
 */
long getTimeout() throws InvalidSessionException;

/**
 * 设置超时时间(毫秒)
 */
void setTimeout(long maxIdleTimeInMillis) throws InvalidSessionException;    

/**
 * 返回Session创建时的主机名或地址
 */
String getHost();

/**
 * 更新最近访问时间,确保Session不会过期
 */
void touch() throws InvalidSessionException;

/**
 * 设置Session停止使用,并释放相关资源
 */
void stop() throws InvalidSessionException;

/**
 * 返回该Session存储的所有属性键
 */
Collection<Object> getAttributeKeys() throws InvalidSessionException;

/**
 * 获取Session属性
 */
Object getAttribute(Object key) throws InvalidSessionException;

/**
 * 设置Session属性
 */
void setAttribute(Object key, Object value) throws InvalidSessionException;

/**
 * 删除Session属性
 */
Object removeAttribute(Object key) throws InvalidSessionException;

从接口中我们可以看出。Session有一个唯一ID,开始时间,最近活动时间等属性,另外提供了两个相对应的方法touch()和stop(),其他方法就是对属性的操作了。Session接口还是相当简单清晰的,下面我们看看接口的实现类。

Session有一些实现类,包括SimpleSession、HttpServletSession和DelegatingSession等。SimpleSession是Shiro提供的一种简单实现,HttpServletSession是基于Sevlet中Session来实现的,DelegatingSession是一种委托机制,委托给SessionManager来实现。下面,我们主要以SimpleSession和DelegatingSession来分析。

SimpleSession实现

SimpleSession从Session接口继承过来的方法实现非常简单,就不过多分析了。我们主要分析一下属性,通过属性就可以了解到SimpleSession中功能的实现了。

// Session唯一ID
private transient Serializable id;
// 开始时间
private transient Date startTimestamp;
// 结束时间
private transient Date stopTimestamp;
// 最近访问时间
private transient Date lastAccessTime;
// 还有多久过期
private transient long timeout;
// 是否过期
private transient boolean expired;
// Session创建时的主机名
private transient String host;
// Session存储的属性值
private transient Map<Object, Object> attributes;

DelegatingSession实现

DelegatingSession是一种委托实现方式,所有的操作都委托给SessionManager接口来实现。我们还是先看有哪些属性。

// SessionKey就是Session唯一ID的对象形式
private final SessionKey key;

// 委派给NativeSessionManager对象,这是SessionManager接口的一个子接口
private final transient NativeSessionManager sessionManager;

很显然,DelegatingSession的委托方式是用过SessionKey从SessionManager中获取相应的Session来进行处理的。在SessionManager中管理着很多Session。

在分析SessionManager前,先说明一下SessionContext这个接口(上一篇中提到过 )。SessionContext表示的是Session创建时的上下文参数,SessionContext有DefaultSessionContext,DefaultWebSessionContext两个实现。但功能都是从MapContext继承来,简单地说SessionContext就是一个Map对象,提供了一个更方便获取具体类型的方法getTypedValue(String key, Class<E> type)。

SessionManager分析

SessionManager管理着Session的创建、操作以及清除等。SessionManager有一些子接口,包括NativeSessionManager、ValidatingSessionManager和WebSessionManager。每个接口都提供了相关的抽象类AbstractSessionManager、AbstractNativeSessionManager、AbstractValidatingSessionManager。我们还是先看看接口提供了哪些方法。

public interface SessionManager {

    /**
     * 开始一个新的Session,context提供一些初始化的数据
     */
    Session start(SessionContext context);

    /**
     * 通过SessionKey查找Session
     * 如果存在则被找到,如果不存在则返回null;如果找到的Session无效(被停止或过期)则会抛异常
     */
    Session getSession(SessionKey key) throws SessionException;
}   


public interface NativeSessionManager extends SessionManager {

    /**
     * 返回Session被开启的时间
     */
    Date getStartTimestamp(SessionKey key);

    /**
     * 获取Session最近访问的时间
     */
    Date getLastAccessTime(SessionKey key);

    /**
     * 判断Session是否有效
     */
    boolean isValid(SessionKey key);

    /**
     * 检测Session是否有效,如果无效则抛出异常
     */
    void checkValid(SessionKey key) throws InvalidSessionException;

    /**
     * 返回Session还有多久过期(毫秒)
     * 如果是负数,表示Session不会过期;如果是正数,表示Session在这个时间后就会过期。
     * 如果Session无效调用这个方法会抛异常
     */
    long getTimeout(SessionKey key) throws InvalidSessionException;

    /**
     * 设置过期时间(毫秒),设置负数表示Session不会过期。
     * 如果Session无效调用这个方法会抛异常
     */
    void setTimeout(SessionKey key, long maxIdleTimeInMillis) throws InvalidSessionException;

    /**
     * 会设置最近访问时间,确保Session没有超时,当然,如果Session已经无效也会抛异常
     */
    void touch(SessionKey key) throws InvalidSessionException;

    /**
     * 返回主机名或Ip
     */
    String getHost(SessionKey key);

    /**
     * 停用Session,释放资源
     */
    void stop(SessionKey key) throws InvalidSessionException;

    /**
     * 返回Session中存储的所有属性键
     */
    Collection<Object> getAttributeKeys(SessionKey sessionKey);

    /**
     * 获取Session中的属性
     */
    Object getAttribute(SessionKey sessionKey, Object attributeKey) throws InvalidSessionException;

    /**
     * 设置Session中的属性
     */
    void setAttribute(SessionKey sessionKey, Object attributeKey, Object value) throws InvalidSessionException;

    /**
     * 删除Session中的属性
     */
    Object removeAttribute(SessionKey sessionKey, Object attributeKey) throws InvalidSessionException;

}


public interface ValidatingSessionManager extends SessionManager {

    /**
     * 为那些有效的Session进行校验,如果Session发现是无效的,将会被更改。
     * 这个方法期望有规律的运行,如1小时一次,一天一次或一星期一次。运行的频率取决于应用的性能,用户活跃数等。
     */
    void validateSessions();
}

从上面的接口中可以看出,SessionManager主要负责创建Session和获取Session,NativeSessionManager接口中包含了所有对Session的操作,这些操作方法和Session接口中是一致的,而ValidatingSessionManager接口提供了对Session校验的支持。这些接口从功能上分工很明确。


AbstractNativeSessionManager分析

AbstractNativeSessionManager类对NativeSessionManager接口做了一个整体的结构实现,定型了整个接口的实现基础。我们先列出AbstractNativeSessionManager中主要功能:

  • 引用了SessionListen接口来负责对Session状态的监听。
  • 提供了创建Session的抽象方法createSession(SessionContext context)和获取Session的抽象方法doGetSession(SessionKey key),这两个方法都应该从SessionManager接口来实现的。
  • 提供了onChange,onStart,onStop,afterStopped钩子方法。

我们先分析SessionManager中的两个方法。start(SessionContext context)和getSession(SessionKey key)。

public Session start(SessionContext context) {
    // 抽象方法创建Session
    Session session = createSession(context);
    applyGlobalSessionTimeout(session);
    // 钩子方法,子类实现
    onStart(session, context);
    // Session监听器
    notifyStart(session);
    // 使用DelegatingSession来委托SessionManger处理
    return createExposedSession(session, context);
}

protected Session createExposedSession(Session session, SessionContext context) {
	return new DelegatingSession(this, new DefaultSessionKey(session.getId()));
}

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状态的监听:Session启动,Session停止,Session过期。

protected void notifyStart(Session session) {
    for (SessionListener listener : this.listeners) {
        listener.onStart(session);
    }
}

protected void notifyStop(Session session) {
    Session forNotification = beforeInvalidNotification(session);
    for (SessionListener listener : this.listeners) {
        listener.onStop(forNotification);
    }
}

protected void notifyExpiration(Session session) {
    Session forNotification = beforeInvalidNotification(session);
    for (SessionListener listener : this.listeners) {
        listener.onExpiration(forNotification);
    }
}

最后,我们再看看对NativeSessionManager接口方法的实现,方法很多,基本上实现思路一样。我们以touch和stop来说明。

public void touch(SessionKey key) throws InvalidSessionException {
    // 获取Session
    Session s = lookupRequiredSession(key);
    // 调用Session自己提供的功能
    s.touch();
    // 调用onChange方法作为变更后的后置处理方法
    onChange(s);
}

public void stop(SessionKey key) throws InvalidSessionException {
    // 获取Session
    Session session = lookupRequiredSession(key);
    try {
        if (log.isDebugEnabled()) {
            log.debug("Stopping session with id [" + session.getId() + "]");
        }
        // 调用Session自己提供的功能
        session.stop();
        // 调用后置处理方法
        onStop(session, key);
        // 通知监听器
        notifyStop(session);
    } finally {
        // 调用停止后的后置方法
        afterStopped(session);
    }
}

我们可以给AbstractNativeSessionManager类作一个总结。该类负责管理Session的操作,但操作的具体实现是由Session自己实现的。相当于对Session操作前后做代理(不管是提供钩子方法还是监听Session)。


AbstractValidatingSessionManager分析

AbstractValidatingSessionManager的作用是定期的校验所有有效的Session状态,因为Session可能被停止或过期。AbstractValidatingSessionManager类继承了上面分析的AbstractNativeSessionManager,然后实现了ValidatingSessionManager接口中的validateSessions()方法。我们还是先从属性开始分析,下面是AbstractValidatingSessionManager类中的属性。

// 标识是否需要校验Sesion
protected boolean sessionValidationSchedulerEnabled;

// 从名称上看,我们就知道这个一个调度器。用来定时调度校验Session
protected SessionValidationScheduler sessionValidationScheduler;

// 调度器调度的时间间隔
protected long sessionValidationInterval;

AbstractValidatingSessionManager定义了一些和调度相关的属性,我们先了解一下SessionValidationScheduler接口有哪些方法。SessionValidationScheduler提供了3个方法:

  • isEnabled() - 表示是否已经开始了调度作业
  • enableSessionValidation() - 开启具体调度的作业内容
  • disableSessionValidation() - 停止调度作业

那么,我们应该想想,调度的作业内容是什么?很显然,这个作业内容是校验Session相关的事情,也就是为什么在ValidatingSessionManager接口中提供了validateSessions()方法的原因。

明白了SessionValidationScheduler接口之后,我们在回过来分析AbstractValidatingSessionManager就相当容易了。我们先看看是如何校验的,分析enableSessionValidationIfNecessary()方法。

/**
 * 这个方法就是判断是否需要校验,如果需要校验就去开启调度作业
 **/
private void enableSessionValidationIfNecessary() {
    SessionValidationScheduler scheduler = getSessionValidationScheduler();
    // 首先,判断是否需要校验Session,如果为false,则永远不会开启校验,根本就不判断scheduler的状态;
    // 其次,如果需要校验Session,会去判断scheduler== null或scheduler没有启动,在这两种情况下都会去开启调度任务
    // 也就是说,如果任务没有开启就去开启,如果已经开启了,就不会在处理。
    if (isSessionValidationSchedulerEnabled() && (scheduler == null || !scheduler.isEnabled())) {
        enableSessionValidation();
    }
}

/**
 * 具体的开启实现在这里
 **/
protected void enableSessionValidation() {
    // 是否设置了scheduler,如果没有就创建一个
    SessionValidationScheduler scheduler = getSessionValidationScheduler();
    if (scheduler == null) {
        // 创建scheduler
        scheduler = createSessionValidationScheduler();
        setSessionValidationScheduler(scheduler);
    }
    // 开启调度作业
    scheduler.enableSessionValidation();
    // 开启作业后的后置处理方法(钩子方法)
    afterSessionValidationEnabled();
}

/**
 * 创建scheduler
 **/
protected SessionValidationScheduler createSessionValidationScheduler() {
    ExecutorServiceSessionValidationScheduler scheduler;
    // 注意:这个的this指的就是ValidatingSessionManager接口啦,前面分析过,调度作业的具体内容时由这个接口来提供的。
    scheduler = new ExecutorServiceSessionValidationScheduler(this);
    scheduler.setInterval(getSessionValidationInterval());
    return scheduler;
}

上面我们只是从代码片段上分析了如何开启校验的,现在我们继续跟随AbstractNativeSessionManager的分析。我们说在AbstractNativeSessionManager中已经定型了整个类的基本实现,提供了两个抽象方法createSession(SessionContext context)和doGetSession(SessionKey key)。在AbstractValidatingSessionManager中对这两个方法进行了实现。下面主要分析这两个方法是怎么实现的。

// 实现createSession方法
protected Session createSession(SessionContext context) throws AuthorizationException {
    // 这就是上面分析过的方法,判断是否需要校验和启动调度作业
    enableSessionValidationIfNecessary();
    // 继续提供抽象方法由子类实现怎么创建Session
    return doCreateSession(context);
}

protected abstract Session doCreateSession(SessionContext initData) throws AuthorizationException;

// 实现doGetSession方法
protected final Session doGetSession(final SessionKey key) throws InvalidSessionException {
    // 这就是上面分析过的方法,判断是否需要校验和启动调度作业
    enableSessionValidationIfNecessary();
    // 继续提供抽象方法有子类实现怎么获取Session
    Session s = retrieveSession(key);
    if (s != null) {
        // 验证Session:
        // 首先,必须是ValidatingSession接口类型的Session
        // 其次,验证Session是否过期
        // 最后,验证Session是否无效
        validate(s, key);
    }
    return s;
}

protected void validate(Session session, SessionKey key) throws InvalidSessionException {
    try {
        doValidate(session);
    } catch (ExpiredSessionException ese) {
        onExpiration(session, ese, key);
        throw ese;
    } catch (InvalidSessionException ise) {
        onInvalidation(session, ise, key);
        throw ise;
    }
}

protected void doValidate(Session session) throws InvalidSessionException {
    if (session instanceof ValidatingSession) {
        ((ValidatingSession) session).validate();
    } else {
        String msg = "The " + getClass().getName() + " implementation only supports validating " +
                "Session implementations of the " + ValidatingSession.class.getName() + " interface.  " +
                "Please either implement this interface in your session implementation or override the " +
                AbstractValidatingSessionManager.class.getName() + ".doValidate(Session) method to perform validation.";
        throw new IllegalStateException(msg);
    }
}

从上面的分析可以得出:AbstractValidatingSessionManager类负责校验Session,对于如何创建和获取Session,并不是它的需要处理的任务。另外AbstractValidatingSessionManager还实现了Destroyable接口,表示销毁时应该处理销毁功能。

protected void disableSessionValidation() {
    // 销毁前置处理方法(钩子方法)
    beforeSessionValidationDisabled();
    SessionValidationScheduler scheduler = getSessionValidationScheduler();
    if (scheduler != null) {
        try {
            // 停止调度任务
            scheduler.disableSessionValidation();
        } catch (Exception e) {
            if (log.isDebugEnabled()) {
                String msg = "Unable to disable SessionValidationScheduler.  Ignoring (shutting down)...";
                log.debug(msg, e);
            }
        }
        // 生命周期管理
        LifecycleUtils.destroy(scheduler);
        // 重置scheduler为null
        setSessionValidationScheduler(null);
    }
}

最后,还有一个重要的功能。上面说到过,调度任务处理的内容是什么?也就是我们说的ValidatingSessionManager接口提供的validateSessions()方法。

public void validateSessions() {

    // 标志无效的Session个数
    int invalidCount = 0;

    // 获取所有有效的Session
    // 这是一个抽象方法。因为目前来说,也不知道Session存放在哪里,要从哪里获取呢?
    Collection<Session> activeSessions = getActiveSessions();
    
    // 遍历判断Session是否有效
    if (activeSessions != null && !activeSessions.isEmpty()) {
        for (Session s : activeSessions) {
            try {
                SessionKey key = new DefaultSessionKey(s.getId());
                validate(s, key);
            } catch (InvalidSessionException e) {
                invalidCount++;
            }
        }
    }

    if (log.isInfoEnabled()) {
        if (invalidCount > 0) {
            msg += "  [" + invalidCount + "] sessions were stopped.";
        } else {
            msg += "  No sessions were stopped.";
        }
        log.info(msg);
    }
}

同样,我们也可以给AbstractValidatingSessionManager来总结一下。AbstractValidatingSessionManager类会启动调度作业来校验Session,而调度作业的真正内容是检测每个Session的validate()方法,Session必须是ValidatingSession类型。validate()方法会抛出两个异常StoppedSessionException和ExpiredSessionException异常,这个两个异常都是InvalidSessionException的子类,所以抛出异常的时候会处理onExpiration()或onInvalidation()方法。


DefaultSessionManager分析

上面分析的都是抽象类,抽象类只是提供了一个基础的框架,在Shiro中DefaultSessionManager才是我们所使用的SessionManager接口的具体实现类。在分析AbstractValidatingSessionManager的时候,我们说过对于创建和获取Session,并不是它的职责。Session如何创建的?Session存放在哪里?我们都还不清楚。在DefaultSessionManager中我们将会知道Shiro是如何做的。还是按照习惯的方式,先看看有哪些属性和构造方法。

// 从名称上看就知道这个创建Session的工厂接口
private SessionFactory sessionFactory;

// DAO是做数据存储的,所以SessionDAO负责Session的CRUD操作
protected SessionDAO sessionDAO;

// 缓存管理器,这个很好理解,Session是频繁使用的对象,需要采用缓存功能
private CacheManager cacheManager;

// 是否删除无效的Session
private boolean deleteInvalidSessions;

// 默认构造方法
public DefaultSessionManager() {
    // 删除无效Session
    this.deleteInvalidSessions = true;
    // SimpleSessionFactory工厂创建SimpleSession实例
    this.sessionFactory = new SimpleSessionFactory();
    // 用内存存储Session
    this.sessionDAO = new MemorySessionDAO();
}

关于如何创建Session的,放在后面说。上面我们说了抛出异常的时候会处理onExpiration()或onInvalidation()方法。继续讨论检测Session无效后是怎么处理的,下面的方法就是处理Session的实现,如果Session被检测出被停止或过期就会调用相应的方法处理,返回将无效的Session删除(如果参数配置需要删除的话)或将Session更新。

@Override
protected void onStop(Session session) {
    if (session instanceof SimpleSession) {
        SimpleSession ss = (SimpleSession) session;
        Date stopTs = ss.getStopTimestamp();
        ss.setLastAccessTime(stopTs);
    }
    onChange(session);
}

@Override
protected void afterStopped(Session session) {
    if (isDeleteInvalidSessions()) {
        delete(session);
    }
}

protected void onExpiration(Session session) {
    if (session instanceof SimpleSession) {
        ((SimpleSession) session).setExpired(true);
    }
    onChange(session);
}

@Override
protected void afterExpired(Session session) {
    if (isDeleteInvalidSessions()) {
        delete(session);
    }
}

protected void onChange(Session session) {
    sessionDAO.update(session);
}

SessionDAO CRUD操作

Session的创建是由SessionFactory来实现的。Shiro只提供了SimpleSessionFactory一个实现类,创建SimpleSession实例。如果需要则可以根据业务扩展接口。创建Session后会调用SessionDAO#create(session)方法,将Session存储起来。对Session的CRUD操作都是通过SessionDAO来处理的,SessionDAO负责将Session存储在哪里,怎么存储。下面简单地描述一下SessionDAO接口。

public interface SessionDAO {

    /**
     * 插入Session(可以是数据库,文件系统,内存,缓存等)
     */
    Serializable create(Session session);

    /**
     * 获取Session
     */
    Session readSession(Serializable sessionId) throws UnknownSessionException;

    /**
     * 更新Session
     */
    void update(Session session) throws UnknownSessionException;

    /**
     * 删除Session
     */
    void delete(Session session);

    /**
     * 返回所有活动的Session
     */
    Collection<Session> getActiveSessions();
}

Shiro提供了两种SessionDAO,第一种是MemorySessionDAO,它将Session存储在内存中;第二种是EnterpriseCacheSessionDAO,可以定义将Session存入到缓存中。由于在使用中我们很大可能需要自定义SessionDAO,下面对SessionDAO也展开分析。MemorySessionDAO是以Map作为存储的,很简单不再说明。我们以EnterpriseCacheSessionDAO来分析。EnterpriseCacheSessionDAO类的继承关系是这样的:EnterpriseCacheSessionDAO->CachingSessionDAO->AbstractSessionDAO。在AbstractSessionDAO中提供了SessionIdGenerator类型的属性,用于生成Session唯一ID值。我们需要分析的重点是CachingSessionDAO。

CachingSessionDAO分析

CachingSessionDAO是一个抽象类,负责对Session进行缓存管理,所有Session都存入到一个缓存中。Shiro提供自己的Cache和CacheManager两个接口。CacheManger负责管理Cache对象实例。下面是CachingSessionDAO的属性,我们可以看出Session就是存放在activeSessions中。

/**
 * 默认Session缓存名称
 */
public static final String ACTIVE_SESSION_CACHE_NAME = "shiro-activeSessionCache";

/**
 * 缓存管理器
 */
private CacheManager cacheManager;

/**
 * 存储Session的缓存对象
 */
private Cache<Serializable, Session> activeSessions;

/**
 * Session缓存名
 */
private String activeSessionsCacheName = ACTIVE_SESSION_CACHE_NAME;

看看在CachingSessionDAO是怎样来创建Session,获取Session,更新Session的。

// 接口方法,创建Session
public Serializable create(Session session) {
    Serializable sessionId = super.create(session);
    // 相当于对父类方法做了后置缓存处理
    // 实际上就是调用Cache#put()方法,将Session存储
    cache(session, sessionId);
    return sessionId;
}

// 实现父类抽象方法,获取Session
public Session readSession(Serializable sessionId) throws UnknownSessionException {
    // 相当于对父类方法做了前置处理
    // 先从缓存中获取,如果缓存中没有再调用真实方法
    Session s = getCachedSession(sessionId);
    if (s == null) {
        s = super.readSession(sessionId);
    }
    return s;
}

// 修改Session
public void update(Session session) throws UnknownSessionException {
    // 抽象方法,修改Session前置处理
    doUpdate(session);
    // 将Session更新到缓存中
    if (session instanceof ValidatingSession) {
        if (((ValidatingSession) session).isValid()) {
            cache(session, session.getId());
        } else {
            uncache(session);
        }
    } else {
        cache(session, session.getId());
    }
}

// 删除Session
public void delete(Session session) {
    // 从缓存中删除
    uncache(session);
    // 删除后置方法
    doDelete(session);
}

总结

在本篇中我们了解了Session、SessionManager以及SessionDAO。Session表示用户的会话数据,Session的核心点是状态,Session有无效和活动两种状态。其中,无效又包括被停止和过期状态,我们可以对Session状态进行监听和检测。

另外,就是Session的存储,在Shiro中使用SessionDAO接口来处理Session的存储,Shiro中提供了基于内存和基于缓存的两种方式来存储Session。

© 著作权归作者所有

xiaoqiyiye
粉丝 17
博文 44
码字总数 80350
作品 0
杭州
私信 提问
shiro 在使用shiro时候配置的ehcache.xml不起作用

在ehcache.xml中 中value=shiro-activeSessionCache 根本没作用啊 在ehcache.xml中配置的这个cache没起作用 反而是 中的设置失效时间起作用了..... 还有个问题就是我用cacheManager中取得use...

灯光下的宁静
2014/05/15
7.7K
2
Shiro的Session管理

概述和配置使用 n概述 Shiro提供安全框架界独一无二的东西:一个完整的企业级Session 解决方案,可以为任意的应用提供session支持,包括web和非web应用,并且无需部署你的应用程序到Web 容器...

boonya
2014/11/24
45.4K
3
org.apache.shiro.SecurityUtils.getSubject().getSession()

Shiro的Session管理 概述和配置使用 n概述 Shiro提供安全框架界独一无二的东西:一个完整的企业级Session 解决方案,可以为任意的应用提供session支持,包括web和非web应用,并且无需部署你的...

bitree1
2016/01/11
0
0
springmvc整合shiro 会话管理时候报错

配置代码 报错信息: org.apache.shiro.session.UnknownSessionException: There is no session with id [DDCEE1C0E7397040829290946EDB7209 请求一次,地址栏的sessionId就变一次 总是产生不......

李永china
2016/06/06
692
5
springmvc集成shiro后,session、request姓汪还是姓蒋?

疑问 我们在项目中使用了spring mvc作为MVC框架,shiro作为权限控制框架,在使用过程中慢慢地产生了下面几个疑惑,本篇文章将会带着疑问慢慢地解析shiro源码,从而解开心里面的那点小纠纠。 ...

细肉云吞
2017/06/18
6.4K
22

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周六乱弹 —— 早上儿子问我他是怎么来的

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @凉小生 :#今日歌曲推荐# 少点戾气,愿你和这个世界温柔以待。中岛美嘉的单曲《僕が死のうと思ったのは (曾经我也想过一了百了)》 《僕が死の...

小小编辑
今天
2.4K
15
Excption与Error包结构,OOM 你遇到过哪些情况,SOF 你遇到过哪些情况

Throwable 是 Java 中所有错误与异常的超类,Throwable 包含两个子类,Error 与 Exception 。用于指示发生了异常情况。 Java 抛出的 Throwable 可以分成三种类型。 被检查异常(checked Exc...

Garphy
今天
41
0
计算机实现原理专题--二进制减法器(二)

在计算机实现原理专题--二进制减法器(一)中说明了基本原理,现准备说明如何来实现。 首先第一步255-b运算相当于对b进行按位取反,因此可将8个非门组成如下图的形式: 由于每次做减法时,我...

FAT_mt
昨天
40
0
好程序员大数据学习路线分享函数+map映射+元祖

好程序员大数据学习路线分享函数+map映射+元祖,大数据各个平台上的语言实现 hadoop 由java实现,2003年至今,三大块:数据处理,数据存储,数据计算 存储: hbase --> 数据成表 处理: hive --> 数...

好程序员官方
昨天
61
0
tabel 中含有复选框的列 数据理解

1、el-ui中实现某一列为复选框 实现多选非常简单: 手动添加一个el-table-column,设type属性为selction即可; 2、@selection-change事件:选项发生勾选状态变化时触发该事件 <el-table @sel...

everthing
昨天
21
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部