Redis实现同一账号登录个数限制

浅浅的花香味﹌ 2024-02-18 23:02 49阅读 0赞

场景：

最近接到一个需求，为了方便用户使用，系统的同一个用户账号可以在5个浏览器是登录，第六个登录的把第一个挤掉，而且用户登录后长时间不操作是需要自动过期的，也就是说需要有session过期时间；

## 一、分析 ##

从需求来看，用户被强制下线有两种可能，一个是session过期，二个是被后面登录的挤掉；第6个登录的把第1个登录的挤掉，那么我们就需要统计登录个数以及找到最早登录的信息；这么一想就联想到了Redis，可以使用Redis的String和ZSet数据结构来实现；

String存储的作用：session过期，需要重新登录；

ZSet存储的作用：后面登录的挤掉最先登录的；

ZSet具有排序的功能；用户登录后就是一个会话，就会产生一个session，不同的session不同的sessionid，所以：

**一、**使用sessionID作为key,userName作为value并且设置过期时间存储到redis的String类型的数据结构里；

**二、**然后把userName作为key，sessionID作为value，存储到ZSet类型的数据结构里，使用系统时间作为分数，设置过期时间；这样，ZSet就会根据时间进行排序，每次登录都先根据userName统计一次ZSet中存储的的个数，如果大于等于5，就删除最早存储的一个。（set里面，更新一个value 剩下的四个value过期时间也都更新，所以，只要同一个账号在过期时间之前登录，set的过期时间就刷新了，可以说，只要string里面存储的sessionId不过期，对应的set就不过期）

登录时通过redis的zcart方法判断ZSet中username对应的登录数量，如果大于等于5就清除最早登录的一组数据，然后把当前登录的信息存储到redis中。否则，直接存储到redis当中即可。

**1、ZSet数据存储结构**

![70][]

**2、ZString数据存储结构**

![70 1][]

## 二、实现 ##

### 第一步：实现操作String和ZSet的方法 ###

连接redis这里就不写了，可以使用JedisCluster，也可以使用spring-data-redis针对jedis提供的一个高度封装的**“RedisTemplate”类（简单方便）**，这里使用的是JedisCluster，为了方便操作，这里写了两个操作工具类：

#### 1. String数据结构操作工具类 ####

