springboot2.0-启动cache和session同时存入redis(使用不同的数据库)

ゝ一纸荒年。 2022-05-16 03:42 22阅读 0赞

1.在springboot2.0中,通过pom.xml引入spring-boot-starter-cache,spring-boot-starter-data-redis,spring-session-data-redis;可以自动将cache和session数据存入redis数据库.  
2.在application.properties中配置如下内容:

#session使用redis进行储存
    spring.session.store-type=redis
    spring.session.redis.namespace=authSession
    spring.session.redis.flush-mode=immediate
    #cache使用redis储存
    spring.cache.type=redis
    spring.security.user.password=123
    spring.security.user.name=user

#redis内存数据库地址配置
    spring.redis.database=1
    spring.redis.host=localhost
    spring.redis.port=6379
    spring.redis.jedis.pool.max-active=8
    spring.redis.jedis.pool.max-idle=8
    spring.redis.jedis.pool.max-wait=-1
    spring.redis.timeout=5000

3.通过以后配置后，springboot的cache和session就自动存至redis中;经过以上3步的配置后,springboot非常简单和方便的就存至redis了, 但现在有一个问题，由于cache和session的内容均存入了数据库1中,如果想让cache和session分别存至不同的数据库?该如何处理呢?  
4.我是通过扩展session的自动配置来完成这个功能需求的,首先在application.properties中增加一个参数：  
        spring.session.redis.database=**5**  
5.创建一个扩展类MyRedisHttpSessionConfiguration继承RedisHttpSessionConfiguration

package com.lxht.emos.config;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    import org.springframework.context.ApplicationEventPublisher;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import org.springframework.session.data.redis.RedisFlushMode;
    import org.springframework.session.data.redis.RedisOperationsSessionRepository;
    import org.springframework.session.data.redis.config.ConfigureNotifyKeyspaceEventsAction;
    import org.springframework.session.data.redis.config.ConfigureRedisAction;
    import org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration;
    import org.springframework.util.StringUtils;
    
    /**
     * Created by fanyuli on 2018/5/28.
     */
    @Configuration
    public class MyRedisHttpSessionConfiguration extends RedisHttpSessionConfiguration{
        private RedisSerializer<Object> defaultRedisSerializer;
        private String redisNamespace = "spring:session";
        private ApplicationEventPublisher applicationEventPublisher;
        private Integer maxInactiveIntervalInSeconds = Integer.valueOf(1800);
        private RedisFlushMode redisFlushMode;
        private String cleanupCron;
        private ConfigureRedisAction configureRedisAction;
        private ClassLoader classLoader;
        @Autowired
        RedisProperties redisProperties;
        @Value("${spring.session.redis.database}")
        private int sessionRedisDatabase;
    
        public MyRedisHttpSessionConfiguration() {
            this.redisFlushMode = RedisFlushMode.ON_SAVE;
            this.cleanupCron = "0 * * * * *";
            this.configureRedisAction = new ConfigureNotifyKeyspaceEventsAction();
        }
    
        @Bean
        public RedisOperationsSessionRepository sessionRepository() {
            RedisTemplate<Object, Object> redisTemplate = this.createRedisTemplate();
            RedisOperationsSessionRepository sessionRepository = new RedisOperationsSessionRepository(redisTemplate);
            sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
    
            if(this.defaultRedisSerializer != null) {
                sessionRepository.setDefaultSerializer(this.defaultRedisSerializer);
            }
    
            sessionRepository.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds.intValue());
            if(StringUtils.hasText(this.redisNamespace)) {
                sessionRepository.setRedisKeyNamespace(this.redisNamespace);
            }
    
            sessionRepository.setRedisFlushMode(this.redisFlushMode);
            return sessionRepository;
        }
    
        public RedisTemplate<Object, Object> createRedisTemplate() {
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate();
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            if(this.defaultRedisSerializer != null) {
                redisTemplate.setDefaultSerializer(this.defaultRedisSerializer);
            }
    
            RedisConnectionFactory lettuceConnectionFactory = redisConnectionFactory();
            redisTemplate.setConnectionFactory(lettuceConnectionFactory);
            redisTemplate.setBeanClassLoader(this.classLoader);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
         
        public RedisConnectionFactory redisConnectionFactory() {

String host = redisProperties.getHost();
            int port = redisProperties.getPort();
            LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(host,port);
            lettuceConnectionFactory.setDatabase(sessionRedisDatabase);
            lettuceConnectionFactory.afterPropertiesSet();
            return lettuceConnectionFactory;
        }
    
        @Autowired
        public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
            this.applicationEventPublisher = applicationEventPublisher;
        }
    }

6.通过对RedisHttpSessionConfiguration进行扩展后,对应的session数据就存至database=5数据库了;