springboot搭配redis缓存注解

启动类+注解 @EnableCaching
controller:
/**
 * 缓存测试
 * @param baseRequest
 * @return
 * @throws BizException
 */
@PostMapping("/testRedisCache")
public BaseResponse testRedisCache(CustomerDeliveryDetailRequest baseRequest) throws BizException {
    WmsEntityResponse wmsEntityResponse=new WmsEntityResponse();
    WmsErpWareEntity wmsErpWareEntity=undoPickBo.queryByWareCode(baseRequest.getWareCode());
    wmsEntityResponse.setData(wmsErpWareEntity);
    return wmsEntityResponse;
}

/**
 * 缓存测试
 * @param baseRequest
 * @return
 * @throws BizException
 */
@PostMapping("/testClearRedisCache")
public BaseResponse testClearRedisCache(CustomerDeliveryDetailRequest baseRequest) throws BizException {
    WmsEntityResponse wmsEntityResponse=new WmsEntityResponse();
    WmsErpWareEntity wmsErpWareEntity=undoPickBo.clearByWareCode(baseRequest.getWareCode());
    wmsEntityResponse.setData(wmsErpWareEntity);
    return wmsEntityResponse;
}

service:

@Transactional(rollbackFor = Exception.class)
@Cacheable(value = "wmsErpWare" ,key="#wareCode",unless="#result == null")
public WmsErpWareEntity queryByWareCode(String wareCode)
{
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("wareCode:"+wareCode);
    WmsErpWareEntity result= wmsErpWareBo.findByWmsWareCode(wareCode);
    return result;
}

@Transactional(rollbackFor = Exception.class)
@CacheEvict(value = "wmsErpWare" ,key="#wareCode")
public WmsErpWareEntity clearByWareCode(String wareCode)
{
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("wareCode:"+wareCode);
    return null;
}

redis配置过期时间

package cn.tfinfo.microservice.wms.biz.undopick.bo;

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.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.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import java.io.Serializable;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 */

@Configuration
@EnableCaching
public class RedisConfig implements Serializable {

    /**
     * 申明缓存管理器，会创建一个切面（aspect）并触发Spring缓存注解的切点（pointcut）
     * 根据类或者方法所使用的注解以及缓存的状态，这个切面会从缓存中获取数据，将数据添加到缓存之中或者从缓存中移除某个值
     */
 
   /* @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.create(redisConnectionFactory);
    }
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        // 创建一个模板类
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        // 将刚才的redis连接工厂设置到模板类中
        template.setConnectionFactory(factory);
        // 设置key的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化器
        //使用Jackson 2，将对象序列化为JSON
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //json转对象类，不设置默认的会将json转成hashmap
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }*/


    /**
     * 最新版，设置redis缓存过期时间
     */

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl( 10), // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        //SsoCache和BasicDataCache进行过期时间配置
        redisCacheConfigurationMap.put("messagCache", this.getRedisCacheConfigurationWithTtl(30 * 60));

        //自定义设置缓存时间
        redisCacheConfigurationMap.put("wmsErpWare", this.getRedisCacheConfigurationWithTtl(600));

        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> 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);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.disableCachingNullValues().entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }
}