package com.zhh.redis.util;
    
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import redis.clients.jedis.JedisCluster;
    
    /**
     * Redis 操作工具类 ：String数据结构
     * @author  zhaoheng
     * 2018-06-27 
     */
    @Component
    public class RedisJpaTemplateString {
        private static final Logger log = Logger.getLogger(RedisJpaTemplateString.class.getName());
    
        @Autowired
        private JedisCluster   jedisCluster;
        
        /**
         * 默认过期时间 （单位：秒）
         */
        private int expireTime = 24*60*60;
    
        /**
         * 用于隔开缓存前缀与缓存键值 
         */
        private static final String KEY_SPLIT = ":"; 
    
        /**
         * 设置缓存 
         * @param prefix 缓存前缀（用于区分缓存，防止缓存键值重复）
         * @param key    缓存key
         * @param value  缓存value
         */
        public void setWithPrefix(String prefix, String key, String value) {
            jedisCluster.set(prefix + KEY_SPLIT + key, value);
            log.info("RedisJpaTemplateString:set cache key="+prefix + KEY_SPLIT + key+",value="+value);
        }
    
        /**
         * 设置缓存，并且自己指定过期时间
         * @param prefix
         * @param key
         * @param value
         * @param expireTime 过期时间(秒)
         */
        public void setWithExpireTime(String prefix, String key, String value, int expireTime) {
            jedisCluster.setex(prefix + KEY_SPLIT + key, expireTime, value);
            log.info("RedisJpaTemplateString:setWithExpireTime cache key="+prefix + KEY_SPLIT + key+",value="+value+",expireTime="+expireTime);
        }
    
        /**
         * 设置缓存，并且由配置文件指定过期时间
         * @param prefix
         * @param key
         * @param value
         */
        public void setWithExpireTime(String prefix, String key, String value) {
            jedisCluster.setex(prefix + KEY_SPLIT + key, expireTime, value);
            log.info("RedisJpaTemplateString:setWithExpireTime cache key="+prefix + KEY_SPLIT + key+",value="+value+",expireTime="+expireTime);
        }
     /**
         * 设置 key 的过期时间(如果已经存在过期时间则刷新过期时间)
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @param expireTime 过期时间
         * @return 设置成功返回 1
         */
    	public Long setOrRefurbishExpireTime(String prefix, String key, int expireTime) {
    		  long number = jedisCluster.expire(prefix + KEY_SPLIT + key, expireTime);
    	      log.info("RedisJpaTemplateString:setWithExpireTime cache key="+prefix + KEY_SPLIT + key+" expireTime="+expireTime+" 执行返回结果:"+number);
    		return number;
    	}
    
    
        /**
         * 获取指定key的缓存
         * @param prefix
         * @param key
         */
        public String getWithPrefix(String prefix, String key) {
            String value = jedisCluster.get(prefix + KEY_SPLIT + key);
            log.info("RedisJpaTemplateString:get cache key="+prefix + KEY_SPLIT + key+",value="+value);
            return value;
        }
    
        /**
         * 删除指定key的缓存
         * @param prefix
         * @param key
         */
        public void deleteWithPrefix(String prefix, String key) {
            jedisCluster.del(prefix + KEY_SPLIT + key);
            log.info("RedisJpaTemplateString:delete cache key="+prefix + KEY_SPLIT + key);
        }
          /**
         * 检查给定 key 是否存在 若 key 存在返回 true ，否则返回false 
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @return 
         */
    	public Boolean exists(String prefix, String key) {
    		Boolean flag = jedisCluster.exists(prefix + KEY_SPLIT + key);
    		log.info("RedisJpaTemplateString:exists cache key="+prefix + KEY_SPLIT + key+" 执行返回结果:"+flag);
    		return flag;
    	}
    
    
        public JedisCluster getJedisCluster() {
    		return jedisCluster;
    	}
    
    	public void setJedisCluster(JedisCluster jedisCluster) {
    		this.jedisCluster = jedisCluster;
    	}
    	public int getExpireTime() {
    		return expireTime;
    	}
    	public void setExpireTime(int expireTime) {
    		this.expireTime = expireTime;
    	}
    }

#### 2. ZSet数据结构操作工具类 ####

