<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">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lee</groupId>

    <artifactId>redis</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>redis</name>

    <url>http://maven.apache.org</url>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.9.RELEASE</version>

    </parent>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <!-- 日志过滤器 -->

        <dependency>

            <groupId>org.codehaus.janino</groupId>

            <artifactId>janino</artifactId>

        </dependency>

    </dependencies>

</project>

redis.masterName=mymaster

redis.sentinels=192.168.11.202:26379,192.168.11.202:26380,192.168.11.202:26381

redis.timeout=10000

#连接master需要用到的密码，如果redis数据节点开启了连接认证

redis.password=myredis

# 连接池

# 连接池最大连接数（使用负值表示没有限制）

redis.pool.maxActive=150

# 连接池中的最大空闲连接

redis.pool.maxIdle=10

# 连接池中的最小空闲连接

redis.pool.minIdle=1

# 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1

redis.pool.maxWaitMillis=3000

# 每次释放连接的最大数目

redis.pool.numTestsPerEvictionRun=50

# 释放连接的扫描间隔（毫秒）

redis.pool.timeBetweenEvictionRunsMillis=3000

# 连接最小空闲时间（毫秒）

redis.pool.minEvictableIdleTimeMillis=1800000

# 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放（毫秒）

redis.pool.softMinEvictableIdleTimeMillis=10000

# 在获取连接的时候检查有效性, 默认false

redis.pool.testOnBorrow=true

# 在空闲时检查有效性, 默认false

redis.pool.testWhileIdle=true

# 在归还给pool时，是否提前进行validate操作

redis.pool.testOnReturn=true

# 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true

redis.pool.blockWhenExhausted=true

package com.lee.redis.config;

import java.util.Arrays;

import java.util.HashSet;

import java.util.Set;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.PropertySource;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.JedisSentinelPool;

@Configuration

@PropertySource("redis/redis-sentinel.properties")

public class RedisConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisConfig.class);

    @Value("${redis.masterName}")

    private String masterName;

    @Value("${redis.sentinels}")

    private String sentinels;

    @Value("${redis.timeout}")

    private int timeout;

    @Value("${redis.password}")

    private String password;

    @Value("${redis.pool.maxActive}")

    private int maxTotal;

    @Value("${redis.pool.maxIdle}")

    private int maxIdle;

    @Value("${redis.pool.minIdle}")

    private int minIdle;

    @Value("${redis.pool.maxWaitMillis}")

    private long maxWaitMillis;

    @Value("${redis.pool.numTestsPerEvictionRun}")

    private int numTestsPerEvictionRun;

    @Value("${redis.pool.timeBetweenEvictionRunsMillis}")

    private long timeBetweenEvictionRunsMillis;

    @Value("${redis.pool.minEvictableIdleTimeMillis}")

    private long minEvictableIdleTimeMillis;

    @Value("${redis.pool.softMinEvictableIdleTimeMillis}")

    private long softMinEvictableIdleTimeMillis;

    @Value("${redis.pool.testOnBorrow}")

    private boolean testOnBorrow;

    @Value("${redis.pool.testWhileIdle}")

    private boolean testWhileIdle;

    @Value("${redis.pool.testOnReturn}")

    private boolean testOnReturn;

    @Value("${redis.pool.blockWhenExhausted}")

    private boolean blockWhenExhausted;

    @SuppressWarnings({ "unchecked", "rawtypes" })

    @Bean

    public JedisSentinelPool jedisSentinelPool(JedisPoolConfig poolConfig) {

        LOGGER.info("sentinel set : {}", sentinels);

        Set sentinelSet = new HashSet(Arrays.asList(sentinels.split(",")));

        JedisSentinelPool jedisPool = new JedisSentinelPool(masterName, sentinelSet, poolConfig, timeout, password);

        return jedisPool;

    }

    @Bean

    public JedisPoolConfig jedisPoolConfig() {

        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        jedisPoolConfig.setMaxTotal(maxTotal);

        jedisPoolConfig.setMaxIdle(maxIdle);

        jedisPoolConfig.setMinIdle(minIdle);

        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

        jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);

        jedisPoolConfig

                .setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        jedisPoolConfig

                .setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

        jedisPoolConfig

                .setSoftMinEvictableIdleTimeMillis(softMinEvictableIdleTimeMillis);

        jedisPoolConfig.setTestOnBorrow(testOnBorrow);

        jedisPoolConfig.setTestWhileIdle(testWhileIdle);

        jedisPoolConfig.setTestOnReturn(testOnReturn);

        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);

        return jedisPoolConfig;

    }

}

package com.lee.redis;

import org.springframework.boot.Banner;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

@Configuration

@EnableAutoConfiguration

@ComponentScan

public class Application {

    public static void main(String[] args) {

        SpringApplication app = new SpringApplication(Application.class);

        app.setBannerMode(Banner.Mode.OFF);            // 是否打印banner

        // app.setApplicationContextClass();        // 指定spring应用上下文启动类

        app.setWebEnvironment(false);

        app.run(args);

    }

}

package com.lee.redis;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisSentinelPool;

@RunWith(SpringRunner.class)

@SpringBootTest(classes = Application.class)

public class RedisTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisTest.class);

    @Autowired

    private JedisSentinelPool sentinelPool;

    @Test

    public void getNameTest() {

        Jedis jedis = null;

        try {

            jedis = sentinelPool.getResource();

            String name = jedis.get("name");

            System.out.println("name is " + name);

        } catch(Exception e) {

            LOGGER.error(e.getMessage(), e);

        } finally {

            if (jedis != null) {

                jedis.close();

            }

        }

    }

}