spring-boot2.x 中使用redis

新項目升級到spring-boot2時，發現某些原有用法已過期，不推薦使用，因此今天主要是解決過期問題，同時演示配置多個redis的用法。以下：

過期方法：
JedisConnectionFactory 類下：
public void setHostName(String hostName)
public void setPassword(String password)
public void setPort(int port)
public void setTimeout(int timeout)
public void setPoolConfig(JedisPoolConfig poolConfig)
public void setDatabase(int index)

maven配置：

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

 

properties文件中配置redis信息：

# REDIS (RedisProperties)
# Redis數據庫索引（默認爲0）
token.redis.database=1
user.redis.database=2
# Redis服務器地址
redis.host=localhost
# Redis服務器鏈接端口
redis.port=6379
# Redis服務器鏈接密碼（默認爲空）
redis.password=MIGfMA0GCSqG4tQFEAX6p88w4xzzBvAep2DwN7LMYmaiuOlDRqDyLoRZHWn/YOlBTJLDedMlDcZzn2X2y3fB5hQy0LkUfZUhwoO2jwIDAQAB
# 鏈接池最大鏈接數（使用負值表示沒有限制）
redis.pool.max-active=8
# 鏈接池最大阻塞等待時間（使用負值表示沒有限制）
redis.pool.max-wait=-1
# 鏈接池中的最大空閒鏈接
redis.pool.max-idle=8
# 鏈接池中的最小空閒鏈接
redis.pool.min-idle=0
# 鏈接超時時間（毫秒）
redis.timeout=0
# redis過時時間600s，10分鐘

redis.expiration=600
#從鏈接池獲取鏈接時是否檢驗連接有效性
redis.testOnBorrow=true

 

基礎類RedisBaseRepository<T>：