package com.zhh.redis.util;
    
    import java.util.Set;
    
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import redis.clients.jedis.JedisCluster;
    
    /**
     * Redis 操作工具类 ：ZSet数据结构
     * @author zhaoheng
     * 2018-06-26
     */
    @Component
    public class RedisJpaTemplateZSet {
    	private static final Logger log = Logger.getLogger(RedisJpaTemplateZSet.class.getName());
    	
    	@Autowired
        private JedisCluster   jedisCluster;
    	
    	private static final String KEY_SPLIT = ":"; //用于隔开缓存前缀与缓存键值 
    
    	/**
    	 * 将带有给定分值的成员添加到有序列表里面
    	 * @param prefix 缓存前缀（用于区分缓存，防止缓存键值重复）
    	 * @param key 缓存key
    	 * @param value 缓存value
    	 * @param score 用于排名的数值（分数）
    	 * @return 返回添加成功的数量
    	 */
    	public Long add(String prefix,String key, String value, double score) {
    		long number = jedisCluster.zadd(prefix + KEY_SPLIT + key, score, value);
            log.info("ZSetOperationsImpl:add cache key="+prefix + KEY_SPLIT + key+",value="+value+" score="+score+" 执行返回结果:"+number);
            return number;
    	}
    
        /**
    	 * 返回有序集合包含的成员数量
    	 * @param prefix 缓存前缀
    	 * @param key 缓存key
    	 * @return
    	 */
    	public Long size(String prefix,String key) {
            long number = jedisCluster.zcard(prefix + KEY_SPLIT + key);
            log.info("ZSetOperationsImpl:size cache key="+prefix + KEY_SPLIT + key+" 执行返回结果:"+number);
    		return number;
    	}
    
    	 /**
    	  * 返回有序集合中排名介于start和end之间的成员，包括start和end在内
    	  * @param prefix 缓存前缀
    	  * @param key 缓存key
    	  * @param start 排名区间开始值
    	  * @param end 排名区间结束值
    	  * @return
    	  */
    	public Set<String> range(String prefix, String key, long start, long end) {
    		Set<String> set = jedisCluster.zrange(prefix + KEY_SPLIT + key, start, end);
            log.info("ZSetOperationsImpl:range cache key="+prefix + KEY_SPLIT + key+" start="+start+" end="+end);
    		return set;
    	}
    	
    	 /**
    	  * 移除有序集合中排名介于start和end之间的所有成员，包括start和end在内，并返回被移除成员的数量
    	  * @param prefix 缓存前缀
    	  * @param key 缓存key
    	  * @param start
    	  * @param end
    	  * @return 返回被移除的个数
    	  */
    	public Long removeRange(String prefix, String key, long start, long end) {
    		long number = jedisCluster.zremrangeByRank(prefix + KEY_SPLIT + key, start, end);
            log.info("ZSetOperationsImpl:removeRange cache key="+prefix + KEY_SPLIT + key+" start="+start+" end="+end+" 执行返回结果:"+number);
    		return number;
    	}
    
        /**
         * 从有序集合里面移除给定的成员，并返回被移除成员的数量
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @param value 缓存value
         * @return
         */
    	public Long remove(String prefix, String key, String... value) {
    		long number = jedisCluster.zrem(prefix + KEY_SPLIT + key, value);
            log.info("ZSetOperationsImpl:remove cache key="+prefix + KEY_SPLIT + key+" value="+value+" 执行返回结果:"+number);
    		return number;
    	}
    
        /**
         * 设置 key 的过期时间(如果已经存在过期时间则刷新过期时间)
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @param expireTime 过期时间
         * @return 设置成功返回 1
         */
    	public Long setOrRefurbishExpireTime(String prefix, String key, int expireTime) {
    		  long number = jedisCluster.expire(prefix + KEY_SPLIT + key, expireTime);
    	      log.info("ZSetOperationsImpl:setOrRefurbishExpireTime cache key="+prefix + KEY_SPLIT + key+" expireTime="+expireTime+" 执行返回结果:"+number);
    		return number;
    	}
    
        /**
         * 删除指定key的缓存
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @return 删除成功返回 1
         */
    	public Long delete(String prefix, String key) {
    		 long number = jedisCluster.del(prefix + KEY_SPLIT + key);
    		log.info("ZSetOperationsImpl:delete cache key="+prefix + KEY_SPLIT + key+" 执行返回结果:"+number);
    		return number;
    	}
    
        /**
         * 检查给定 key 是否存在 若 key 存在返回 true ，否则返回false 
         * @param prefix 缓存前缀
         * @param key 缓存key
         * @return 
         */
    	public Boolean exists(String prefix, String key) {
    		Boolean flag = jedisCluster.exists(prefix + KEY_SPLIT + key);
    		log.info("ZSetOperationsImpl:exists cache key="+prefix + KEY_SPLIT + key+" 执行返回结果:"+flag);
    		return flag;
    	}
    
    }

## 定义常量 ##

public class RedisCodes {
    	/**
    	 * prefix 缓存前缀（用于区分缓存，防止缓存键值重复） 在用户登录信息存入redis时使用
    	 */
    	private final String MERCHANT_PREFIX_LOGIN = "LOGIN_";
    	
