SpringSession系列之通过Redis统计在线用户数量

柔情只为你懂 2021-09-07 06:19 434阅读 0赞

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

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

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里的数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0MjczOTE_size_16_color_FFFFFF_t_70]  
这个`ssoLoginUser` key是自己登录时候设置的，根据业务修改，经过测试，在登出系统时候，session设置过期获取removeAttribute不能清redis里的key数据，所以只能在登出系统逻辑加上：

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");
    		}
    	}
    }

进行数据统计：

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：

<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：

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);
    	}
    }

ok，本博客只能学习参考，要做比较齐全的在线用户统计，需要花多点时间，有问题希望能指出

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ0MjczOTE_size_16_color_FFFFFF_t_70]: /images/20210813/b45a6d7018aa41488d2817013b7c99cc.png