2017.4.12 开涛shiro教程-第十八章-并发登录人数控制

原博客地址：http://jinnianshilongnian.iteye.com/blog/2018398

根据下载的pdf学习。

开涛shiro教程-第十八章-并发登录人数控制

shiro中没有提供默认实现，不过可以很容易实现。通过shiro filter机制拓展KickoutSessionControllerFilter。

kickoutSessionControllerFilter  ->  将这个filter配置到shiro的配置文件中 -> 遇到的一些问题。

示例代码的结构：

1.配置spring-config-shiro.xml

（1）kickoutSessionControllerFilter

kickoutAfter：是否提出后来登录的，默认为false，即后来登录的踢出前者。

maxSession：同一个用户的最大会话数，默认1，表示同一个用户最多同时一个人登录。

kickoutUrl：被踢出后重定向的地址。

<bean id="kickoutSessionControlFilter"
　　  class="com.github.zhangkaitao.shiro.chapter18.web.shiro.filter.KickoutSessionControlFilter">
　　<property name="cacheManager" ref="cacheManager"/>
　　<property name="sessionManager" ref="sessionManager"/>
　　<property name="kickoutAfter" value="false"/>
　　<property name="maxSession" value="2"/>
　　<property name="kickoutUrl" value="/login?kickout=1"/>
</bean>

（2）shiroFilter

此处配置除了登录等之外的地址都走 kickout 拦截器进行并发登录控制。

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
　　<property name="securityManager" ref="securityManager"/>
　　<property name="loginUrl" value="/login"/>
　　<property name="filters">
　　　　<util:map>
　　　　　　<entry key="authc" value-ref="formAuthenticationFilter"/>
　　　　　　<entry key="sysUser" value-ref="sysUserFilter"/>
　　　　　　<entry key="kickout" value-ref="kickoutSessionControlFilter"/>
　　　　</util:map>
　　</property>
　　<property name="filterChainDefinitions">
　　　　<value>
　　　　　　/login = authc
　　　　　　/logout = logout
　　　　　　/authenticated = authc
　　　　　　/** = kickout,user,sysUser
　　　　</value>
　　</property>
</bean>

（3） ehcache.xml

这里的名称在后面的kickoutController里要用到。

    <cache name="shiro-kickout-session"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

2.KickoutSessionControllerFilter

此处，使用了Cache缓存"用户名-会话id"之间的关系，如果量比较大的话，可以考虑持久化到数据库/其他持久化的Cache中。

另外，此处没有并发控制的同步实现，可以考虑根据用户名来获取锁，减少锁的粒度。

package com.github.zhangkaitao.shiro.chapter18.web.shiro.filter;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.DefaultSessionKey;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;
import java.util.Deque;
import java.util.LinkedList;

/**
 * <p>User: Zhang Kaitao
 * <p>Date: 14-2-18
 * <p>Version: 1.0
 */
public class KickoutSessionControlFilter extends AccessControlFilter {

    private String kickoutUrl; //踢出后到的地址
    private boolean kickoutAfter = false; //踢出之前登录的/之后登录的用户 默认踢出之前登录的用户
    private int maxSession = 1; //同一个帐号最大会话数 默认1

    private SessionManager sessionManager;
    private Cache<String, Deque<Serializable>> cache;

    public void setKickoutUrl(String kickoutUrl) {
        this.kickoutUrl = kickoutUrl;
    }

    public void setKickoutAfter(boolean kickoutAfter) {
        this.kickoutAfter = kickoutAfter;
    }

    public void setMaxSession(int maxSession) {
        this.maxSession = maxSession;
    }

    public void setSessionManager(SessionManager sessionManager) {
        this.sessionManager = sessionManager;
    }

