[項目回顧]基於Redis的在線用戶列表解決方案

遷移：基於Redis的在線用戶列表解決方案

前言：

　　由於項目需求，需要在集群環境下實現在線用戶列表的功能，並依靠在線列表實現用戶單一登陸（同一賬戶只能一處登陸）功能：

　　在單機環境下，在線列表的實現方案可以采用SessionListener來完成，當有Session創建和銷毀的時候做相應的操作即可完成功能及將相應的Session的引用存放於內存中，由於持有了所有的Session的引用，故可以方便的實現用戶單一登陸的功能（比如在第二次登陸的時候使之前登陸的賬戶所在的Session失效）。

　　而在集群環境下，由於用戶的請求可能分布在不同的Web服務器上，繼續將在線用戶列表儲存在單機內存中已經不能滿足需要，不同的Web服務器將會產生不同的在線列表，並且不能有效的實現單一用戶登陸的功能，因為某一用戶可能並不在接受到退出請求的Web服務器的在線用戶列表中（在集群中的某台服務器上完成的登陸操作，而在其他服務器上完成退出操作）。

　　現有解決方案：

　　1.將用戶的在線情況記錄進入數據庫中，依靠數據庫完成對登陸狀況的檢測

　　2.將在線列表放在一個公共的緩存服務器上

　　由於緩存服務器可以為緩存內容設置指定有效期，可以方便實現Session過期的效果，以及避免讓數據庫的讀寫性能成為系統瓶頸等原因，我們采用了Redis來作為緩存服務器用於實現該功能。

單機環境下的解決方案：

　　基於HttpSessionListener：

import java.util.Date;
import java.util.Hashtable;
import java.util.Iterator;

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

import com.xxx.common.util.StringUtil;

/**
 * 
 * @ClassName: SessionListener
 * @Description: 記錄所有登陸的Session信息，為在線列表做基礎
 * @author BuilderQiu
 * @date 2013-9-18 09:35:13
 *
 */
public class SessionListener implements HttpSessionListener {
    
    //在線列表<uid,session>
    private static Hashtable<String,HttpSession> sessionList = new Hashtable<String, HttpSession>();
    

    public void sessionCreated(HttpSessionEvent event) {
        //不做處理，只處理登陸用戶的列表
        
    }

    public void sessionDestroyed(HttpSessionEvent event) {
        removeSession(event.getSession());
    }
    
    public static void removeSession(HttpSession session){
        if(session == null){
            return ;
        }

        String uid=(String)session.getAttribute("clientUserId");//已登陸狀態會將用戶的UserId保存在session中
        if(!StringUtil.isBlank(uid)){//判斷是否登陸狀態
            removeSession(uid);
        }
    }
    
    public static void removeSession(String uid){
        HttpSession session = sessionList.get(uid);
        try{
            sessionList.remove(uid);//先執行，防止session.invalidate()報錯而不執行
            if(session != null){
                session.invalidate();
            }
        }catch (Exception e) {
            System.out.println("Session invalidate error!");
        }
    }
    
    public static void addSession(String uid,HttpSession session){
        sessionList.put(uid, session);
    }
    
    public static int getSessionCount(){
        return sessionList.size();
    }
    
    public static Iterator<HttpSession> getSessionSet(){
        return sessionList.values().iterator();
    }
    
    public static HttpSession getSession(String id){
        return sessionList.get(id);
    }
    
    public static boolean contains(String uid){
        return sessionList.containsKey(uid);
    }
    
    /**
     * 
     * @Title: isLoginOnThisSession
     * @Description: 檢測是否已經登陸
     * @param @param uid 用戶UserId
     * @param @param sid 發起請求的用戶的SessionId
     * @return boolean true 校驗通過 
     */
    public static boolean isLoginOnThisSession(String uid,String sid){
        if(uid==null||sid==null){
            return false;
        }
        if(contains(uid)){
            HttpSession session = sessionList.get(uid);
            
            if(session!=null&&session.getId().equals(sid)){
                return true;
            }
        }
        return false;
    }
    
}

　　用戶的在線狀態全部維護記錄在sessionList中，並且可以通過sessionList獲取到任意用戶的session對象，可以用來完成使指定用戶離線的功能(調用該用戶的session.invalidate()方法)。

　　用戶登錄的時候調用addSession(uid,session)方法將用戶與其登錄的Session信息記錄至sessionList中，再退出的時候調用removeSession(session) or removeSession(uid)方法，在強制下線的時候調用removeSession(uid)方法，以及一些其他的操作即可實現相應的功能。

基於Redis的解決方案：

　　該解決方案的實質是將在線列表的所在的內存共享出來，讓集群環境下所有的服務器都能夠訪問到這部分數據，並且將用戶的在線狀態在這塊內存中進行維護。

　　Redis連接池工具類：

