springboot--redis配置

基于spring.version:4.x;
4.2.4.RELEASE
不同spring版本对应的redis版本也不一样，配置类也会不同。

添加pom：

<dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.7.2.RELEASE</version>
</dependency>
<dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.8.1</version>
</dependency>

redis参数配置：RedisConfig.class

package com.chenglulu.api.config;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Data
public class RedisConfig {

    @Value("127.0.0.1")
    private String redisHost;

    @Value("3306")
    private Integer redisPort;

    @Value("123456")
    private String redisPassword;
}

redis配置类：RedisConfiguration.class

package com.chenglulu.api;

import com.chenglulu.api.config.RedisConfig;
import com.chenglulu.util.CryptorUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class RedisConfiguration {

    @Autowired
    private RedisConfig redisConfig;

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

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        /*最大空闲数*/
        config.setMaxIdle(50);
        /*连接池的最大数据库连接数*/
        config.setMaxTotal(30000);
        /*最大建立连接等待时间*/
        config.setMaxWaitMillis(100);
        /*是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个*/
        config.setTestOnBorrow(true);
        /*在空闲时检查有效性, 默认false*/
        config.setTestWhileIdle(false);

        return config;
    }

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        String password = redisConfig.getRedisPassword();
       
        JedisConnectionFactory factory = new JedisConnectionFactory(jedisPoolConfig());

        factory.setHostName(redisConfig.getRedisHost());
        factory.setPort(redisConfig.getRedisPort());
        factory.setPassword(password);
        factory.setTimeout(100);
        factory.setDatabase(1);

        return factory;
    }

    @Bean(name = "redisTemplate")
    public StringRedisTemplate initRedisTemplate() {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();

        stringRedisTemplate.setConnectionFactory(jedisConnectionFactory());
        // 自定义Redis序列化器
//        RedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
//        RedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 设置序列化器
//        stringRedisTemplate.setKeySerializer(stringRedisSerializer);
//        stringRedisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
//        stringRedisTemplate.setHashKeySerializer(stringRedisSerializer);
//        stringRedisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);
//        stringRedisTemplate.setEnableTransactionSupport(true);
        return stringRedisTemplate;
    }


    @Bean(name = "redisCacheManager")
    public CacheManager initRedisCacheManager(StringRedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        // 设置超时时间为10分钟，单位为秒
        cacheManager.setDefaultExpiration(600);
        // 设置缓存名称
        List<String> cacheNames = new ArrayList<>();
        cacheNames.add("redisCacheManager");
//        cacheManager.setCacheNames(cacheNames);
        return cacheManager;
    }

}

redis工具类：redisUtils.class

package com.chenglulu.api.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;


@Service
public class RedisUtil {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public StringRedisTemplate getStringRedisTemplate() {
        return this.stringRedisTemplate;
    }

    public RedisConnection getRedisConnection() {
        return this.stringRedisTemplate.getConnectionFactory().getConnection();
    }

    // 是否存在key
    public Boolean hasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    // 设置指定key的值
    public void set(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    // 获取指定key的值
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

示例使用

@Service
public class redisService {
    @Autowired
    private RedisUtil redisUtil;

    public void setTestRedis(){
      RedisConnection redisConnection = getRedisConnection();
      
      try{
          redisUtil.set("test","123456");
      }catch(Exception e){
          
      }
      if(redisConnection != null){
        redisConnection.close();
      }
    }

    public String getTestRedis(){
      RedisConnection redisConnection = getRedisConnection();
      
      String value = null;
      try{
          if(redisUtil.hasKey("test")){
              value = redisUtil.get("test");
          };
      }catch(Exception e){
          
      }
      if(redisConnection != null){
        redisConnection.close();
      }
      return value;
    }

    /*判断redis是否可用*/
    public RedisConnection getRedisConnection(){
        RedisConnection redisConnection = null;
        try {
            redisConnection = redisUtil.getRedisConnection();
        }catch (RedisConnectionFailureException e){
            logger.error("getRedisConnection RedisConnectionFailureException e = {}", e);
        }catch (Exception e){
            logger.error("getRedisConnection Exception e = {}", e);
        }
        if(redisConnection == null){
            //可以在redis有异常时做一些事情
        }
        logger.info("getRedisConnection RedisConnection is = {}", redisConnection);
        return redisConnection;
    }
}