    public void setCacheManager(CacheManager cacheManager) {
        this.cache = cacheManager.getCache("shiro-kickout-session");
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        Subject subject = getSubject(request, response);
        if(!subject.isAuthenticated() && !subject.isRemembered()) {
            //如果没有登录，直接进行之后的流程
            return true;
        }

        Session session = subject.getSession();
        String username = (String) subject.getPrincipal();
        Serializable sessionId = session.getId();

        //TODO 同步控制
        Deque<Serializable> deque = cache.get(username);
        if(deque == null) {
            deque = new LinkedList<Serializable>();
            cache.put(username, deque);
        }

        //如果队列里没有此sessionId，且用户没有被踢出；放入队列
        if(!deque.contains(sessionId) && session.getAttribute("kickout") == null) {
            deque.push(sessionId);
        }

        //如果队列里的sessionId数超出最大会话数，开始踢人
        while(deque.size() > maxSession) {
            Serializable kickoutSessionId = null;
            if(kickoutAfter) { //如果踢出后者
                kickoutSessionId = deque.removeFirst();
            } else { //否则踢出前者
                kickoutSessionId = deque.removeLast();
            }
            try {
                Session kickoutSession = sessionManager.getSession(new DefaultSessionKey(kickoutSessionId));
                if(kickoutSession != null) {
                    //设置会话的kickout属性表示踢出了
                    kickoutSession.setAttribute("kickout", true);
                }
            } catch (Exception e) {//ignore exception
            }
        }

        //如果被踢出了，直接退出，重定向到踢出后的地址
        if (session.getAttribute("kickout") != null) {
            //会话被踢出了
            try {
                subject.logout();
            } catch (Exception e) { //ignore
            }
            saveRequest(request);
            WebUtils.issueRedirect(request, response, kickoutUrl);
            return false;
        }

        return true;
    }
}

3.测试

因为此处设置maxSession=2，所以需要打开3个浏览器。分别访问：http:l//ocalhost:8080/chapter18 进行登录。

然后刷新第一次打开的浏览器，将会被强制退出。

4.遇到的问题

（1）there is no session Id ***

报错：there is no session Id ***。

原因：我没有在ehcache.xml里配置"shiro-kickout-session"。

因为kickoutController里用到了：

    public void setCacheManager(CacheManager cacheManager) {
        this.cache = cacheManager.getCache("shiro-kickout-session");
    }

所以在ehcache.xml中一定记得加上（名字匹配即可）：

　　<cache name="shiro-kickout-session"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

（2）sessionKey must be an HTTP compatible implementation

报错：sessionKey must be an HTTP compatible implementation。

原因：我的sessionManager和示例代码中的sessionManager不同，示例中用的是DefaultWebSessionManager，我用的是ServletContainerSessionManager。

代码中这一句报的错误：

 Session kickoutSession = sessionManager.getSession(new DefaultSessionKey(kickoutSessionId));

sessionManager.getSession时，因为sessionManager的类类型是ServletContainerSessionManager，所以会进行一个http判定。

参考来自：http://blog.csdn.net/qq_26946497/article/details/51064654?locationNum=3

 public Session getSession(SessionKey key) throws SessionException {
        if (!WebUtils.isHttp(key)) { //判断是不是http的key，否则抛异常
            String msg = "SessionKey must be an HTTP compatible implementation.";
            throw new IllegalArgumentException(msg);
        }
        ...
    }

最后的解决办法：不存放sessionId在deque中，直接存放Session。又可以跳过通过sessionId获取session这一步，直接从deque中拿到之前保存的session。

//修改前
Deque<Serializable> deque = cache.get(username);
deque.push(sessionId);
kickoutSessionId = deque.removeLast();
Session kickoutSession = sessionManager.getSession(new DefaultSessionKey(kickoutSessionId));

//修改后
Deque<Session> deque = cache.get(username);
deque.push(session);
kickoutSession = deque.removeLast();

（3）没有增加锁

　　synchronized (this.cache) {
       Deque<Session> deque = cache.get(usernameTenant);
       ...
　　}
    //如果被踢出了，直接退出，重定向到踢出后的地址
    if (session.getAttribute(KICK_OUT) != null && session.getAttribute(KICK_OUT) == true) {
　　...

（4）动态设定是否需要kickout

在配置文件中，设置参数 kickout = false。然后在kickoutController里拿到这个参数的值。

　　protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        if("false".equals(kickout)){
            //如果不需要单用户登录的限制
            return true;
        }
        ...
}

5.CacheManager和SessionManager详解

（1）CacheManager

示例中的配置文件：

-> ehcache.xml 
-> ehcacheManager（EhCacheManagerFactoryBean）
-> springCacheManager（EhCacheCacheManager） 
-> cacheManager（SpringCacheManagerWrapper） 
-> 其他bean里使用

