Spring Session - 使用Spring Session从零到一构建分布式session

￡神魔★判官ぃ 2022-10-29 15:22 175阅读 0赞

### 文章目录 ###

*  快速入门 Spring Session + Redis
 *   *  官网指导
     *  Demo
     *  pom 依赖
     *  配置文件
     *  配置类RedisHttpSessionConfiguration
     *  Redis中的session数据解析
 *  附 其他相关类
 *   *  BaseController
     *  统一返回结果相关的Code
 *  Jedis的POM依赖及配置

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]

--------------------

# 快速入门 Spring Session + Redis #

## 官网指导 ##

[https://spring.io/projects/spring-session-data-redis\#samples][https_spring.io_projects_spring-session-data-redis_samples]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]

我们就用spring boot 来演示下吧

## Demo ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]

## pom 依赖 ##

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>boot2</artifactId>
            <groupId>com.artisan</groupId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>springsession</artifactId>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
    
            
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-redis</artifactId>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    
    </project>

--------------------

## 配置文件 ##

server:
      port: 8888
    
    spring:
      redis:
        host: 127.0.0.1
        port: 6379
        password: # Redis密码
        timeout: 5000ms
        lettuce:
          pool:
            max-active: 8
            max-wait: -1ms
            max-idle: 8
            min-idle: 0
      session:
        store-type: redis

*  max-active: 8 \# 连接池最大连接数，默认为 8 。使用负数表示没有限制。
 *  max-idle: 8 \# 默认连接数最大空闲的连接数，默认为 8 。使用负数表示没有限制。
 *  min-idle: 0 \# 默认连接池最小空闲的连接数，默认为 0 。允许设置 0 和 正数。
 *  max-wait: -1 \# 连接池最大阻塞等待时间，单位：毫秒。默认为 -1 ，表示不限制。
 *  session: store-type: redis 指定存储类型

--------------------

## 配置类RedisHttpSessionConfiguration ##

package com.artisan.config;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
    
    /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/2/16 14:12 * @mark: show me the code , change the world */
    @Configuration
    @EnableRedisHttpSession
    public class RedisHttpSessionConfiguration { 
    
    
        @Bean(name = "springSessionDefaultRedisSerializer")
        public RedisSerializer springSessionDefaultRedisSerializer() { 
            return RedisSerializer.json();
        }
    }

添加 @EnableRedisHttpSession 注解，开启自动化配置 Spring Session 使用 Redis 作为数据 。

我们来下 EnableRedisHttpSession 注解

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]

*  maxInactiveIntervalInSeconds 属性，Session 不活跃后的过期时间，默认为 1800 秒。
 *  redisNamespace 属性，在 Redis 的 key 的统一前缀，默认为 “spring:session” 。
 *  flushMode 属性，Redis 会话刷新模式(RedisFlushMode)。支持两种，默认为`RedisFlushMode.ON_SAVE`
    
    > RedisFlushMode.ON\_SAVE ，在请求执行完成时，统一写入 Redis 存储。  
    > RedisFlushMode.IMMEDIATE ，在每次修改 Session 时，立即写入 Redis 存储。
 *  cleanupCron 属性，清理 Redis Session 会话过期的任务执行 CRON 表达式，默认为 `"0 * * * * *"` 每分钟执行一次。虽然Redis 自带了 key 的过期，但是惰性删除策略，实际过期的 Session 还在 Redis 中占用内存。所以，Spring Session 通过定时任务，删除 Redis 中过期的 Session ，尽快释放 Redis 的内存。

默认情况下，采用 Java 自带的序列化方式 ，可读性很差。 所以在 `springSessionDefaultRedisSerializer()` 方法，定义了一个 Bean 名字为 `springSessionDefaultRedisSerializer`的 RedisSerializer Bean ，采用 JSON 序列化方式 。

--------------------

好了，截止到目前，核心的框架已经搭建起来了，我们来测试下

![在这里插入图片描述][20210216173940975.gif_pic_center]

package com.artisan.controller;
    
    import com.artisan.common.CommonResult;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/2/16 14:42 * @mark: show me the code , change the world */
    @RestController
    public class ArtisanController  extends BaseController { 
    
    
    
        @GetMapping("/mockSet")
        public CommonResult set(@RequestParam("key") String key, @RequestParam("value") String value) { 
            getHttpSession().setAttribute(key, value);
            return CommonResult.success("成功模拟登录");
        }
    
    
        @GetMapping("/mockGet") 
        public CommonResult get(@RequestParam("key") String key) { 
            return CommonResult.success( getHttpSession().getAttribute(key));
        }
    
    
    }

