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：被踢出后重定向的地址。

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

 

（2）shiroFilter

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

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

2.3 ehcache.xml

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

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

1 <cache name="shiro-kickout-session"
2            eternal="false"
3            timeToIdleSeconds="3600"
4            timeToLiveSeconds="0"
5            overflowToDisk="false"
6            statistics="true">
7     </cache>

 

2.4 实现KickoutSessionControlFilter

1 package com.baosight.common.filter;
2
3 import org.apache.shiro.cache.Cache;
4 import org.apache.shiro.cache.CacheManager;
5 import org.apache.shiro.session.Session;
6 import org.apache.shiro.subject.Subject;
7 import org.apache.shiro.web.filter.AccessControlFilter;
8 import org.slf4j.Logger;
9 import org.slf4j.LoggerFactory;
10 import org.springframework.beans.factory.annotation.Value;
11
12 import javax.servlet.ServletRequest;
13 import javax.servlet.ServletResponse;
14 import java.io.Serializable;
15 import java.util.Deque;
16 import java.util.LinkedList;
17
18 /**
19  * Created by liyuhui on 2017/4/12.
20  */
21 public class KickoutSessionControlFilter extends AccessControlFilter{
22     private static final Logger LOGGER = LoggerFactory.getLogger(KickoutSessionControlFilter.class);
23
24     @Value("${aas.kickout:false}")
25     private String kickout;
26
27     private String kickoutUrl;
28     private boolean kickoutAfter = false;
29     private int maxSession = 1;
31     private Cache<String, Deque<Session>> cache;
 32
33     public void setKickoutUrl(String kickoutUrl) {
34         this.kickoutUrl = kickoutUrl;
35     }
36
37     public void setKickoutAfter(boolean kickoutAfter) {
38         this.kickoutAfter = kickoutAfter;
39     }
40
41     public void setMaxSession(int maxSession) {
42         this.maxSession = maxSession;
43     }
44
45     public void setCacheManager(CacheManager cacheManager) {
46         this.cache = cacheManager.getCache("shiro-kickout-session");
 47     }
48
49     @Override
50     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
51         return false;
52     }
53
54     @Override
55     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
56         if(!"true".equals(kickout)){
57             //如果不需要单用户登录的限制
58             return true;
59         }
60
61         Subject subject = getSubject(request, response);
62         if(!subject.isAuthenticated() && !subject.isRemembered()){
63             //如果没登录，直接进行之后的流程
64             return true;
65         }
66
67         Session session = subject.getSession();
68         Serializable sessionId = session.getId();
69
70         String usernameTenant = (String)session.getAttribute("loginName");
71         synchronized (this.cache) {
72             if(cache == null){
73                 throw new Exception("cache 为空");
74             }
75             Deque<Session> deque = cache.get(usernameTenant);
76             if (deque == null) {
77                 deque = new LinkedList<Session>();
78                 cache.put(usernameTenant, deque);
79             }
80
81             //如果队列里没有此sessionId，且用户没有被踢出；放入队列
82             boolean whetherPutDeQue = true;
83             if (deque.isEmpty()) {
84                 whetherPutDeQue = true;
85             } else {
86                 for (Session sessionInqueue : deque) {
87                     if (sessionId.equals(sessionInqueue.getId())) {
88                         whetherPutDeQue = false;
89                         break;
90                     }
91                 }
92             }
93             if (whetherPutDeQue) {
94                 deque.push(session);
95             }
96             this.LOGGER.debug("logged user:" + usernameTenant + ", deque size = " + deque.size());
97             this.LOGGER.debug("deque = " + deque);
98
99             //如果队列里的sessionId数超出最大会话数，开始踢人
100             while (deque.size() > maxSession) {
101                 Session kickoutSession = null;
102                 if (kickoutAfter) { //如果踢出后者
103                     kickoutSession = deque.removeFirst();
104                     this.LOGGER.debug("踢出后登录的，被踢出的sessionId为: " + kickoutSession.getId());
105                 } else { //否则踢出前者
106                     kickoutSession = deque.removeLast();
107                     this.LOGGER.debug("踢出先登录的，被踢出的sessionId为： " + kickoutSession.getId());
108                 }
109                 if (kickoutSession != null) {
110                     kickoutSession.stop();
111                 }
112             }
113         }
114         return true;
115     }
116 }

 

3.遇到的错误和说明

3.1 共享session的问题

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

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

之前的代码：

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

 

之后的代码：

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