springBoot--集成springsession利用redis来实现session共享

悠悠 2022-05-29 07:43 337阅读 0赞

转：https://www.cnblogs.com/mengmeng89012/p/5519698.html

这次带来的是spring boot + redis 实现session共享的教程。

在spring boot的文档中，告诉我们添加@EnableRedisHttpSession来开启spring session支持，配置如下：

Java代码   ![收藏代码][icon_star.png]

1.  @Configuration  
2.  @EnableRedisHttpSession  
3.  public class RedisSessionConfig \{  
4.  \}

而@EnableRedisHttpSession这个注解是由spring-session-data-redis提供的，所以在pom.xml文件中添加：

Java代码   ![收藏代码][icon_star.png]

1.  <dependency>  
2.          <groupId>org.springframework.boot</groupId>  
3.          <artifactId>spring-boot-starter-redis</artifactId>  
4.  </dependency>  
5.  <dependency>  
6.          <groupId>org.springframework.session</groupId>  
7.          <artifactId>spring-session-data-redis</artifactId>  
8.  </dependency>

接下来，则需要在application.properties中配置redis服务器的位置了，在这里，我们就用本机：

Java代码   ![收藏代码][icon_star.png]

1.  spring.redis.host=localhost  
2.  spring.redis.port=6379

这样以来，最简单的spring boot + redis实现session共享就完成了，下面进行下测试。

首先我们开启两个tomcat服务，端口分别为8080和9090，在application.properties中进行设置[【下载地址】][Link 1]   ：

Java代码   ![收藏代码][icon_star.png]

1.  server.port=8080

接下来定义一个Controller：

Java代码   ![收藏代码][icon_star.png]

1.  @RestController  
2.  @RequestMapping(value = "/admin/v1")  
3.  public class QuickRun \{  
4.      @RequestMapping(value = "/first", method = RequestMethod.GET)  
5.      public Map<String, Object> firstResp (HttpServletRequest request)\{  
6.          Map<String, Object> map = new HashMap<>();  
7.          request.getSession().setAttribute("request Url", request.getRequestURL());  
8.          map.put("request Url", request.getRequestURL());  
9.          return map;  
10.     \}  
11.   
12.     @RequestMapping(value = "/sessions", method = RequestMethod.GET)  
13.     public Object sessions (HttpServletRequest request)\{  
14.         Map<String, Object> map = new HashMap<>();  
15.         map.put("sessionId", request.getSession().getId());  
16.         map.put("message", request.getSession().getAttribute("map"));  
17.         return map;  
18.     \}  
19. \}

启动之后进行访问测试，首先访问8080端口的tomcat，返回 [获取【下载地址】][Link 1]   ：

Java代码   ![收藏代码][icon_star.png]

1.  \{ "request Url":"http://localhost:8080/admin/v1/first"\}

接着，我们访问8080端口的sessions，返回：

Java代码   ![收藏代码][icon_star.png]

1.  \{ "sessionId":"efcc85c0-9ad2-49a6-a38f-9004403776b5","message":"http://localhost:8080/admin/v1/first"\}

最后，再访问9090端口的sessions，返回：

Java代码   ![收藏代码][icon_star.png]

1.  \{ "sessionId":"efcc85c0-9ad2-49a6-a38f-9004403776b5","message":"http://localhost:8080/admin/v1/first"\}

可见，8080与9090两个服务器返回结果一样，实现了session的共享

如果此时再访问9090端口的first的话，首先返回：

Java代码   ![收藏代码][icon_star.png]

1.  \{ "request Url":"http://localhost:9090/admin/v1/first"\}

而两个服务器的sessions都是返回：

Java代码   ![收藏代码][icon_star.png]

1.  \{ "sessionId":"efcc85c0-9ad2-49a6-a38f-9004403776b5","message":"http://localhost:9090/admin/v1/first"\}

通过spring boot + redis来实现session的共享非常简单，而且用处也极大，配合nginx进行负载均衡，便能实现分布式的应用了。

\-------------------------------------------------------

添加cache

RedisCacheConfig

![复制代码][copycode.gif]

package com.lzw.core.configuration;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * Created by ZhenWeiLai on 2017/6/11.
     */
    @Configuration
    @EnableCaching
    public class RedisCacheConfig  extends CachingConfigurerSupport {
        Logger logger = LoggerFactory.getLogger(RedisCacheConfig.class);
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.port}")
        private int port;
    
        @Value("${spring.redis.timeout}")
        private int timeout;
    
        @Value("${spring.redis.pool.max-idle}")
        private int maxIdle;
    
        @Value("${spring.redis.pool.max-wait}")
        private long maxWaitMillis;
    
        @Value("${spring.redis.password}")
        private String password;
    
    
        @Bean
        public JedisPool redisPoolFactory() {
            logger.info("JedisPool注入成功！！");
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
    
            JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
    
            return jedisPool;
        }
    
    
        @Bean
        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
            RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
            redisTemplate.setConnectionFactory(cf);
            return redisTemplate;
        }
    
        @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
    
            //默认超时时间,单位秒
            cacheManager.setDefaultExpiration(3000);
            //根据缓存名称设置超时时间,0为不超时
            Map<String,Long> expires = new ConcurrentHashMap<>();
            cacheManager.setExpires(expires);
    
            return cacheManager;
        }
    }

![复制代码][copycode.gif]

application.yml

![复制代码][copycode.gif]

spring:
      datasource:
    #    readSize: 1
    #    name: writeDataSource
        type: com.alibaba.druid.pool.DruidDataSource
        write:
          driver-class-name: com.mysql.jdbc.Driver
          url: jdbc:mysql://localhost:3306/cloud?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&useSSL=true
          username: root
          password: 123
          initialSize: 10
          maxActive: 100
          maxWait: 60000
          minIdle: 5
          timeBetweenEvictionRunsMillis: 60000
          minEvictableIdleTimeMillis: 300000
          validationQuery: SELECT 'x'
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          poolPreparedStatements: true
          maxPoolPreparedStatementPerConnectionSize: 20
    
      #redis配置
      redis:
        host: 192.168.1.11
        port: 6379
        # REDIS (RedisProperties)
        # Redis数据库索引（默认为0）
        database: 0
        # Redis服务器连接密码（默认为空）
        password:
        # 连接池最大连接数（使用负值表示没有限制）
        # 连接超时时间（毫秒）
        timeout: 0
        pool:
          max-active: 8
          # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-wait: -1
          # 连接池中的最大空闲连接
          max-idle: 8
          # 连接池中的最小空闲连接
          min-idle: 0

[icon_star.png]: /images/20220529/3b735a3b26ec4327995922d85b9de130.png
[Link 1]: http://item.taobao.com/item.htm?id=41222768202
[copycode.gif]: /images/20220529/7f7c70e14a3a4115a39403d34c92fc9a.png