Bagaimanakah SpringSession mengira bilangan pengguna dalam talian melalui Redis?

Oleh kerana logik asal sistem adalah log masuk tunggal menggunakan Sesi Musim Bunga ditambah perkongsian sesi oleh Redis Selepas log masuk, nilai kunci akan ditetapkan dalam sesi untuk menunjukkan bahawa pengguna telah log masuk, dan HttpServletRequestWrapper akan. ditulis semula untuk menetapkan nilai data Pengguna jauh

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

Data dicache oleh Sesi Musim Bunga dalam redis

KuncissoLoginUser ini ditetapkan apabila anda log masuk. Mengikut kepada pengubahsuaian perniagaan, selepas ujian, selepas log keluar Dalam sistem, jika tetapan sesi tamat tempoh dan removeAttribute diperoleh, data utama dalam redis tidak boleh dikosongkan, jadi satu-satunya cara untuk log keluar daripada sistem adalah dengan menambah:

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

untuk statistik data:

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

Atas ialah kandungan terperinci Bagaimanakah SpringSession mengira bilangan pengguna dalam talian melalui Redis?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!