2017.6.30 用shiro实现并发登录人数控制（实际项目中的实现）

之前的学习总结：http://www.cnblogs.com/lyh421/p/6698871.html

1.kickout功能描述

如果将配置文件中的kickout设置为true，则在另处再次登录时，会将第一次登录的用户踢出。

 

2.kickout的实现

2.1 新建KickoutSessionControlFilter extends AccessControlFilter

详细的方法实现，后面再来完成。类存放于公共module：base_project中。

 1 public class KickoutSessionControlFilter extends AccessControlFilter {
 2     @Override
 3     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
 4         return false;
 5     }
 6
 7     @Override
 8     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
 9         return false;
10     }
11 }

2.2 配置spring-config-shiro.xml

这两个文件配置在要使用kickout功能的module中。

（1）kickoutSessionControllerFilter

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

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

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

 <!--并发登录控制-->
     <bean id="kickoutSessionControlFilter" class="***.common.filter.KickoutSessionControlFilter">
         <property name="cacheManager" ref="springCacheManager"/>
         <property name="kickoutAfter" value="false"/>
         <property name="maxSession" value="1"/>
         <property name="kickoutUrl" value="/login.do"/>
     </bean>

（2）shiroFilter

此处配置什么时候走kickout 拦截器，进行并发登录控制。这里拦截所有.jsp和.do的路径。

 <bean id="AuthRequestFilter" class="com.baosight.aas.auth.filter.AuthRequestFilter"/>
     <!-- Shiro主过滤器本身功能十分强大,其强大之处就在于它支持任何基于URL路径表达式的、自定义的过滤器的执行 -->
     <!-- Web应用中,Shiro可控制的Web请求必须经过Shiro主过滤器的拦截,Shiro对基于Spring的Web应用提供了完美的支持 -->
     <bean id="shiroFilter" class="com.baosight.aas.auth.filter.factory.ClientShiroFilterFactoryBean">
           //略
         <property name="filters">
             <util:map>
                 <entry key="authc" value-ref="formAuthenticationFilter"/>
                   //略
                 <entry key="kickout" value-ref="kickoutSessionControlFilter"/>
             </util:map>
         </property>
         <property name="filterChainDefinitions">
             <value>
                   //略                 /**/*.jsp = forceLogout,authc,kickout
                 /**/*.do = forceLogout,authc,kickout
                 /** = forceLogout,authc
             </value>
         </property>
     </bean>

2.3 ehcache.xml

注意，其他module在配置shiro的时候，都是使用的公共module：base_project中的ehcache.xml文件。在此文件中加上一段：

这里的名称shiro-kickout-session在后面的kickoutController里要用到。

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

2.4 实现KickoutSessionControlFilter

 package com.baosight.common.filter;

 import org.apache.shiro.cache.Cache;
 import org.apache.shiro.cache.CacheManager;
 import org.apache.shiro.session.Session;
 import org.apache.shiro.subject.Subject;
 import org.apache.shiro.web.filter.AccessControlFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;

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

 /**
  * Created by liyuhui on 2017/4/12.
  */
 public class KickoutSessionControlFilter extends AccessControlFilter{
     private static final Logger LOGGER = LoggerFactory.getLogger(KickoutSessionControlFilter.class);

     @Value("${aas.kickout:false}")
     private String kickout;

     private String kickoutUrl;
     private boolean kickoutAfter = false;
     private int maxSession = 1;
     private Cache<String, Deque<Session>> 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 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 {
         if(!"true".equals(kickout)){
             //如果不需要单用户登录的限制
             return true;
         }

         Subject subject = getSubject(request, response);
         if(!subject.isAuthenticated() && !subject.isRemembered()){
             //如果没登录，直接进行之后的流程
             return true;
         }

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

         String usernameTenant = (String)session.getAttribute("loginName");
         synchronized (this.cache) {
             if(cache == null){
                 throw new Exception("cache 为空");
             }
             Deque<Session> deque = cache.get(usernameTenant);
             if (deque == null) {
                 deque = new LinkedList<Session>();
                 cache.put(usernameTenant, deque);
             }

             //如果队列里没有此sessionId，且用户没有被踢出；放入队列
             boolean whetherPutDeQue = true;
             if (deque.isEmpty()) {
                 whetherPutDeQue = true;
             } else {
                 for (Session sessionInqueue : deque) {
                     if (sessionId.equals(sessionInqueue.getId())) {
                         whetherPutDeQue = false;
                         break;
                     }
                 }
             }
             if (whetherPutDeQue) {
                 deque.push(session);
             }
             this.LOGGER.debug("logged user:" + usernameTenant + ", deque size = " + deque.size());
             this.LOGGER.debug("deque = " + deque);

             //如果队列里的sessionId数超出最大会话数，开始踢人
             while (deque.size() > maxSession) {
                 Session kickoutSession = null;
                 if (kickoutAfter) { //如果踢出后者
                     kickoutSession = deque.removeFirst();
                     this.LOGGER.debug("踢出后登录的，被踢出的sessionId为: " + kickoutSession.getId());
                 } else { //否则踢出前者
                     kickoutSession = deque.removeLast();
                     this.LOGGER.debug("踢出先登录的，被踢出的sessionId为： " + kickoutSession.getId());
                 }
                 if (kickoutSession != null) {
                     kickoutSession.stop();
                 }
             }
         }
         return true;
     }
 }

3.遇到的错误和说明

3.1 共享session的问题

项目中，使用了共享session，出现了踢出失效的问题。（已解决）

解决办法：原本的实现代码使用的是标记属性，现在改为直接stop该session。

之前的代码：

  if (kickoutSession != null) {
         //设置会话的kickout属性表示踢出了
         kickoutSession.setAttribute(KICK_OUT, true);
  }

之后的代码：

 if (kickoutSession != null) {
       kickoutSession.stop();
 }