--------------------

启动测试类，走一波

package com.artisan;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringSeesionDemoApplication { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(SpringSeesionDemoApplication.class, args);
    	}
    
    }

访问 [http://localhost:8888/mockSet?key=artisan &value=avalue][http_localhost_8888_mockSet_key_artisan _value_avalue]

[http://localhost:8888/mockGet?key=artisan][http_localhost_8888_mockGet_key_artisan]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]

--------------------

## Redis中的session数据解析 ##

127.0.0.1:0>keys *
     1)  "spring:session:sessions:expires:e0dd90b9-9551-4e8a-9609-cde0758b88c2"
     2)  "spring:session:sessions:e0dd90b9-9551-4e8a-9609-cde0758b88c2"
     3)  "spring:session:expirations:1613470560000"

![在这里插入图片描述][20210216175123775.png]

每一个 Session 对应 Redis 二个 key-value 键值对

*  开头：以 spring:session 开头，可以通过 @EnableRedisHttpSession 注解的 redisNamespace 属性配置。
 *  结尾：以对应 Session 的 sessionid 结尾。
 *  中间：中间分别是 `"session"、"expirations"、sessions:expires`

一般情况下，只需要关注中间为 `session` 的 key-value 键值对即可，它负责真正存储 Session 数据

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 5]

127.0.0.1:0>hgetall spring:session:sessions:ab7d40d8-cd3d-49d7-8b3a-d1ae71d40935
     1)  "lastAccessedTime"  # 最后访问时间
     2)  "1613469344975"
     3)  "maxInactiveInterval" # Session 允许最大不活跃时长，单位：秒。
     4)  "1800"
     5)  "creationTime"   # 创建时间
     6)  "1613469342207"
     7)  "sessionAttr:artisan" # 设置的属性值
     8)  ""avalue""
    127.0.0.1:0>

对于中间为 `sessions:expires`和 `expirations`的两个来说，主要为了实现主动删除 Redis 过期的 Session 会话，解决 Redis 惰性删除的问题。

`spring:session:expirations:{时间戳}`，是为了获得每分钟需要过期的 sessionid 集合，即 \{时间戳\} 是每分钟的时间戳

--------------------

# 附 其他相关类 #

## BaseController ##

package com.artisan.controller;
    
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    
    public class BaseController  { 
    
        public HttpServletRequest getRequest(){ 
            return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        }
    
        public HttpServletResponse getResponse(){ 
            return ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getResponse();
        }
    
        public HttpSession getHttpSession(){ 
            return getRequest().getSession();
        }
    
    }

--------------------

## 统一返回结果相关的Code ##

【IErrorCode 】

package com.artisan.common;
    
    
    public interface IErrorCode { 
        long getCode();
    
        String getMessage();
    }

--------------------

【ResultCode 】

package com.artisan.common;
    
    
    public enum ResultCode implements IErrorCode { 
        SUCCESS(200, "操作成功"),
        FAILED(500, "操作失败"),
        VALIDATE_FAILED(404, "参数检验失败"),
        UNAUTHORIZED(401, "暂未登录或token已经过期"),
        FORBIDDEN(403, "没有相关权限");
    
        private long code;
        private String message;
    
        private ResultCode(long code, String message) { 
            this.code = code;
            this.message = message;
        }
    
        public long getCode() { 
            return code;
        }
    
        public String getMessage() { 
            return message;
        }
    }

--------------------

【CommonResult】

