Overview

Spring Data Redis（SDR）框架通过Spring出色的基础架构支持消除了与存储库交互所需的冗余任务和样板代码，从而简化了编写使用Redis键值存储库的Spring应用程序的过程 查看详细。

Maven 依赖

在 pom 文件中引入依赖：

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>

引入依赖后可以配置 redis ，spring boot中提供默认的配置类，只需要在 application.yml 中配置相应字段即可，如：

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 10000

自定义配置

但是，很多种情况下需要对其进行自定义修改，如：对application.yml 中密码加密，因此需要自定义配置类。在自定义配置类中，有可能工程中支持多种redis模式，例如：单节点，哨兵 或者 集群 等。这时候固然可以选择一个配置项来表示模式来动态的加载对应配置，但是这里使用了springboot中 @ConditionalOnProperty（类说明） 声明判断属性是否存在来动态加载配置类。

havingValue（默认为 “”） 属性可用于指定该属性应该具有的值。下表显示了条件何时与属性值和havingValue属性匹配:

|Property Value |havingValue=""| havingValue="true" |havingValue="false" |havingValue="foo" |-|-|-|-|-|-| |"true" |yes| yes| no| no |"false"| no |no |yes |no |"foo" |yes| no |no |yes

单节点 自定义

spring:
  redis:
    database: 0
    host: etas_redis
    port: 6379
    timeout: 10000
    password: 'xxxxxxxxx'
    publickey: 'xxxxx'
    passwordEncrypt: true
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 5
        min-idle: 0

@Configuration
@ConditionalOnProperty(prefix = "spring", name = "redis.host")
public class RedisConfigSingleNode {

    @Bean
    JedisConnectionFactory jedisConnectionFactory() throws Exception {
        JedisConnectionFactory jedisConFactory
                = new JedisConnectionFactory();
        jedisConFactory.setHostName(host);
        jedisConFactory.setPort(port);
        jedisConFactory.setDatabase(database);
        jedisConFactory.setTimeout(timeout);

        if (passwordEncrypt) {
            password = decrypt(publickey, password);
            logger.debug("解密密码：{}",password);
        }

        JedisPoolConfig jp = new JedisPoolConfig();
        jp.setMaxWaitMillis(max_wait);
        jp.setMaxIdle(max_idle);
        jp.setMinIdle(min_idle);
        jp.setMaxTotal(max_active);

        jedisConFactory.setPoolConfig(jp);

        return jedisConFactory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() throws Exception {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        return template;
    }

    private static final Logger logger = LoggerFactory.getLogger(RedisConfigSingleNode.class);

    @Value("${spring.redis.database}")
    private Integer database;

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private Integer port;

    @Value("${spring.redis.timeout}")
    private Integer timeout;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.publickey}")
    private String publickey;

    @Value("${spring.redis.passwordEncrypt}")
    private Boolean passwordEncrypt;

    @Value("${spring.redis.jedis.pool.max-active}")
    private Integer max_active;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private Long max_wait;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private Integer max_idle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private Integer min_idle;

    public RedisConfigSingleNode(){
        logger.info("RedisConfigSingleNode 加载");
    }
}

哨兵模式 自定义

spring:
  redis:
    database: 0
    timeout: 10000
    password: 'xxxxxxxxx'
    publickey: 'xxxxx'
    passwordEncrypt: true
    sentinel:
      master: mymaster
      nodes: 127.0.0.1:26379,127.0.0.1:26479,127.0.0.1:26579

@Configuration
@ConditionalOnProperty(prefix = "spring", name = "redis.sentinel.master")
public class RedisConfigSentinel {
    @Bean
    JedisConnectionFactory jedisConnectionFactory() throws Exception {


        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration().master(master);

        String[] sentinelNodes = nodes.split(",");
        for (String node : sentinelNodes) {
            String[] address = node.split(":");
            logger.info("config node: {},ip:{},port:{}", node, address[0], address[1]);
            sentinelConfig.sentinel(address[0], Integer.parseInt(address[1]));
        }

        if (passwordEncrypt) {
            password = decrypt(publickey, password);
            logger.debug("解密密码：{}", password);
        }
        JedisConnectionFactory jedisConFactory = new JedisConnectionFactory(sentinelConfig);
        jedisConFactory.setDatabase(database);
        jedisConFactory.setTimeout(timeout);
        jedisConFactory.setPassword(password);

        return jedisConFactory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() throws Exception {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        return template;
    }

    private static final Logger logger = LoggerFactory.getLogger(RedisConfigSentinel.class);

    @Value("${spring.redis.database}")
    private Integer database;

    @Value("${spring.redis.timeout}")
    private Integer timeout;

    @Value("${spring.redis.sentinel.master}")
    private String master;

    @Value("${spring.redis.sentinel.nodes}")
    private String nodes;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.publickey}")
    private String publickey;

    @Value("${spring.redis.passwordEncrypt}")
    private Boolean passwordEncrypt;

    public RedisConfigSentinel() {
        logger.info("RedisConfigSentinel 加载");
    }
}