import java.util.ResourceBundle;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisPoolUtils {
    
    private static final JedisPool pool;
    
    static{
        ResourceBundle bundle = ResourceBundle.getBundle("redis");
        JedisPoolConfig config = new JedisPoolConfig();
        if (bundle == null) {    
            throw new IllegalArgumentException("[redis.properties] is not found!");    
        }
        //設置池配置項值  
        config.setMaxActive(Integer.valueOf(bundle.getString("jedis.pool.maxActive")));    
        config.setMaxIdle(Integer.valueOf(bundle.getString("jedis.pool.maxIdle")));    
        config.setMaxWait(Long.valueOf(bundle.getString("jedis.pool.maxWait")));    
        config.setTestOnBorrow(Boolean.valueOf(bundle.getString("jedis.pool.testOnBorrow")));    
        config.setTestOnReturn(Boolean.valueOf(bundle.getString("jedis.pool.testOnReturn")));
        
        pool = new JedisPool(config, bundle.getString("redis.ip"),Integer.valueOf(bundle.getString("redis.port")) );
    }
    
    /**
     * 
     * @Title: release
     * @Description: 釋放連接
     * @param @param jedis
     * @return void
     * @throws
     */
    public static void release(Jedis jedis){
        pool.returnResource(jedis);
    }
    
    public static Jedis getJedis(){
        return pool.getResource();
    }

}

　　Redis在線列表工具類：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Set;

import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;

import cn.sccl.common.util.StringUtil;

import com.xxx.common.util.JsonDateValueProcessor;
import com.xxx.user.model.ClientUser;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import tools.Constants;

/**
 * 
 * Redis緩存中存放兩組key：
 * 1.SID_PREFIX開頭，存放登陸用戶的SessionId與ClientUser的Json數據
 * 2.UID_PREFIX開頭，存放登錄用戶的UID與SessionId對於的數據
 *
 * 3.VID_PREFIX開頭，存放位於指定頁面用戶的數據（與Ajax一起使用，用於實現指定頁面同時瀏覽人數的限制功能）
 * 
 * @ClassName: OnlineUtils
 * @Description: 在線列表操作工具類
 * @author BuilderQiu
 * @date 2014-1-9 上午09:25:43
 *
 */
public class OnlineUtils {
    
    //KEY值根據SessionID生成    
    private static final String SID_PREFIX = "online:sid:";
    private static final String UID_PREFIX = "online:uid:";
    private static final String VID_PREFIX = "online:vid:";
    private static final int OVERDATETIME = 30 * 60;
    private static final int BROADCAST_OVERDATETIME = 70;//Ajax每60秒發起一次，超過BROADCAST_OVERDATETIME時間長度未發起表示已經離開該頁面

    public static void login(String sid,ClientUser user){
        
        Jedis jedis = RedisPoolUtils.getJedis();

        jedis.setex(SID_PREFIX+sid, OVERDATETIME, userToString(user));
        jedis.setex(UID_PREFIX+user.getId(), OVERDATETIME, sid);
        
        RedisPoolUtils.release(jedis);
    }
    
    public static void broadcast(String uid,String identify){
        
        if(uid==null||"".equals(uid)) //異常數據，正常情況下登陸用戶才會發起該請求
            return ;
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        jedis.setex(VID_PREFIX+identify+":"+uid, BROADCAST_OVERDATETIME, uid);
        
        RedisPoolUtils.release(jedis);
    }
    
    
    private static String userToString(ClientUser user){
        JsonConfig  config = new JsonConfig();
        JsonValueProcessor processor = new JsonDateValueProcessor("yyyy-MM-dd HH:mm:ss");
        config.registerJsonValueProcessor(Date.class, processor);
        JSONObject obj = JSONObject.fromObject(user, config);

        return obj.toString();
    }
    
    /**
     * 
     * @Title: logout
     * @Description: 退出
     * @param @param sessionId
     * @return void
     * @throws
     */
    public static void logout(String sid,String uid){
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        jedis.del(SID_PREFIX+sid);
        jedis.del(UID_PREFIX+uid);
        
        RedisPoolUtils.release(jedis);
    }
    
    /**
     * 
     * @Title: logout
     * @Description: 退出
     * @param @param UserId  使指定用戶下線
     * @return void
     * @throws
     */
    public static void logout(String uid){
        Jedis jedis = RedisPoolUtils.getJedis();
        
        //刪除sid
        jedis.del(SID_PREFIX+jedis.get(UID_PREFIX+uid));
        //刪除uid
        jedis.del(UID_PREFIX+uid);
        
        RedisPoolUtils.release(jedis);
    }
    
    public static String getClientUserBySessionId(String sid){
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        String user = jedis.get(SID_PREFIX+sid);
        
        RedisPoolUtils.release(jedis);
        
        return user;
    }
    
    public static String getClientUserByUid(String uid){
        Jedis jedis = RedisPoolUtils.getJedis();
        
        String user = jedis.get(SID_PREFIX+jedis.get(UID_PREFIX+uid));
        
        RedisPoolUtils.release(jedis);
        
        return user;
    }
    
    /**
     * 
     * @Title: online
     * @Description: 所有的key
     * @return List  
     * @throws
     */
    public static List online(){

        Jedis jedis = RedisPoolUtils.getJedis();
        
        Set online = jedis.keys(SID_PREFIX+"*");
        
        RedisPoolUtils.release(jedis);
        return new ArrayList(online);
    }
    