    	/**
    	 * session过期时间（单位：秒）
    	 */
    	private final int SESSION_EXPIRE_TIME = 3600;
    }

##  ##

## 第二步、在过滤器里面写相应的逻辑代码 ##

package com.zhh.crm.filter;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Set;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import org.apache.commons.lang.StringUtils;
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.web.context.support.WebApplicationContextUtils;
    
    import com.zhh.redis.util.RedisJpaTemplateString;
    import com.zhh.redis.util.RedisJpaTemplateZSet;
    import com.zhh.redis.util.code.RedisCodes;
    import com.zhh.web.common.vo.PiccUser;
    
    /**
     * CRM SESSION超时过滤器，当SESSION超时之后，将由此过滤器返回一个异常编码：600.
     * @author zhaoheng
     */
    public class CopyOfCrmSessionFilter implements Filter {
    
    	private ApplicationContext wac;
    	private static Logger logger = Logger.getLogger(CopyOfCrmSessionFilter.class);
    	
    /*	
        // Filter中不能使用此方式来获取Bean，因为filter依赖于servlet,此时Servlet还未加载
        @Autowired
    	RedisJpaTemplateZSet opsForZSet;
    	@Autowired
    	RedisJpaTemplateString rTemplate;*/
    	
    	/**
    	 * prefix 缓存前缀（用于区分缓存，防止缓存键值重复） 在用户登录信息存入redis时使用
    	 */
    	private final String prefix = RedisCodes.MERCHANT_PREFIX_LOGIN;
    	
    	/**
    	 * session过期时间（单位：秒）
    	 */
    	private final int expireTime = RedisCodes.SESSION_EXPIRE_TIME;
    	
    	public void destroy() {}
    
    	public void doFilter(ServletRequest arg0, ServletResponse arg1,
    			FilterChain arg2) throws IOException, ServletException {
    
    		logger.info("开始执行方法：判断session是否超时或还未登陆系统，如果超时或还未登陆系统跳转到登陆页面");
    		HttpServletRequest request = (HttpServletRequest) arg0;
    		HttpServletResponse response = (HttpServletResponse) arg1;
    		
    		RedisJpaTemplateZSet  opsForZSet = wac.getBean(RedisJpaTemplateZSet.class);
    		RedisJpaTemplateString rTemplate = wac.getBean(RedisJpaTemplateString.class);
    		HttpSession session = request.getSession();
    				
    				String sessionId = session.getId();
    				String merchantLoginName = (String) session.getAttribute("merchantLoginName");
    
    				// 把相关信息存入redis
    				this.saveRedisCache(opsForZSet, rTemplate, sessionId, merchantLoginName);
    
    				// 判断String里面的session是否过期（是否存在）
    				boolean flag = rTemplate.exists(prefix,sessionId);
    				
    				if (flag) { // 未过期
    					// 刷新过期时间
    					rTemplate .setOrRefurbishExpireTime(prefix, sessionId, expireTime);
    					opsForZSet.setOrRefurbishExpireTime(prefix, merchantLoginName, expireTime);
    					arg2.doFilter(request, response);
    					
    				}else{ // 已过期
    					logger.info("session过期，清空redis ZSet中的相应信息");
    					opsForZSet.remove(prefix, merchantLoginName, sessionId);
    				}	
    	}
    	public void init(FilterConfig arg0) throws ServletException {
    		ServletContext context = arg0.getServletContext(); 
    		wac = WebApplicationContextUtils .getWebApplicationContext(context); 
    		
    	}
    
    	/**
    	 * 把用户登录信息（sessionID和userName）存入redis中
    	 * @param sessionId  session唯一标识
    	 * @param userName 登录用户名
    	 */
    	public void saveRedisCache(RedisJpaTemplateZSet opsForZSet,RedisJpaTemplateString rTemplate,String sessionId,String userName) {
    		logger.info("把用户登录信息（sessionID和userName）存入redis中开始     sessionId:"+sessionId+" userName:"+userName);
    				
    		long count = opsForZSet.size(prefix, userName);
    		logger.info("登录前查询正在登录中的个数："+count);
    		
    		// 如果大于等于 5个，先清除第一个再插入新登录的，否则直接插入新登录的数据信息
    		if (count >= 5) {
    			Set<String> set = opsForZSet.range(prefix, userName, 0, 0);
    			// 第一步：删除zset里面登录时间最早的信息
    			opsForZSet.removeRange(prefix, userName, 0, 0);
    			// 第二步：删除string里面登录时间最早的信息
    			for (String zsetVal : set) {
    				rTemplate.deleteWithPrefix(prefix, zsetVal);
    			}
    			// 第三步： sessionId 和 userName存放到redis的string里面（新登录的信息）
    			rTemplate.setWithExpireTime(prefix, sessionId, userName,expireTime);
    			// 第四步： 登录状态存储到redis的zSet（新登录的信息）
    			opsForZSet.add(prefix, userName, sessionId,System.currentTimeMillis());
    			// 第五步：设置zSet的过期时间
    			opsForZSet.setOrRefurbishExpireTime(prefix, userName, expireTime);
    			
    		} else {
    			rTemplate.setWithExpireTime(prefix, sessionId, userName,expireTime);
    			opsForZSet.add(prefix, userName, sessionId,System.currentTimeMillis());
    			opsForZSet.setOrRefurbishExpireTime(prefix, userName, expireTime);
    		}
    		logger.info("把用户登录信息（sessionID和userName）存入redis中结束。  ");
    	}
    }

