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

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数据库了;