    /**
     * 
     * @Title: online
     * @Description: 分頁顯示在線列表
     * @return List  
     * @throws
     */
    public static List onlineByPage(int page,int pageSize) throws Exception{
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        Set onlineSet = jedis.keys(SID_PREFIX+"*");
        
        
        List onlines =new ArrayList(onlineSet);
        
        if(onlines.size() == 0){
            return null;
        }
        
        Pipeline pip = jedis.pipelined();
        for(Object key:onlines){
            pip.get(getKey(key));
        }
        List result = pip.syncAndReturnAll();
        RedisPoolUtils.release(jedis);
        
        List<ClientUser> listUser=new ArrayList<ClientUser>();
        for(int i=0;i<result.size();i++){
            listUser.add(Constants.json2ClientUser((String)result.get(i)));
        }
        Collections.sort(listUser,new Comparator<ClientUser>(){
            public int compare(ClientUser o1, ClientUser o2) {
                return o2.getLastLoginTime().compareTo(o1.getLastLoginTime());
            }
        });
        onlines=listUser;
        int start = (page - 1) * pageSize;
        int toIndex=(start+pageSize)>onlines.size()?onlines.size():start+pageSize;
        List list = onlines.subList(start, toIndex);
    
        return list;
    }
    
    private static String getKey(Object obj){
        
        String temp = String.valueOf(obj);
        String key[] = temp.split(":");

        return SID_PREFIX+key[key.length-1];
    }
    
    /**
     * 
     * @Title: onlineCount
     * @Description: 總在線人數
     * @param @return
     * @return int
     * @throws
     */
    public static int onlineCount(){
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        Set online = jedis.keys(SID_PREFIX+"*");
        
        RedisPoolUtils.release(jedis);
        
        return online.size();
        
    }
    
    /**
     * 獲取指定頁面在線人數總數
     */
    public static int broadcastCount(String identify) {
        Jedis jedis = RedisPoolUtils.getJedis();
        
        Set online = jedis.keys(VID_PREFIX+identify+":*");
        
        

        RedisPoolUtils.release(jedis);
        
        return online.size();
    }
    
    /**
     * 自己是否在線
     */
    public static boolean broadcastIsOnline(String identify,String uid) {
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        String online = jedis.get(VID_PREFIX+identify+":"+uid);
        
        RedisPoolUtils.release(jedis);
        
        return !StringUtil.isBlank(online);//不為空就代表已經找到數據了，也就是上線了
    }
    
    /**
     * 獲取指定頁面在線人數總數
     */
    public static int broadcastCount() {
        Jedis jedis = RedisPoolUtils.getJedis();
        
        Set online = jedis.keys(VID_PREFIX+"*");
        
        RedisPoolUtils.release(jedis);
        
        return online.size();
    }
    
    
    /**
     * 
     * @Title: isOnline
     * @Description: 指定賬號是否登陸
     * @param @param sessionId
     * @param @return
     * @return boolean 
     * @throws
     */
    public static boolean isOnline(String uid){
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        boolean isLogin = jedis.exists(UID_PREFIX+uid);
        
        RedisPoolUtils.release(jedis);
        
        return isLogin;
    }
    
    public static boolean isOnline(String uid,String sid){
        
        Jedis jedis = RedisPoolUtils.getJedis();
        
        String loginSid = jedis.get(UID_PREFIX+uid);
        
        RedisPoolUtils.release(jedis);
        
        return sid.equals(loginSid);
    }
}

 　  由於在線狀態是記錄在Redis中的，並不單純依靠Session的過期機制來實現，所以需要通過攔截器在每次發送請求的時候去更新Redis中相應的緩存過期時間來更新用戶的在線狀態。

　　登陸、退出操作與單機版相似，強制下線需要配合攔截器實現，當用戶下次訪問的時候，自己來校驗自己的狀態是否為已經下線，不再由服務器控制。

　　配合攔截器實現在線狀態維持與強制登陸(使其他地方登陸了該賬戶的用戶下線)功能：

...
if(uid != null){//已登錄
    if(!OnlineUtils.isOnline(uid, session.getId())){
        session.invalidate();

        return ai.invoke();
    }else{
        OnlineUtils.login(session.getId(), (ClientUser)session.getAttribute("clientUser"));
        //刷新緩存
    }
}
...

注：Redis在線列表工具類中的部分代碼是后來需要實現限制同時訪問指定頁面瀏覽人數功能而添加的，同樣基於Redis實現，前端由Ajax輪詢來更新用戶停留頁面的狀態。

附錄：

　　Redis連接池配置文件：

###redis##config########
#redis服務器ip # 
#redis.ip=localhost
#redis服務器端口號#
redis.port=6379

###jedis##pool##config###
#jedis的最大分配對象#
jedis.pool.maxActive=1024
#jedis最大保存idel狀態對象數 #
jedis.pool.maxIdle=200
#jedis池沒有對象返回時，最大等待時間 #
jedis.pool.maxWait=1000
#jedis調用borrowObject方法時，是否進行有效檢查#
jedis.pool.testOnBorrow=true
#jedis調用returnObject方法時，是否進行有效檢查 #
jedis.pool.testOnReturn=true