SpringBoot整合Redis

1.导入依赖

<!--Redis依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>
<!--Jedis依赖-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
</dependency>

2.application.yml配置文件

spring:  
  redis:
    host: 127.0.0.1
    port: 6379
    timeout: 3
    jedis:
      pool:
        max-idle: 10
        max-active: 10
        max-wait: 5

3.RedisConfig：封装配置文件中Redis的相关配置

@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfig {
    private String host;
    private int port;
    private int timeout;//秒
    private int jedisPoolMaxActive;
    private int jedisPoolMaxIdle;
    private int jedisPoolMaxWait;//秒
    //get和set方法...
}

注意：使用@ConfigurationProperties注解需要导入依赖

<!--使用@ConfigurationProperties需要用到这个依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

4.使用JedisPool

@Configuration
public class Config {

    @Autowired
    RedisConfig redisConfig;

    /**
     * 将JedisPool添加到容器中
     * @return
     */
    @Bean
    public JedisPool jedisPoolFactory(){
        JedisPoolConfig jpc = new JedisPoolConfig();
        //使用配置文件中Redis的相关配置创建JedisPool
        jpc.setMaxIdle(redisConfig.getJedisPoolMaxIdle());
        jpc.setMaxTotal(redisConfig.getJedisPoolMaxActive());
        jpc.setMaxWaitMillis(redisConfig.getJedisPoolMaxWait()*1000);
        JedisPool jp = new JedisPool(jpc,redisConfig.getHost());
        return jp;
    }
}

5.获取Jedis操作Redis

• RedisService：操作Redis，存数据取数据

public class RedisService {


    @Autowired
    private JedisPool jedisPool;

    /**
     * 从Redis数据库中，通过key获得一个Class<T>类型的数据
     * @param key
     * @param clazz
     * @param <T> 表示方法的返回值是泛型
     * @return
     */
    public <T> T get(String key,Class<T> clazz){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = jedis.get(key);//调用Jedis操作Redis，通过key获得数据
            T value = stringToBean(str,clazz);//将String转为想要的clazz类型
            return value;
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 将String转为想要的clazz类型
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> T stringToBean(String str, Class<T> clazz) {
        if (str == null || str.length() <= 0){
            return null;
        }
        if (clazz == int.class || clazz == Integer.class){
            return (T) Integer.valueOf(str);
        }else if (clazz == String.class){
            return (T) str;
        }else if (clazz == long.class || clazz == Long.class){
            return (T) Long.valueOf(str);
        }else {
            return JSON.toJavaObject(JSON.parseObject(str),clazz);
        }
    }


    /**
     * 将连接返回连接池
     * @param jedis
     */
    private void returnToPool(Jedis jedis) {
        //jedis不是空，将jedis返回JedisPool
        if (jedis != null){
            jedis.close();
        }
    }

    /**
     * 将T型的数据存入Redis中
     * @param key
     * @param value
     * @param <T>
     * @return
     */
    public <T> boolean set(String key,T value){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = beanToString(value);//将T型的数据转为String
            if (str == null || str.length() <= 0){
                return false;
            }
            jedis.set(key,str);
            return true;
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 将T型的数据转为String
     * @param value
     * @param <T>
     * @return
     */
    private <T> String beanToString(T value) {
        if (value == null){
            return null;
        }
        Class<?> clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class){
            return "" + value;
        }else if (clazz == String.class){
            return (String)value;
        }else if (clazz == long.class || clazz == Long.class){
            return "" + value;
        }else {
            return JSON.toJSONString(value);
        }
    }
}

• RedisController：根据获得的请求进行不同的操作

@Controller
public class RedisController {

    @Autowired
    private RedisService redisService;

    /**
     * 测试操作是否成功
     * @return
     */
    @ResponseBody
    @RequestMapping("getKey")
    public Result<String> redisGet(){
        boolean b = redisService.set("key1", "hello hello");
        String s = redisService.get("key1", String.class);
        return Result.success(s);
    }
}

6.报错：Timeout waiting for idle object

经过调试，发现是因为application.xml中的max-idle、max-active、max-wait没有和RedisConfig中的jedisPoolMaxActive、jedisPoolMaxIdle、jedisPoolMaxWait绑定上。修改RedisConfig

@Component
    @ConfigurationProperties(prefix = "spring.redis")
    public class RedisConfig {
        private String host;
        private int port;
        private int timeout;//秒
        @Value("${spring.redis.jedis.pool.max-active}")
        private int jedisPoolMaxActive;
        @Value("${spring.redis.jedis.pool.max-idle}")
        private int jedisPoolMaxIdle;
        @Value("${spring.redis.jedis.pool.max-wait}")
        private int jedisPoolMaxWait;//秒
        //get和set方法...
}