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>
                   //略48                 /**/*.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();
}