当前位置：首页 > 数据库 > Redis > 详细页面

SpringSession通过Redis统计在线用户数量的实现代码

时间：2023-11-01来源：系统城装机大师作者：佚名

最近遇到一个比较紧急的任务，要求统计在线用户，目的是配合性能测评，要求证明自己系统的在线用户能够达标，不过系统因为历史原因，并没有这个功能，所以只能去springSession官网和网上搜资料，想到通过统计redis里缓存的数据

因为系统原先的逻辑是使用Spring Session加上Redis做的会话共享实现的单点登录，登录之后会在session设置一个key值表示用户已经登录过，同时重写HttpServletRequestWrapper 设置remoteUser数据值

1
2
3
4
5
6
7
8
9
10
11
12 class RemoteUserRequestWrapper extends HttpServletRequestWrapper {
String userCode;
RemoteUserRequestWrapper(HttpServletRequest request) {
super(request);
this.userCode = (String) request.getSession()
.getAttribute(org.apache.commons.lang3.StringUtils.isBlank(sessionKeyName)?DEFAULT_SESSION_KEY_NAME:sessionKeyName);
}
@Override
public String getRemoteUser() {
return userCode;
}
}

Spring Session缓存在redis里的数据

这个ssoLoginUser key是自己登录时候设置的，根据业务修改，经过测试，在登出系统时候，session设置过期获取removeAttribute不能清redis里的key数据，所以只能在登出系统逻辑加上：

1
2
3
4
5
6
7
8
9
10 Set<String> keys = RedisUtils.redisTemplate.keys("spring:session:sessions:*");
for(String key : keys){
if(key.indexOf("expires")==-1){
String s = (String)RedisUtils.redisTemplate.opsForHash().get(key, "sessionAttr:ssoLoginUser");
if(request.getRemoteUser().equals(s)) {
logger.info("loginusername:{}",s)
RedisUtils.redisTemplate.opsForHash().delete(key, "sessionAttr:ssoLoginUser");
}
}
}

进行数据统计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 List<Map<String,Object>> list = new ArrayList<Map<String, Object>>();
List<Map<String,Object>> data = new ArrayList<Map<String, Object>>();
Set<String> keys = redisTemplate.keys("spring:session:sessions:*");
for(String key : keys){
if(key.indexOf("expires")==-1){
String s = (String)redisTemplate.opsForHash().get(key, "sessionAttr:ssoLoginUser");
if(StringUtils.isNotBlank(s)) {
System.out.println(s);
Map<String,Object> map = new HashMap<String,Object>(16);
map.put("usercode", s);
list.add(map);
}
}
}
return list;

pom.xml：

1
2
3
4
5
6
7
8
9
10
11
12 <dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
<version>1.2.2.RELEASE</version>
<type>pom</type>
</dependency>

<dependency>
<groupId>biz.paluch.redis</groupId>
<artifactId>lettuce</artifactId>
<version>3.5.0.Final</version>
</dependency>

RedisUtils.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231 package com.common.utils.redis;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class RedisUtils {

private RedisUtils() {
}

@SuppressWarnings("unchecked")
public static RedisTemplate<String, Object> redisTemplate =
ContextLoader.getCurrentWebApplicationContext().getBean(RedisTemplate.class);

/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout) {

return expire(key, timeout, TimeUnit.SECONDS);
}

/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout, final TimeUnit unit) {

Boolean ret = redisTemplate.expire(key, timeout, unit);
return ret != null && ret;
}

/**
* 删除单个key
*
* @param key 键
* @return true=删除成功；false=删除失败
*/
public static boolean del(final String key) {

redisTemplate.delete(key);
return true;
}

/**
* 删除多个key
*
* @param keys 键集合
* @return 成功删除的个数
*/
public static long del(final Collection<String> keys) {

redisTemplate.delete(keys);
return 0;
}

/**
* 存入普通对象
*
* @param key Redis键
* @param value 值
*/
public static void set(final String key, final Object value) {

redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
}

// 存储普通对象操作

/**
* 存入普通对象
*
* @param key 键
* @param value 值
* @param timeout 有效期，单位秒
*/
public static void set(final String key, final Object value, final long timeout) {

redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
}

/**
* 获取普通对象
*
* @param key 键
* @return 对象
*/
public static Object get(final String key) {

return redisTemplate.opsForValue().get(key);
}

// 存储Hash操作

/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public static void hPut(final String key, final String hKey, final Object value) {

redisTemplate.opsForHash().put(key, hKey, value);
}

/**
* 往Hash中存入多个数据
*
* @param key Redis键
* @param values Hash键值对
*/
public static void hPutAll(final String key, final Map<String, Object> values) {

redisTemplate.opsForHash().putAll(key, values);
}

/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public static Object hGet(final String key, final String hKey) {

return redisTemplate.opsForHash().get(key, hKey);
}

/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public static List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {

return redisTemplate.opsForHash().multiGet(key, hKeys);
}

// 存储Set相关操作

/**
* 往Set中存入数据
*
* @param key Redis键
* @param values 值
* @return 存入的个数
*/
public static long sSet(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().add(key, values);
return count == null ? 0 : count;
}

/**
* 删除Set中的数据
*
* @param key Redis键
* @param values 值
* @return 移除的个数
*/
public static long sDel(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().remove(key, values);
return count == null ? 0 : count;
}

// 存储List相关操作

/**
* 往List中存入数据
*
* @param key Redis键
* @param value 数据
* @return 存入的个数
*/
public static long lPush(final String key, final Object value) {
Long count = redisTemplate.opsForList().rightPush(key, value);
return count == null ? 0 : count;
}

/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Collection<Object> values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}

/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Object... values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}

/**
* 从List中获取begin到end之间的元素
*
* @param key Redis键
* @param start 开始位置
* @param end 结束位置（start=0，end=-1表示获取全部元素）
* @return List对象
*/
public static List<Object> lGet(final String key, final int start, final int end) {
return redisTemplate.opsForList().range(key, start, end);
}
}