我的配置文件：

-> ehcache.xml 
-> ehcacheManager（EhCacheManagerFactoryBean）
-> cacheManager（EhCacheCacheManager） 
-> springCacheManager（SpringCacheManagerWrapper）
-> 其他bean里使用

所以名字都是浮云，重点是从cacheManager的构成：

-> ehcache.xml 
-> EhCacheManagerFactoryBean 
-> EhCacheCacheManager 
-> SpringCacheManagerWrapper  
-> 其他bean使用

详细配置如下：

 1 spring-config-shiro.xml
 2  　　<bean id="cacheManager" class="com.github.zhangkaitao.shiro.spring.SpringCacheManagerWrapper">
 3          <property name="cacheManager" ref="springCacheManager"/>
 4  　　</bean>
 5 
 6　　  <bean id="credentialsMatcher" class="com.github.zhangkaitao.shiro.chapter18.credentials.RetryLimitHashedCredentialsMatcher">
 7         <constructor-arg ref="cacheManager"/>
 8         ...
 9     </bean>
10 
11     <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
12         <property name="sessionManager" ref="sessionManager"/>
13         <property name="cacheManager" ref="cacheManager"/>
14         ...
15     </bean>
16 
17 　　 <bean id="kickoutSessionControlFilter" class="com.github.zhangkaitao.shiro.chapter18.web.shiro.filter.KickoutSessionControlFilter">
18         <property name="cacheManager" ref="cacheManager"/>
19         <property name="sessionManager" ref="sessionManager"/>
20         ...
21     </bean>
22 
23  spring-config-cache.xml
24  　　<bean id="springCacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
25         <property name="cacheManager" ref="ehcacheManager"/>
26  　　</bean>
27  
28  　　<bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
29         <property name="configLocation" value="classpath:ehcache/ehcache.xml"/>
30  　　</bean>

（2）SessionManager

SessionManager是一个接口。

public interface SessionManager {
    Session start(SessionContext sessionContext);
    Session getSession(SessionKey sessionKey) throws SessionException;
}

类结构图如下：

Shiro提供了三个默认实现：

DefaultSessionManager：DefaultSecurityManager使用的默认实现，用于JavaSE环境；

ServletContainerSessionManager：DefaultWebSecurityManager使用的默认实现，用于Web环境，其直接使用Servlet容器的会话；

DefaultWebSessionManager：用于Web环境的实现，可以替代ServletContainerSessionManager，自己维护着会话，直接废弃了Servlet容器的会话管理。

示例中：配置文件spring-config-shiro.xml中使用的是DefaultWebSessionManager。

 1<!-- 会话管理器 -->
 3     <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
 4     ...
 5     </bean>
 6 
 7     <!-- 安全管理器 -->
 8     <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
 9         <property name="sessionManager" ref="sessionManager"/>
10         <property name="cacheManager" ref="cacheManager"/>
11         ...
12     </bean>
13     
13     <!-- 并发登录控制 -->
14     <bean id="kickoutSessionControlFilter" class="com.github.zhangkaitao.shiro.chapter18.web.shiro.filter.KickoutSessionControlFilter">
15         <property name="cacheManager" ref="cacheManager"/>
16         <property name="sessionManager" ref="sessionManager"/>
17          ...
18     </bean>

我的项目中：配置文件applicationContext-shiro.xml中没有进行sessionManager的配置（为了共享session），所以使用的是shiro的默认实现：ServletContainerSessionManager。（或者运行代码时，可以去看sessionManager的类类型）

　　<!--文件中没有sessionManager的配置-->

　　<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="cacheManager" ref="springCacheManager"/>
        <!--这里没有配置sessionManager-->
        ...
    </bean>

　　<bean id="kickoutSessionControlFilter" class="com.baosight.common.filter.KickoutSessionControlFilter">
        <property name="cacheManager" ref="springCacheManager"/>
         <!--这里没有配置sessionManager-->
         ...
    </bean>

而这两种实现（DefaultWebSessionManager 和 ServletContainerSessionManager）的区别以及源码分析：

http://blog.csdn.net/qq_26946497/article/details/51064654?locationNum=3

注意：没有配置SessionManager时，默认为ServletContainerSessionManager。