#### 第三步、用户点击退出登录后执行的方法 ####

在清空session的地方调用以下方法用于清空redis里面的存储信息

/**
         * 用户退出登录删除redis中的session信息
         * @param sessionId session唯一标识
         * @param userName 用户登录名
         */
        public void deleteRedisCache(String sessionId,String userName) {
            log.info("用户退出登录，清空redis中相应的存储信息开始     sessionId:"+sessionId+" userName:"+userName);
    
            // 存储前缀，可以自己定义 MERCHANT_PREFIX_LOGIN = "LOGIN_"
            final String prefix = RedisCodes.MERCHANT_PREFIX_LOGIN;
            rTemplate.deleteWithPrefix(prefix,sessionId);// 删除string里面的信息
            opsForZSet.remove(prefix, userName, sessionId);//删除zset里面的信息
            log.info("用户退出登录，清空redis中相应的存储信息结束");
        }

因为我们设置了session过期时间，所以，就算用户不点击退出，到期后redis将自动清空过期信息。

注意：

**因为过滤器依赖与servlet容器，我们看一下web.xml标签的加载顺序：**context-param -> listener -> filter -> servlet ，也就是说，filter执行的时候servlet还未加载，所以filter里面不能获取IOC容器里面的Bean，所以文中就使用如下方法来获取上下文信息：

private ApplicationContext wac;
    
    // 通过Spring提供的工具类获取ApplicationContext对象
    public void init(FilterConfig arg0) throws ServletException {
    		ServletContext context = arg0.getServletContext(); 
    		wac = WebApplicationContextUtils .getWebApplicationContext(context); 
    		
    	}
    
    		
    public void doFilter(ServletRequest arg0, ServletResponse arg1,
    			FilterChain arg2) throws IOException, ServletException {
            RedisJpaTemplateZSet  opsForZSet = wac.getBean(RedisJpaTemplateZSet.class);
    		RedisJpaTemplateString rTemplate = wac.getBean(RedisJpaTemplateString.class);
    }

[70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/31a8dd9e7533452aadf49f4cb8ba5afb.png
[70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/d8dafc1bb21842cfb1b023676c03db2d.png