前言：
由于项目需求，需要在集群环境下实现在线用户列表的功能，并依靠在线列表实现用户单一登陆（同一账户只能一处登陆）功能：
在单机环境下，在线列表的实现方案可以采用SessionListener来完成，当有Session创建和销毁的时候做相应的操作即可完成功能及将相应的Session的引用存放于内存中，由于持有了所有的Session的引用，故可以方便的实现用户单一登陆的功能（比如在第二次登陆的时候使之前登陆的账户所在的Session失效）。
而在集群环境下，由于用户的请求可能分布在不同的Web服务器上，继续将在线用户列表储存在单机内存中已经不能满足需要，不同的Web服务器将会产生不同的在线列表，并且不能有效的实现单一用户登陆的功能，因为某一用户可能并不在接受到退出请求的Web服务器的在线用户列表中（在集群中的某台服务器上完成的登陆操作，而在其他服务器上完成退出操作）。
现有解决方案：
1.将用户的在线情况记录进入数据库中，依靠数据库完成对登陆状况的检测
2.将在线列表放在一个公共的缓存服务器上
由于缓存服务器可以为缓存内容设置指定有效期，可以方便实现Session过期的效果，以及避免让数据库的读写性能成为系统瓶颈等原因，我们采用了Redis来作为缓存服务器用于实现该功能。
单机环境下的解决方案：
基于HttpSessionListener：
1 import java.util.Date;
2 import java.util.Hashtable;
3 import java.util.Iterator;
4 import javax.servlet.http.HttpSession;
5 import javax.servlet.http.HttpSessionEvent;
6 import javax.servlet.http.HttpSessionListener;
7 import com.xxx.common.util.StringUtil;
8 /**
9 *
10 * @ClassName: SessionListener
11 * @Description: 记录所有登陆的Session信息，为在线列表做基础
12 * @author libaoting
13 * @date 2013-9-18 09:35:13
14 *
15 */
16 public class SessionListener implements HttpSessionListener {
17 //在线列表<uid,session>
18 private static Hashtable<String,HttpSession> sessionList = new Hashtable<String, HttpSession>();
19 public void sessionCreated(HttpSessionEvent event) {
20 //不做处理，只处理登陆用户的列表
21 }
22 public void sessionDestroyed(HttpSessionEvent event) {
23 removeSession(event.getSession());
24 }
25 public static void removeSession(HttpSession session){
26 if(session == null){
27 return ;
28 }
29 String uid=(String)session.getAttribute("clientUserId");//已登陆状态会将用户的UserId保存在session中
30 if(!StringUtil.isBlank(uid)){//判断是否登陆状态
31 removeSession(uid);
32 }
33 }
34 public static void removeSession(String uid){
35 HttpSession session = sessionList.get(uid);
36 try{
37 sessionList.remove(uid);//先执行，防止session.invalidate()报错而不执行
38 if(session != null){
39 session.invalidate();
40 }
41 }catch (Exception e) {
42 System.out.println("Session invalidate error!");
43 }
44 }
45 public static void addSession(String uid,HttpSession session){
46 sessionList.put(uid, session);
47 }
48 public static int getSessionCount(){
49 return sessionList.size();
50 }
51 public static Iterator<HttpSession> getSessionSet(){
52 return sessionList.values().iterator();
53 }
54 public static HttpSession getSession(String id){
55 return sessionList.get(id);
56 }
57 public static boolean contains(String uid){
58 return sessionList.containsKey(uid);
59 }
60 /**
61 *
62 * @Title: isLoginOnThisSession
63 * @Description: 检测是否已经登陆
64 * @param @param uid 用户UserId
65 * @param @param sid 发起请求的用户的SessionId
66 * @return boolean true 校验通过
67 */
68 public static boolean isLoginOnThisSession(String uid,String sid){
69 if(uid==null||sid==null){
70 return false;
71 }
72 if(contains(uid)){
73 HttpSession session = sessionList.get(uid);
74 if(session!=null&&session.getId().equals(sid)){
75 return true;
76 }
77 }
78 return false;
79 }
80 }用户的在线状态全部维护记录在sessionList中，并且可以通过sessionList获取到任意用户的session对象，可以用来完成使指定用户离线的功能(调用该用户的session.invalidate()方法)。
用户登录的时候调用addSession(uid,session)方法将用户与其登录的Session信息记录至sessionList中，再退出的时候调用removeSession(session) or removeSession(uid)方法，在强制下线的时候调用removeSession(uid)方法，以及一些其他的操作即可实现相应的功能。
基于Redis的解决方案：
该解决方案的实质是将在线列表的所在的内存共享出来，让集群环境下所有的服务器都能够访问到这部分数据，并且将用户的在线状态在这块内存中进行维护。
Redis连接池工具类：
1 import java.util.ResourceBundle;
2 import redis.clients.jedis.Jedis;
3 import redis.clients.jedis.JedisPool;
4 import redis.clients.jedis.JedisPoolConfig;
5 public class RedisPoolUtils {
6 private static final JedisPool pool;
7 static{
8 ResourceBundle bundle = ResourceBundle.getBundle("redis");
9 JedisPoolConfig config = new JedisPoolConfig();
10 if (bundle == null) {
11 throw new IllegalArgumentException("[redis.properties] is not found!");
12 }
13 //设置池配置项值
14 config.setMaxActive(Integer.valueOf(bundle.getString("jedis.pool.maxActive")));
15 config.setMaxIdle(Integer.valueOf(bundle.getString("jedis.pool.maxIdle")));
16 config.setMaxWait(Long.valueOf(bundle.getString("jedis.pool.maxWait")));
17 config.setTestOnBorrow(Boolean.valueOf(bundle.getString("jedis.pool.testOnBorrow")));
18 config.setTestOnReturn(Boolean.valueOf(bundle.getString("jedis.pool.testOnReturn")));
19 pool = new JedisPool(config, bundle.getString("redis.ip"),Integer.valueOf(bundle.getString("redis.port")) );
20 }
21 /**
22 *
23 * @Title: release
24 * @Description: 释放连接
25 * @param @param jedis
26 * @return void
27 * @throws
28 */
29 public static void release(Jedis jedis){
30 pool.returnResource(jedis);
31 }
32 public static Jedis getJedis(){
33 return pool.getResource();
34 }
35 }
36 Redis在线列表工具类：
37 import java.util.ArrayList;
38 import java.util.Collections;
39 import java.util.Comparator;
40 import java.util.Date;
41 import java.util.List;
42 import java.util.Set;
43 import net.sf.json.JSONObject;
44 import net.sf.json.JsonConfig;
45 import net.sf.json.processors.JsonValueProcessor;
46 import cn.sccl.common.util.StringUtil;
47 import com.xxx.common.util.JsonDateValueProcessor;
48 import com.xxx.user.model.ClientUser;
49 import redis.clients.jedis.Jedis;
50 import redis.clients.jedis.Pipeline;
51 import tools.Constants;
52 /**
53 *
54 * Redis缓存中存放两组key：
55 * 1.SID_PREFIX开头，存放登陆用户的SessionId与ClientUser的Json数据
56 * 2.UID_PREFIX开头，存放登录用户的UID与SessionId对于的数据
57 *
58 * 3.VID_PREFIX开头，存放位于指定页面用户的数据（与Ajax一起使用，用于实现指定页面同时浏览人数的限制功能）
59 *
60 * @ClassName: OnlineUtils
61 * @Description: 在线列表操作工具类
62 * @author BuilderQiu
63 * @date 2014-1-9 上午09:25:43
64 *
65 */
66 public class OnlineUtils {
67 //KEY值根据SessionID生成
68 private static final String SID_PREFIX = "online:sid:";
69 private static final String UID_PREFIX = "online:uid:";
70 private static final String VID_PREFIX = "online:vid:";
71 private static final int OVERDATETIME = 30 * 60;
72 private static final int BROADCAST_OVERDATETIME = 70;//ax每60秒发起一次，超过BROADCAST_OVERDATETIME时间长度未发起表示已经离开该页面
73 public static void login(String sid,ClientUser user){
74 Jedis jedis = RedisPoolUtils.getJedis();
75 jedis.setex(SID_PREFIX+sid, OVERDATETIME, userToString(user));
76 jedis.setex(UID_PREFIX+user.getId(), OVERDATETIME, sid);
77 RedisPoolUtils.release(jedis);
78 }
79 public static void broadcast(String uid,String identify){
80 if(uid==null||"".equals(uid)) //异常数据，正常情况下登陆用户才会发起该请求
81 return ;
82 Jedis jedis = RedisPoolUtils.getJedis();
83 jedis.setex(VID_PREFIX+identify+":"+uid, BROADCAST_OVERDATETIME, uid);
84 RedisPoolUtils.release(jedis);
85 }
86 private static String userToString(ClientUser user){
87 JsonConfig config = new JsonConfig();
88 JsonValueProcessor processor = new JsonDateValueProcessor("yyyy-MM-dd HH:mm:ss");
89 config.registerJsonValueProcessor(Date.class, processor);
90 JSONObject obj = JSONObject.fromObject(user, config);
91 return obj.toString();
92 }
93 /**
94 *
95 * @Title: logout
96 * @Description: 退出
97 * @param @param sessionId
98 * @return void
99 * @throws
100 */
101 public static void logout(String sid,String uid){
102 Jedis jedis = RedisPoolUtils.getJedis();
103 jedis.del(SID_PREFIX+sid);
104 jedis.del(UID_PREFIX+uid);
105 RedisPoolUtils.release(jedis);
106 }
107 /**
108 *
109 * @Title: logout
110 * @Description: 退出
111 * @param @param UserId 使指定用户下线
112 * @return void
113 * @throws
114 */
115 public static void logout(String uid){
116 Jedis jedis = RedisPoolUtils.getJedis();
117 //删除sid
118 jedis.del(SID_PREFIX+jedis.get(UID_PREFIX+uid));
119 //删除uid
120 jedis.del(UID_PREFIX+uid);
121 RedisPoolUtils.release(jedis);
122 }
123 public static String getClientUserBySessionId(String sid){
124 Jedis jedis = RedisPoolUtils.getJedis();
125 String user = jedis.get(SID_PREFIX+sid);
126 RedisPoolUtils.release(jedis);
127 return user;
128 }
129 public static String getClientUserByUid(String uid){
130 Jedis jedis = RedisPoolUtils.getJedis();
131 String user = jedis.get(SID_PREFIX+jedis.get(UID_PREFIX+uid));
132 RedisPoolUtils.release(jedis);
133 return user;
134 }
135 /**
136 *
137 * @Title: online
138 * @Description: 所有的key
139 * @return List
140 * @throws
141 */
142 public static List online(){
143 Jedis jedis = RedisPoolUtils.getJedis();
144 Set online = jedis.keys(SID_PREFIX+"*");
145 RedisPoolUtils.release(jedis);
146 return new ArrayList(online);
147 }
148 /**
149 *
150 * @Title: online
151 * @Description: 分页显示在线列表
152 * @return List
153 * @throws
154 */
155 public static List onlineByPage(int page,int pageSize) throws Exception{
156 Jedis jedis = RedisPoolUtils.getJedis();
157 Set onlineSet = jedis.keys(SID_PREFIX+"*");
158 List onlines =new ArrayList(onlineSet);
159 if(onlines.size() == 0){
160 return null;
161 }
162 Pipeline pip = jedis.pipelined();
163 for(Object key:onlines){
164 pip.get(getKey(key));
165 }
166 List result = pip.syncAndReturnAll();
167 RedisPoolUtils.release(jedis);
168 List<ClientUser> listUser=new ArrayList<ClientUser>();
169 for(int i=0;i<result.size();i++){
170 listUser.add(Constants.json2ClientUser((String)result.get(i)));
171 }
172 Collections.sort(listUser,new Comparator<ClientUser>(){
173 public int compare(ClientUser o1, ClientUser o2) {
174 return o2.getLastLoginTime().compareTo(o1.getLastLoginTime());
175 }
176 });
177 onlines=listUser;
178 int start = (page - 1) * pageSize;
179 int toIndex=(start+pageSize)>onlines.size()?onlines.size():start+pageSize;
180 List list = onlines.subList(start, toIndex);
181 return list;
182 }
183 private static String getKey(Object obj){
184 String temp = String.valueOf(obj);
185 String key[] = temp.split(":");
186 return SID_PREFIX+key[key.length-1];
187 }
188 /**
189 *
190 * @Title: onlineCount
191 * @Description: 总在线人数
192 * @param @return
193 * @return int
194 * @throws
195 */
196 public static int onlineCount(){
197 Jedis jedis = RedisPoolUtils.getJedis();
198 Set online = jedis.keys(SID_PREFIX+"*");
199 RedisPoolUtils.release(jedis);
200 return online.size();
201 }
202 /**
203 * 获取指定页面在线人数总数
204 */
205 public static int broadcastCount(String identify) {
206 Jedis jedis = RedisPoolUtils.getJedis();
207 Set online = jedis.keys(VID_PREFIX+identify+":*");
208 RedisPoolUtils.release(jedis);
209 return online.size();
210 }
211 /**
212 * 自己是否在线
213 */
214 public static boolean broadcastIsOnline(String identify,String uid) {
215 Jedis jedis = RedisPoolUtils.getJedis();
216 String online = jedis.get(VID_PREFIX+identify+":"+uid);
217 RedisPoolUtils.release(jedis);
218 return !StringUtil.isBlank(online);//不为空就代表已经找到数据了，也就是上线了
219 }
220 /**
221 * 获取指定页面在线人数总数
222 */
223 public static int broadcastCount() {
224 Jedis jedis = RedisPoolUtils.getJedis();
225 Set online = jedis.keys(VID_PREFIX+"*");
226 RedisPoolUtils.release(jedis);
227 return online.size();
228 }
229 /**
230 *
231 * @Title: isOnline
232 * @Description: 指定账号是否登陆
233 * @param @param sessionId
234 * @param @return
235 * @return boolean
236 * @throws
237 */
238 public static boolean isOnline(String uid){
239 Jedis jedis = RedisPoolUtils.getJedis();
240 boolean isLogin = jedis.exists(UID_PREFIX+uid);
241 RedisPoolUtils.release(jedis);
242 return isLogin;
243 }
244 public static boolean isOnline(String uid,String sid){
245 Jedis jedis = RedisPoolUtils.getJedis();
246 String loginSid = jedis.get(UID_PREFIX+uid);
247 RedisPoolUtils.release(jedis);
248 return sid.equals(loginSid);
249 }
250 }由于在线状态是记录在Redis中的，并不单纯依靠Session的过期机制来实现，所以需要通过拦截器在每次发送请求的时候去更新Redis中相应的缓存过期时间来更新用户的在线状态。
登陆、退出操作与单机版相似，强制下线需要配合拦截器实现，当用户下次访问的时候，自己来校验自己的状态是否为已经下线，不再由服务器控制。
配合拦截器实现在线状态维持与强制登陆(使其他地方登陆了该账户的用户下线)功能：
1 ...
2 if(uid != null){//已登录
3 if(!OnlineUtils.isOnline(uid, session.getId())){
4 session.invalidate();
5 return ai.invoke();
6 }else{
7 OnlineUtils.login(session.getId(), (ClientUser)session.getAttribute("clientUser"));
8 //刷新缓存
9 }
10 }
11 ...注：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
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
