SpringBoot集成Redis

今天拿到手一个运用SpringBoot做的一个数据可视化项目，查询速度因为数据量越来越大导致速度较慢，所以需要运用Redis去做一个缓存。接下来看看怎么集成的吧：
需要的依赖

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

配置文件

    # Redis数据库索引（默认为0）
    spring.redis.database= 1
    # Redis服务器地址
    spring.redis.host=
    # Redis服务器连接端口
    spring.redis.port= 6379
    # Redis服务器连接密码（默认为空）
    spring.redis.password=
    # 连接池最大连接数（使用负值表示没有限制）
    spring.redis.pool.max-active= 1000
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.pool.max-wait= -1
    # 连接池中的最大空闲连接
    spring.redis.pool.max-idle= 10
    # 连接池中的最小空闲连接
    spring.redis.pool.min-idle= 5
    # 连接超时时间（毫秒）
    spring.redis.timeout= 0

Redis配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
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.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {


    /**
     * 生产key的策略
     *
     * @return
     */
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(":");
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    @SuppressWarnings({"rawtypes"})
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
        //设置超时时间，单位秒
        redisCacheManager.setDefaultExpiration(60);
        return redisCacheManager;
    }

    /**
     * redisTemplate配置
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate(redisConnectionFactory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

使用在方法上直接加注解就可以了
@Cacheable(value = “leo:scorpius”,key=”“)
key参数是必须的，但是因为有了配置类中的key的全局生成策略所以不再需要(生成策略包名:方法名)。
直接写成
@Cacheable(value = “leo:scorpius”,key=”“)

注解中value含义：就是redis中的key。
注解中key含义：在rides中判断是否是同一个对象需要。
(在不同需求中，可以自己根据需求去重写生成key的策略去reids中判断)