redis实现session共享，使用JedisAPI

偏执的太偏执、 2022-05-21 09:49 161阅读 0赞

**背景**

我所在的公司需要搭建集群环境，而我正好被选上负责搭建redis和解决session共享的问题，我在这里做一些小小的笔记，写的内容可能有写不全面，请大家多多包涵！以下就是我工作中使用的共享session方案！

**简述**

redis环境搭建：[https://blog.csdn.net/qq\_31803503/article/details/79246210][https_blog.csdn.net_qq_31803503_article_details_79246210]

jedis配置：

redis.properties

#ip地址  
    redis.hostName=192.168.1.222
    #端口号  
    redis.port=6379
    #如果有密码  
    redis.password=root
    #客户端超时时间单位是毫秒 默认是2000  
    redis.timeout=10000
    #最大空闲数  
    redis.maxIdle=300
    #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal  
    #redis.maxActive=600  
    #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性  
    redis.maxTotal=1000
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。  
    redis.maxWaitMillis=1000
    #连接的最小空闲时间 默认1800000毫秒(30分钟)  
    redis.minEvictableIdleTimeMillis=300000
    #每次释放连接的最大数目,默认3  
    redis.numTestsPerEvictionRun=1024
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1  
    redis.timeBetweenEvictionRunsMillis=30000
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个  
    redis.testOnBorrow=true
    #在空闲时检查有效性, 默认false  
    redis.testWhileIdle=true

applicationContext-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context 
    	http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    
    	
    	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    		
    		<property name="maxIdle" value="${redis.maxIdle}" />
    		
    		<property name="maxTotal" value="${redis.maxTotal}" />
    		
    		<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
    		
    		<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
    		
    		<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
    		
    		<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
    		
    		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
    		
    		<property name="testWhileIdle" value="${redis.testWhileIdle}" />
    	</bean>
    	
    	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
    		<property name="poolConfig" ref="jedisPoolConfig"></property>
    		
    		<property name="hostName" value="${redis.hostName}"></property>
    		
    		<property name="port" value="${redis.port}"></property>
    		
    		<property name="password" value="${redis.password}" />
    		
    		<property name="timeout" value="${redis.timeout}"></property>
    	</bean>
    	
    	<bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
    	
    	<bean id="genericJackson2JsonRedisSerializer" class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
    	
    	<bean id="jsonRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    		<property name="connectionFactory" ref="jedisConnectionFactory" />
    		
    		<property name="keySerializer" ref="genericJackson2JsonRedisSerializer" />
    		<property name="valueSerializer" ref="genericJackson2JsonRedisSerializer" />
    		<property name="hashKeySerializer" ref="genericJackson2JsonRedisSerializer" />
    		<property name="hashValueSerializer" ref="genericJackson2JsonRedisSerializer" />
    		<property name="enableTransactionSupport" value="true"></property>
    	</bean>
    	<bean id="jdkRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    		<property name="connectionFactory" ref="jedisConnectionFactory" />
    		<property name="keySerializer" ref="jdkSerializationRedisSerializer" />
    		<property name="valueSerializer" ref="jdkSerializationRedisSerializer" />
    		<property name="hashKeySerializer" ref="jdkSerializationRedisSerializer" />
    		<property name="hashValueSerializer" ref="jdkSerializationRedisSerializer" />
    		<property name="enableTransactionSupport" value="true"></property>
    	</bean>
    	
    	<bean id="jedisUtil" class="cn.lin.common.utils.JedisUtil">
    		<property name="jsonRedisTemplate" ref="jsonRedisTemplate" />
    		<property name="jdkRedisTemplate" ref="jdkRedisTemplate" />
    	</bean>
    </beans>

JedisUtil.java

/**
     * Jedis 工具类
     * Jedis用来操作Redis的Java API
     * 通过spring注入获取对象
     * @author JC.LIN
     * @date 2018年6月5日
     */
    public class JedisUtil implements Serializable {
    	private static final long serialVersionUID = 3528032973746326900L;
    	private static final Logger LOGGER = LoggerFactory.getLogger(JedisUtil.class);
    	public static RedisTemplate<String, Object> jsonRedisTemplate;//json序列化
    	public static RedisTemplate<String, Object> jdkRedisTemplate;//jdk序列化
    	private JedisUtil(){}
    	@Autowired(required = true)
    	public static void setJsonRedisTemplate(RedisTemplate<String, Object> jsonRedisTemplate) {
    		JedisUtil.jsonRedisTemplate = jsonRedisTemplate;
    	}
    	@Autowired(required = true)
    	public static void setJdkRedisTemplate(RedisTemplate<String, Object> jdkRedisTemplate) {
    		JedisUtil.jdkRedisTemplate = jdkRedisTemplate;
    	}
    	//========================jdk序列化=============================
    	public static ValueOperations<String, Object> getJdkOpsForValue(){
    		return jdkRedisTemplate.opsForValue();
    	}
    	public static ZSetOperations<String, Object> getJdkOpsForZSet(){
    		return jdkRedisTemplate.opsForZSet();
    	}
    	public static HashOperations<String, Object, Object> getJdkOpsForHash(){
    		return jdkRedisTemplate.opsForHash();
    	}
    	public static ListOperations<String, Object> getJdkOpsForList(){
    		return jdkRedisTemplate.opsForList();
    	}
    	public static SetOperations<String, Object> getJdkOpsForSet(){
    		return jdkRedisTemplate.opsForSet();
    	}
    	//========================json序列化=============================
    	public static ValueOperations<String, Object> getJsonOpsForValue(){
    		return jsonRedisTemplate.opsForValue();
    	}
    	public static ZSetOperations<String, Object> getJsonOpsForZSet(){
    		return jsonRedisTemplate.opsForZSet();
    	}
    	public static HashOperations<String, Object, Object> getJsonOpsForHash(){
    		return jsonRedisTemplate.opsForHash();
    	}
    	public static ListOperations<String, Object> getJsonOpsForList(){
    		return jsonRedisTemplate.opsForList();
    	}
    	public static SetOperations<String, Object> getJsonOpsForSet(){
    		return jsonRedisTemplate.opsForSet();
    	}
    	
    	//=============================common============================ 
    	/** 
         * 指定缓存失效时间 
         * @param key 键 
         * @param time 时间(秒) 
         */  
        public static boolean expire(String key, long time){  
            try {  
                if(time>0){  
                	jsonRedisTemplate.expire(key, time, TimeUnit.SECONDS);  
                }  
                return true;  
            } catch (Exception e) {  
            	LOGGER.error("指定缓存失效时间错误", e);
            }  
            return false;
        }
        /** 
         * 根据key 获取过期时间 
         * @param key 键 不能为null 
         * @return 时间(秒) 返回0代表为永久有效 
         */  
        public static long getExpire(String key){  
            try {
    			return jsonRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    		} catch (Exception e) {
    			LOGGER.error("根据key 获取过期时间错误", e);
    		}
            return 0l;
        }
        /** 
         * 判断key是否存在 
         * @param key 键 
         * @return true 存在 false不存在 
         */  
        public static boolean hasKey(String key){  
            try {  
                return jsonRedisTemplate.hasKey(key);  
            } catch (Exception e) {
            	LOGGER.error("判断key是否存在错误", e);
            }  
            return false;
        }  
        /** 
         * 删除缓存 
         * @param key 可以传一个值 或多个 
         */  
        @SuppressWarnings("unchecked")  
        public static void del(String... key){  
            try {
    			if(key != null && key.length > 0){  
    			    if(key.length == 1){  
    			    	jsonRedisTemplate.delete(key[0]);  
    			    }else{  
    			    	jsonRedisTemplate.delete(CollectionUtils.arrayToList(key));  
    			    }  
    			}
    		} catch (Exception e) {
    			LOGGER.error("删除缓存错误", e);
    		}  
        }
        /** 
         * 普通缓存获取
         * @param key 键 
         * @return 值 
         */  
        public static Object get(String key){
        	try {
    			if(UtilTool.isNotEmpty(key)){
    				return jsonRedisTemplate.opsForValue().get(key);
    			}
    		} catch (Exception e) {
    			LOGGER.error("普通缓存获取错误", e);
    		}
        	return null; 
        }
        /** 
         * 普通缓存放入 
         * @param key 键 
         * @param value 值 
         * @return true成功 false失败 
         */  
        public static boolean set(String key,Object value) {  
             try {  
            	 jsonRedisTemplate.opsForValue().set(key, value);  
            	 return true;  
            } catch (Exception e) {  
            	LOGGER.error("存入redis缓存错误", e);
            }  
            return false;
              
        }
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public static boolean set(String key,Object value, long time){  
            try {
                if(time>0){  
                	jsonRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
                }else{  
                    set(key, value);  
                }  
                return true;  
            } catch (Exception e) {  
            	LOGGER.error("普通缓存放入并设置时间错误", e);
            }  
    		return false;
        }  
        
    }

实现共享session方式我总结出有三种：

第一种：使用spring集成的jar包：spring-session.jar

配置详情：[https://blog.csdn.net/qq\_31803503/article/details/79246329][https_blog.csdn.net_qq_31803503_article_details_79246329]

第二种：使用Cookie

我们在登录成功时生成一个sessionID，将sessionID作为key，用户作为value(用户需要进行序列化才能存到redis中)。

序列化：

/**
    	 * 序列化对象
    	 * @param obj
    	 */
    	public static String serialize(Object obj){
    		ByteArrayOutputStream byteArrayOutputStream = null;
    		ObjectOutputStream objectOutputStream = null;
    		try {
    			byteArrayOutputStream = new ByteArrayOutputStream();
    			objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
    			objectOutputStream.writeObject(obj);
    			return byteArrayOutputStream.toString("ISO-8859-1");
    		} catch (Exception e) {
    			LOGGER.error("序列化对象出错", e);
    		} finally {
    			if(objectOutputStream != null){
    				try {
    					objectOutputStream.close();
    				} catch (IOException e) {}
    			}
    			if(byteArrayOutputStream != null){
    				try {
    					byteArrayOutputStream.close();
    				} catch (IOException e) {}
    			}
    		}
    		return null;
    	}
    	/**
    	 * 反序列化对象
    	 * @param str
    	 */
    	public static Object deserialize(String str){
    		ByteArrayInputStream byteArrayInputStream = null;
    		ObjectInputStream objectInputStream = null;
    		try {
    			byteArrayInputStream = new ByteArrayInputStream(str.getBytes("ISO-8859-1"));
    			objectInputStream = new ObjectInputStream(byteArrayInputStream);
    			return objectInputStream.readObject();
    		} catch (Exception e) {
    			LOGGER.error("反序列化对象出错", e);
    		} finally {
    			if(objectInputStream != null){
    				try {
    					objectInputStream.close();
    				} catch (IOException e) {}
    			}
    			if(byteArrayInputStream != null){
    				try {
    					byteArrayInputStream.close();
    				} catch (IOException e) {}
    			}
    		}
    		return null;
    	}

LoginController:

session.setAttribute(Constants.LOGIN_USER, dbUser);//用户登录成功
    String sessionId = session.getId();
    JedisUtil.getJdkOpsForValue().set(sessionId, dbUser, Constants.USER_REDIS_TIMEOUT, TimeUnit.SECONDS);//设置用户对象到redis，过期时间为30分钟
    Cookie sessionIdCookie = new Cookie(Constants.COOKIE_SESSIONID, sessionId);//将sessionID存到cookie中
    sessionIdCookie.setPath("/");
    sessionIdCookie.setDomain(request.getServerName());
    sessionIdCookie.setMaxAge(Constants.COOKIE_AGE);//cookie生命时间（一般30min）
    response.addCookie(sessionIdCookie);

拦截器：

HttpSession session = request.getSession();
    User user = (User) session.getAttribute(Constants.LOGIN_USER);
    String sessionId = "";
    if(user == null){
        //取出Cookie中的sessionId，来去redis中取出用户
        Cookie[] cookies = request.getCookies();
        if (UtilTool.isNotEmpty(cookies)) {
        for (Cookie cookie : cookies) {
    	if(Constants.COOKIE_SESSIONID.equals(cookie.getName()) && UtilTool.isNotEmpty(cookie.getValue())){
    	    sessionId = cookie.getValue();
    	}
        }
    }
    User redisUser = (User) JedisUtil.getJdkOpsForValue().get(sessionId);
    if(redisUser == null){
    	response.sendRedirect(request.getContextPath() + "/common/login/index.action");
    	return false;
    }
    //取出用户后，放入session中
    session.setAttribute(Constants.LOGIN_USER, redisUser);
    }
    JedisUtil.expire(Constants.LOGIN_USER, Constants.USER_REDIS_TIMEOUT);//每一次都要设置超时时间

这种方法可以实现，但出现几个问题：

1.放入session中的属性未必只有一个，也有可能有多个，如何区别他们的key

2.每一次都要把key放入cookie中，一来麻烦，二来不安全，三来性能差。

3.如何在不修改业务代码的情况下，又能把属性准确的放入redis中呢？

出现以上几个问题后，我想redis的某些数据结构是可以把我们这个结构给保存起来的，结果发现redis中有一个叫hash表的数据结构，相当于java中的Map数据结构。

![70][]

然后，我们添加一个session监听器，监听session属性的新增、修改、删除操作。

public class SessionListener implements HttpSessionListener,HttpSessionAttributeListener {
    	@Override
    	public void sessionCreated(HttpSessionEvent event) {
    	}
    	//session销毁
    	@Override
    	public void sessionDestroyed(HttpSessionEvent event) {
    		System.out.println("sessionDestroyed");
    		HttpSession session = event.getSession();
    		User user = (User) session.getAttribute(Constants.LOGIN_USER);
    		if(user != null){
    			LOGIN_USER_MAP.remove(user.getEid());
    		}
    	}
    	@Override
    	public void attributeAdded(HttpSessionBindingEvent event) {	
    	}
    	@Override
    	public void attributeRemoved(HttpSessionBindingEvent event) {
    	}
    	@Override
    	public void attributeReplaced(HttpSessionBindingEvent event) {
    		
    	}
    }

直接在监听器中用jedis操作redis

jedis操作hash的API方法是和redis hash命令是同名的，详情：[http://www.runoob.com/redis/redis-hashes.html][http_www.runoob.com_redis_redis-hashes.html]

感兴趣的朋友可以关注微信公众号（会定时推送新的知识）：

![70 1][]

[https_blog.csdn.net_qq_31803503_article_details_79246210]: https://blog.csdn.net/qq_31803503/article/details/79246210
[https_blog.csdn.net_qq_31803503_article_details_79246329]: https://blog.csdn.net/qq_31803503/article/details/79246329
[70]: /images/20220521/cb82a81ef7b244239b2784b748a0058d.png
[http_www.runoob.com_redis_redis-hashes.html]: http://www.runoob.com/redis/redis-hashes.html
[70 1]: /images/20220521/9aa7af2bb22648f2b4891bcf6a1348e7.png