SpringBoot 配置Redis详解及使用

环境：SpringBoot2.1.1.RELEASE版本

一、SpringBoot配置Reids

　　1、pom引入spring-boot-starter-data-redis包

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

　　2、application.yml配置Redis地址、端口及基本信息　　

　　注：如果Redis开启了密码，在timeout前增加password：mima

# Spring配置
spring:
  # redis配置  
  redis: 
     # 地址
     host: 127.0.0.1
     # 端口，默认为6379
     port: 6379 
     # 连接超时时间
     timeout: 10s
     lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1m

二、增加RedisConfig.java启动加载类

import java.time.Duration;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheManager.RedisCacheManagerBuilder;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

/***
 * redis 配置
 * @author*/
@Configuration
@EnableCaching
public class RedisCongif extends CachingConfigurerSupport {

    /**
     * 分割符
     */
    public static final String DECOLLATOR = ":";

    /**
     * 应用前缀
     */
    public static final String APP_PREFIX = "redis";

    /**
     * 缓存名前缀
     */
    public static final String CACHE_NAMES_PREFIX = APP_PREFIX + DECOLLATOR + "cacheNames" + DECOLLATOR;

    /**
     * 永不过期的缓存名
     */
    public static final String CACHE_NAME_FOREVER = CACHE_NAMES_PREFIX + "forever";

    /**
     * 10分钟有效期的缓存名
     */
    public static final String CACHE_NAME_MINUTES_10 = CACHE_NAMES_PREFIX + "minutes-10";

    /**
     * 30分钟有效期的缓存名
     */
    public static final String CACHE_NAME_MINUTES_30 = CACHE_NAMES_PREFIX + "minutes-30";

    /**
     * 1个小时有效期的缓存名
     */
    public static final String CACHE_NAME_HOURS_01 = CACHE_NAMES_PREFIX + "hours-1";

    /**
     * 24小时有效期的缓存名
     */
    public static final String CACHE_NAME_HOURS_24 = CACHE_NAMES_PREFIX + "hours-24";
    
    /**
     * 12小时有效期的缓存名
     */
    public static final String CACHE_NAME_HOURS_12 = CACHE_NAMES_PREFIX + "hours-12";

    /**
     * 30天有效期的缓存名
     */
    public static final String CACHE_NAME_DAYS_30 = CACHE_NAMES_PREFIX + "days-30";
    
    /**
     * 选择redis作为默认缓存工具
　　  * SpringBoot2.0以上CacheManager配置方式
     * @param redisTemplate
     * @return
     * */
    @Bean
    public CacheManager cacheManager(RedisTemplate<String, Object> redisTemplate) {
        RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                // 设置key为String
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getStringSerializer()))
                // 设置value 为自动转Json的Object
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()))
                // 不缓存null
                .disableCachingNullValues()
                // 缓存数据保存1小时
                .entryTtl(Duration.ofHours(1));
        RedisCacheManager redisCacheManager = RedisCacheManagerBuilder
                // Redis 连接工厂
                .fromConnectionFactory(redisTemplate.getConnectionFactory())
                // 缓存配置
                .cacheDefaults(defaultCacheConfiguration)
                // 配置同步修改或删除 put/evict
                .transactionAware()
                .build();
        
//        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
        return redisCacheManager;
    }
    
    
    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
    
    
}

需要注意的是，SpringBoot2.0以上版本（不太确定）RedisTempate<K, V> 必须要定义K和V，在SpringBoot1.5x版本以下是不需要的，CacheManager配置如下：

@Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);

        // 设置默认缓存过期时间(0为不失效)
        // redisCacheManager.setDefaultExpiration(0);//秒

        // 设置缓存的value属性的过期时间(单位秒)
        Map<String, Long> expiresMap = new HashMap<String, Long>();
        expiresMap.put(CACHE_NAME_FOREVER, 0L);// 0表示永不失效
        expiresMap.put(CACHE_NAME_MINUTES_10, 60L * 10);
        expiresMap.put(CACHE_NAME_MINUTES_30, 60L * 30);
        expiresMap.put(CACHE_NAME_HOURS_01, 60L * 60);
        expiresMap.put(CACHE_NAME_HOURS_24, 60L * 60 * 24);
        expiresMap.put(CACHE_NAME_HOURS_12, 60L * 60 * 12);
        expiresMap.put(CACHE_NAME_DAYS_30, 60L * 60 * 24 * 30);

        redisCacheManager.setExpires(expiresMap);

        return redisCacheManager;
    }

三、如何使用Redis，三种注解方式@Cacheable、@CachePut、@CacheEvict

/**
     * redis在serviceImpl里使用方式
     * 1、Cacheable 的用法
     *     缓存有数据时，从缓存获取；没有数据时，执行方法，并将返回值保存到缓存中
     *  @Cacheable 一般在查询中使用
     *     1) cacheNames 指定缓存区，没有配置使用@CacheConfig指定的缓存区
     *     2) key 指定缓存区的key
     *     3) 注解的值使用SpEL表达式（eq ==  lt <  le <=   gt >  ge >=）
     * 1.1、时效性缓存(缓存24小时)
     *     @Cacheable(value = RedisCongif.CACHE_NAME_HOURS_24)
     * 1.2、缓存到指定key
     *     @Cacheable(key="'list'")
     * 1.3、condition 满足条件缓存数据
     *     @Cacheable(key = "#id", condition = "#number ge 20") // >= 20
     * 1.4、unless 满足条件时否决缓存数据
     *     @Cacheable(key = "#id", unless = "#number lt 20") // < 20
     * 2、CachePut 的用法
     *     一定会执行方法，并将返回值保存到缓存中
     *  @CachePut 一般在新增和修改中使用
     * 2.1、缓存到指定key
     *     @CachePut(key = "#user.id")
     * 2.2、condition 满足条件缓存数据
     *     @CachePut(key = "#user.id", condition = "#user.age ge 20")
     * 3、CacheEvict 的用法
     *     CacheEvict 来删除缓存，@CacheEvict 就是一个触发器，在每次调用被它注解的方法时，就会触发删除它指定的缓存的动作
     * 3.1、根据key删除缓存区中的数据
     *     @CacheEvict(key = "#id")
     * 3.2、根据条件配置
     *     allEntries = true ：删除整个缓存区的所有值，此时指定的key无效
     *     beforeInvocation = true ：默认false，表示调用方法之后删除缓存数据；true时，在调用之前删除缓存数据(如方法出现异常)
     *     @CacheEvict(key = "#id", allEntries = true)
     */

以上是个人配置Redis步骤，使用的是时效缓存方式：@Cacheable(value = RedisCongif.CACHE_NAME_HOURS_24)，缓存24小时，24小时之后过期，会重新查询数据库获取最新的数据再次缓存24小时。时效可以根据自己的需求进行配置10分钟、30分钟、1小时、12小时、1天、30天等等。

posted @ 2020-09-15 10:39 小温2597 阅读(12910) 评论(1) 编辑收藏举报

刷新页面返回顶部

小温

SpringBoot 配置Redis详解及使用

一、SpringBoot配置Reids

1、pom引入spring-boot-starter-data-redis包

2、application.yml配置Redis地址、端口及基本信息

二、增加RedisConfig.java启动加载类

三、如何使用Redis，三种注解方式@Cacheable、@CachePut、@CacheEvict

公告

　　1、pom引入spring-boot-starter-data-redis包

　　2、application.yml配置Redis地址、端口及基本信息　　