為了安全起見，同一個賬號理應同時只能在一臺裝置上登入，後面登入的踢出前面登入的。用Shiro可以輕鬆實現此功能。

shiro中sessionManager是專門作會話管理的，而sessinManager將會話儲存在sessionDAO中，如果不給sessionManager注入

sessionDAO，會話將是瞬時狀態，沒有被儲存起來，從sessionManager裡取session,是取不到的。

此例中sessionDAO注入了Ehcache快取，會話被儲存在Ehcache中，不知Ehcache為何物的，請自行查閱資料。

完整demo下載：http://download.csdn.net/detail/qq_33556185/9555720

shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd   
    http://www.springframework.org/schema/tx   
    http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-4.2.xsd  
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
     
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
        <property name="globalSessionTimeout" value="1800000"/>  
        <property name="deleteInvalidSessions" value="true"/>  
        <property name="sessionDAO" ref="sessionDAO"/>  
        <property name="sessionIdCookieEnabled" value="true"/>  
        <property name="sessionIdCookie" ref="sessionIdCookie"/>  
        <property name="sessionValidationSchedulerEnabled" value="true"/>
        <property name="sessionValidationScheduler" ref="sessionValidationScheduler"/>
         <property name="cacheManager" ref="shiroEhcacheManager"/>
</bean>  
	   <!-- 會話DAO，sessionManager裡面的session需要儲存在會話Dao裡，沒有會話Dao，session是瞬時的，沒法從
     sessionManager裡面拿到session -->  
    <bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">  
        <property name="sessionIdGenerator" ref="sessionIdGenerator"/>  
        <property name="activeSessionsCacheName" value="shiro-activeSessionCache"/>
    </bean> 
	  <!-- 快取管理器 -->
  <bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">  
  <property name="cacheManagerConfigFile" value="classpath:ehcache.xml" />  
  </bean>
<bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
        <constructor-arg value="sid"/>
        <property name="httpOnly" value="true"/>
        <property name="maxAge" value="-1"/> 
</bean> 
 <!-- 會話ID生成器 -->
 <bean id="sessionIdGenerator" class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator"></bean>
<bean id="kickoutSessionControlFilter"  class="com.core.shiro.KickoutSessionControlFilter">  
    <property name="sessionManager" ref="sessionManager"/>  
    <property name="cacheManager" ref="shiroEhcacheManager"/>
    <property name="kickoutAfter" value="false"/>  
    <property name="maxSession" value="1"/>  
    <property name="kickoutUrl" value="/toLogin?kickout=1"/>  