package com.artisan.common;
    
    
    public class CommonResult<T> { 
        private long code;
        private String message;
        private T data;
    
        protected CommonResult() { 
        }
    
        protected CommonResult(long code, String message, T data) { 
            this.code = code;
            this.message = message;
            this.data = data;
        }
    
        /** * 成功返回结果 * * @param data 获取的数据 */
        public static <T> CommonResult<T> success(T data) { 
            return new CommonResult<T>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), data);
        }
    
        /** * 成功返回结果 * * @param data 获取的数据 * @param message 提示信息 */
        public static <T> CommonResult<T> success(T data, String message) { 
            return new CommonResult<T>(ResultCode.SUCCESS.getCode(), message, data);
        }
    
        /** * 失败返回结果 * @param errorCode 错误码 */
        public static <T> CommonResult<T> failed(IErrorCode errorCode) { 
            return new CommonResult<T>(errorCode.getCode(), errorCode.getMessage(), null);
        }
    
        /** * 失败返回结果 * @param message 提示信息 */
        public static <T> CommonResult<T> failed(String message) { 
            return new CommonResult<T>(ResultCode.FAILED.getCode(), message, null);
        }
    
        /** * 失败返回结果 */
        public static <T> CommonResult<T> failed() { 
            return failed(ResultCode.FAILED);
        }
    
        /** * 参数验证失败返回结果 */
        public static <T> CommonResult<T> validateFailed() { 
            return failed(ResultCode.VALIDATE_FAILED);
        }
    
        /** * 参数验证失败返回结果 * @param message 提示信息 */
        public static <T> CommonResult<T> validateFailed(String message) { 
            return new CommonResult<T>(ResultCode.VALIDATE_FAILED.getCode(), message, null);
        }
    
        /** * 未登录返回结果 */
        public static <T> CommonResult<T> unauthorized(T data) { 
            return new CommonResult<T>(ResultCode.UNAUTHORIZED.getCode(), ResultCode.UNAUTHORIZED.getMessage(), data);
        }
    
        /** * 未授权返回结果 */
        public static <T> CommonResult<T> forbidden(T data) { 
            return new CommonResult<T>(ResultCode.FORBIDDEN.getCode(), ResultCode.FORBIDDEN.getMessage(), data);
        }
    
        /** * 请求异常返回结果#add by yangguo */
        public static <T> CommonResult<T> badResponse(IErrorCode errorCode) { 
            return new CommonResult<T>(errorCode.getCode(), errorCode.getMessage(), null);
        }
    
        public long getCode() { 
            return code;
        }
    
        public void setCode(long code) { 
            this.code = code;
        }
    
        public String getMessage() { 
            return message;
        }
    
        public void setMessage(String message) { 
            this.message = message;
        }
    
        public T getData() { 
            return data;
        }
    
        public void setData(T data) { 
            this.data = data;
        }
    }

# Jedis的POM依赖及配置 #

Spring Boot 2 以上默认使用lettuce作为redis的客户端，如果想要用jedis ,我这里也给大家准备了一份，请参考

<dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
           
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-redis</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <exclusions>
                    
                    <exclusion>
                        <groupId>io.lettuce</groupId>
                        <artifactId>lettuce-core</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>
    
        </dependencies>

spring:
      # 对应 RedisProperties 类
      redis:
        host: 127.0.0.1
        port: 6379
        password: # Redis 服务器密码，默认为空。生产中，一定要设置 Redis 密码！
        database: 0 # Redis 数据库号，默认为 0 。
        timeout: 0 # Redis 连接超时时间，单位：毫秒。
        # 对应 RedisProperties.Jedis 内部类
        jedis:
          pool:
            max-active: 8 # 连接池最大连接数，默认为 8 。使用负数表示没有限制。
            max-idle: 8 # 默认连接数最大空闲的连接数，默认为 8 。使用负数表示没有限制。
            min-idle: 0 # 默认连接池最小空闲的连接数，默认为 0 。允许设置 0 和 正数。
            max-wait: -1 # 连接池最大阻塞等待时间，单位：毫秒。默认为 -1 ，表示不限制。

![在这里插入图片描述][20210216180521542.gif_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]: /images/20221024/43424c10e051459ba8ab0c34b5554ea6.png
[https_spring.io_projects_spring-session-data-redis_samples]: https://spring.io/projects/spring-session-data-redis#samples
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/2cd41e3899004222a1bcd3a0cb23c6d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]: /images/20221024/a1f9ba9393b3410ca4d1ed84ad2bef6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]: /images/20221024/bc54e810d1ab456da53d675af2ae7569.png
[20210216173940975.gif_pic_center]: /images/20221024/c95aa7c6d1fe45feb7c96a3d81a959d1.png
[http_localhost_8888_mockSet_key_artisan _value_avalue]: http://localhost:8888/mockSet?key=artisan%20&value=avalue
[http_localhost_8888_mockGet_key_artisan]: http://localhost:8888/mockGet?key=artisan
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]: /images/20221024/d7a179faff804d0a917f86a972ebeec0.png
[20210216175123775.png]: /images/20221024/716164e966e042deabc5ca4538df9f0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 5]: /images/20221024/39154b1d46904256a1251c81461d7fa0.png
[20210216180521542.gif_pic_center]: /images/20221024/e31fd607b66945cf8e5b46bf14560243.png