private ValueOperations<String, T> valueOperations;
    private StringRedisTemplate stringRedisTemplate;
    private RedisTemplate<String, T> redisTemplate;

    public RedisBaseRepository(StringRedisTemplate stringRedisTemplate, RedisTemplate<String, T> redisTemplate) {
        this.valueOperations = redisTemplate.opsForValue();
        this.redisTemplate = redisTemplate;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 緩存字符串
     *
     * @param key
     * @param value
     */
    public void saveString(String key, String value, Integer cacheTime, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, value, cacheTime, timeUnit);
    }

    /**
     * 得到字符串
     *
     * @param key
     */
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 更新字符串
     *
     * @param key
     */
    public String updateString(String key, String value) {
        return stringRedisTemplate.opsForValue().getAndSet(key, value);
    }

    /**
     * 刪除字符串
     *
     * @param key
     */
    public void deleteString(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 保存對象
     */
    public void save(String key, T value, Integer cacheTime, TimeUnit timeUnit) {
        valueOperations.set(key, value, cacheTime, timeUnit);
    }

    /**
     * 更新對象
     *
     * @param value 實例
     */
    public void update(String key, T value, Integer cacheTime, TimeUnit timeUnit) {
        valueOperations.set(key, value, cacheTime, timeUnit);
    }

    /**
     * 根據id查詢對象
     *
     * @param key 實例uuid
     */
    public T findOne(String key) {
        T obj = valueOperations.get(key);
        return obj;
    }

    /**
     * 查詢全部對象
     */
    public List<T> findAll() {
        Set<String> strs = redisTemplate.keys("*");
        return valueOperations.multiGet(strs);
    }

    /**
     * 刪除對象
     *
     * @param key 實例uids
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 獲取token的有效期
     *
     * @param key
     */
    public long getExpireTime(String key) {
        long time = redisTemplate.getExpire(key);
        return time;
    }

    /**
     * 獲取token的有效期---秒、分，時，日……
     *
     * @param key
     * @return
     */
    public long getExpireTimeType(String key, TimeUnit timeUnit) {
        long time = redisTemplate.getExpire(key, timeUnit);
        return time;
    }

 

配置類@Configuration MultipleRedisConfiguration ：

@Value("${token.redis.database}")
    private int tokenIndex;

    @Value("${user.redis.database}")
    private int userIndex;

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

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

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

    @Value("${redis.pool.max-active}")
    private int maxTotal;

    @Value("${redis.pool.max-idle}")
    private int maxIdle;

    @Value("${redis.pool.min-idle}")
    private int minIdle;

    @Value("${redis.pool.max-wait}")
    private long maxWaitMillis;

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

    @Value("${redis.testOnBorrow}")
    private boolean testOnBorrow;

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

    @Bean
    public StringRedisTemplate stringRedisTemplate() {
        StringRedisTemplate temple = new StringRedisTemplate();
        temple.setConnectionFactory(redisConnectionFactory(tokenIndex));
        return temple;
    }

    @Bean
    public RedisTemplate<String, User> userRedisTemplate() {
        RedisTemplate<String, User> template = new RedisTemplate<String, User>();
        template.setConnectionFactory(redisConnectionFactory(userIndex));
        return template;
    }

    @Bean
    public StringRedisTemplate userStringRedisTemplate() {
        StringRedisTemplate temple = new StringRedisTemplate();
        temple.setConnectionFactory(redisConnectionFactory(userIndex));
        return temple;
    }

    @Component
    public class TokenRedisRepository extends RedisBaseRepository<Object> {
        @Autowired
        public TokenRedisRepository(StringRedisTemplate stringRedisTemplate, RedisTemplate<String, Object> redisTemplate) {
            super(stringRedisTemplate, redisTemplate);
        }
    }

    @Component
    public class UserRedisRepository extends RedisBaseRepository<User> {
        @Autowired
        public UserRedisRepository(StringRedisTemplate userStringRedisTemplate, RedisTemplate<String, User> userRedisTemplate) {
            super(userStringRedisTemplate, userRedisTemplate);
        }
    }

    /*
     * redisConnectionFactory
     * @description：構造RedisConnectionFactory
     * @author 李陽
     * @date 2018/12/27
     * @params [index]
     * @return org.springframework.data.redis.connection.RedisConnectionFactory
     */
    public RedisConnectionFactory redisConnectionFactory(int index) {
        RedisStandaloneConfiguration con = new RedisStandaloneConfiguration();
        con.setHostName(hostName);
        con.setPort(port);
        if (StringUtils.isNotEmpty(password)) {
            con.setPassword(RedisPassword.of(password));
        }
        if (index != 0) {
            con.setDatabase(index);
        }
        JedisClientConfiguration clientConfig =
                ((JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder()
                        .connectTimeout(Duration.ofMillis(timeout)).readTimeout(Duration.ofMillis(timeout)))
                        .poolConfig(poolCofig(maxIdle, maxTotal, maxWaitMillis, minIdle, testOnBorrow)).build();

        JedisConnectionFactory jedis = new JedisConnectionFactory(con, clientConfig);
        jedis.afterPropertiesSet();
        return jedis;
    }

    /*
     * poolCofig
     * @description：構造鏈接池配置
     * @author 李陽
     * @date 2018/12/27
     * @params [maxIdle, maxTotal, maxWaitMillis, minIdle, testOnBorrow]
     * @return redis.clients.jedis.JedisPoolConfig
     */
    private static JedisPoolConfig poolCofig(int maxIdle, int maxTotal, long maxWaitMillis, int minIdle, boolean testOnBorrow) {
        JedisPoolConfig poolCofig = new JedisPoolConfig();
        poolCofig.setMaxIdle(maxIdle);
        poolCofig.setMaxTotal(maxTotal);
        poolCofig.setMaxWaitMillis(maxWaitMillis);
        poolCofig.setMinIdle(minIdle);
        poolCofig.setTestOnBorrow(testOnBorrow);
        return poolCofig;
    }

 

 

使用方式：

@Autowired
    private MultipleRedisConfiguration.TokenRedisRepository tokenRedisRepository;

    @Autowired
    private MultipleRedisConfiguration.UserRedisRepository userRedisRepository;

    /*
     * getLatestIMToken 
     * @description：得到redis中存儲的token
     * @author 李陽
     * @date 2018/11/29
     * @params []
     * @return java.lang.String
     */
    public String getLatestIMToken() {
        //redis中token
        String token = tokenRedisRepository.getString("token");

        //token有效期小於等於一天或爲空時，更新token
        if (StringUtils.isBlank(token) || 1 >= tokenRedisRepository.getExpireTimeType("token", TimeUnit.DAYS)) {
            token = "Bearer 11111111111111111111";

            //更新或保存token 55天
            tokenRedisRepository.saveString("token", token, 55, TimeUnit.DAYS);
            return token;
        }
        return token;
    }

    /*
     * getUser
     * @description：得到redis中的user對象
     * @author 李陽
     * @date 2018/12/27
     * @params []
     * @return User
     */
    public User getUser() {
        //redis中user
        User user = userRedisRepository.findOne("user");

        //user有效期小於等於半小時或爲空時，更新user
        if (null == user || 30 >= userRedisRepository.getExpireTimeType("user", TimeUnit.MINUTES)) {
            user = new User("name", "mobile");

            //更新或保存user 3小時
            userRedisRepository.save("user", user, 3, TimeUnit.HOURS);
            return user;
        }
        return user;
    }