前言：
由于项目需求，需要在集群环境下实现在线用户列表的功能，并依靠在线列表实现用户单一登陆（同一账户只能一处登陆）功能：
在单机环境下，在线列表的实现方案可以采用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