</bean> 
      <bean id="logout" class="org.apache.shiro.web.filter.authc.LogoutFilter">
        <property name="redirectUrl" value="/toLogin" />
       </bean> 
          <!-- 會話驗證排程器 -->
    <bean id="sessionValidationScheduler" class="org.apache.shiro.session.mgt.ExecutorServiceSessionValidationScheduler ">
        <property name="interval" value="1800000"/>
        <property name="sessionManager" ref="sessionManager"/>
    </bean>
	 <!-- Shiro Filter 攔截器相關配置 -->  
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
        <!-- securityManager -->  
        <property name="securityManager" ref="securityManager" />  
        <!-- 登入路徑 -->  
        <property name="loginUrl" value="/toLogin" />  
        <!-- 使用者訪問無許可權的連結時跳轉此頁面  -->  
        <property name="unauthorizedUrl" value="/unauthorizedUrl.jsp" />  
       
        <!-- 過濾鏈定義 -->  
         <property name="filters">  
         <map>  
             <entry key="kickout" value-ref="kickoutSessionControlFilter"/>  
         </map>  
     </property> 
        <property name="filterChainDefinitions">  
            <value>  
            	/loginin=kickout,anon
            	 /logout = logout
            	/toLogin=anon
            	/css/**=anon 
                /html/**=anon 
                /images/**=anon
                /js/**=anon 
                /upload/**=anon 
                <!-- /userList=roles[admin] -->
                /userList=kickout,authc,perms[/userList]
                /toRegister=kickout,authc,perms[/toRegister]
                /toDeleteUser=kickout,authc,perms[/toDeleteUser]
                /** = kickout,authc
             </value>  
        </property>  
    </bean>  
  
    <!-- securityManager -->  
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
        <property name="realm" ref="myRealm" />  
         <property name="sessionManager" ref="sessionManager"/>
         <property name="cacheManager" ref="shiroEhcacheManager"/>
    </bean>  
    <!-- 自定義Realm實現 --> 
    <bean id="myRealm" class="com.core.shiro.CustomRealm" />  
    
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
	   <property name="prefix" value="/"/>  
	   <property name="suffix" value=".jsp"></property>  
	</bean>
</beans>  
 

<?xml version="1.0" encoding="UTF-8"?>  
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"  
    updateCheck="false" maxBytesLocalDisk="20G" maxBytesLocalOffHeap="50M">
      
    <diskStore path="java.io.tmpdir"/> <!-- 系統的預設臨時檔案路徑 -->
    <defaultCache eternal="false"   
        maxElementsInMemory="10000"  
        overflowToDisk="false"   
        timeToIdleSeconds="0"  
        timeToLiveSeconds="0"   
        memoryStoreEvictionPolicy="LFU" />  
   <!-- 
    eternal：快取中物件是否為永久的，如果是，超時設定將被忽略，物件從不過期。
    maxElementsInMemory：快取中允許建立的最大物件數
    overflowToDisk：記憶體不足時，是否啟用磁碟快取。
    timeToIdleSeconds：快取資料的鈍化時間，也就是在一個元素消亡之前，
            兩次訪問時間的最大時間間隔值，這隻能在元素不是永久駐留時有效，
 	 如果該值是 0 就意味著元素可以停頓無窮長的時間。
    timeToLiveSeconds：快取資料的生存時間，也就是一個元素從構建到消亡的最大時間間隔值，
           這隻能在元素不是永久駐留時有效，如果該值是0就意味著元素可以停頓無窮長的時間。
    memoryStoreEvictionPolicy：快取滿了之後的淘汰演算法。
    1 FIFO，先進先出
	2 LFU，最少被使用，快取的元素有一個hit屬性，hit值最小的將會被清出快取。
	3 LRU，最近最少使用的，快取的元素有一個時間戳，當快取容量滿了，而又需要騰出地方來快取新的元素的時候，那麼現有快取元素中時間戳離當前時間最遠的元素將被清出快取。
    -->
    <cache name="myCache"  eternal="false"   
        maxElementsInMemory="10000"  
        overflowToDisk="false"   
        timeToIdleSeconds="0"  
        timeToLiveSeconds="0"   
        memoryStoreEvictionPolicy="LFU" />  
    <cache name="shiro-activeSessionCache" eternal="false"
          maxElementsInMemory="10000"  
          overflowToDisk="true"
          timeToIdleSeconds="0"
          timeToLiveSeconds="0"/>
</ehcache> 
 

<script type="text/javascript">
    function kickout(){
       var href=location.href;
       if(href.indexOf("kickout")>0){
           alert("您的賬號在另一臺裝置上登入，您被擠下線，若不是您本人操作，請立即修改密碼！");
       } 
    }
    window.onload=kickout(); 
</script>

package com.core.shiro;

import java.io.Serializable;
import java.util.Deque;
import java.util.LinkedList;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
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;
public class KickoutSessionControlFilter  extends AccessControlFilter{
	private String kickoutUrl; //踢出後到的地址
    private boolean kickoutAfter; //踢出之前登入的/之後登入的使用者 預設踢出之前登入的使用者
    private int maxSession; //同一個帳號最大會話數 預設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-activeSessionCache");
    }
     /**
      * 是否允許訪問，返回true表示允許
      */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
    	return false;
    }
    /**
     * 表示訪問拒絕時是否自己處理，如果返回true表示自己不處理且繼續攔截器鏈執行，返回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();

        // 初始化使用者的佇列放到快取裡
        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.getFirst();
                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
            	e.printStackTrace();
            }
        }

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