Redisson结合SpringCache优雅的使用缓存

Redisson结合SpringCache优雅的使用缓存

redisson结合SpringCache使用缓存,可控缓存时间

pom

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson-spring-boot-starter</artifactId>
   <version>3.21.1</version>
 </dependency>

yaml

spring:
  #  redis 接口及端口配置
  redis:
    redisson:
      host: 127.0.0.1
      port: 6379
      password: root
      timeout: 3000  #连接超时时间

config

package com.config.redissonConfig;

import lombok.Getter;
import lombok.Setter;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.Codec;
import org.redisson.spring.cache.CacheConfig;
import org.redisson.spring.cache.RedissonSpringCacheManager;

import java.util.Map;

/**
 * @author: syh
 * @date: 2023/10/11
 * @description: 类描述 调整默认时间作为cache缓存使用
 */
public class MessageRedissonCacheManager extends RedissonSpringCacheManager {
    public MessageRedissonCacheManager(RedissonClient redisson) {
        super(redisson);
    }

    public MessageRedissonCacheManager(RedissonClient redisson, Map<String, ? extends CacheConfig> config) {
        super(redisson, config);
    }

    public MessageRedissonCacheManager(RedissonClient redisson, Map<String, ? extends CacheConfig> config, Codec codec) {
        super(redisson, config, codec);
    }

    public MessageRedissonCacheManager(RedissonClient redisson, String configLocation) {
        super(redisson, configLocation);
    }

    public MessageRedissonCacheManager(RedissonClient redisson, String configLocation, Codec codec) {
        super(redisson, configLocation, codec);
    }

    @Override
    public CacheConfig createDefaultConfig() {
        return defaultConfig;
    }


    @Getter
    @Setter
    /**
     * 默认时间   最长时间24小时  ,最大空间时间1小时
     */
    private CacheConfig defaultConfig = new CacheConfig(24 * 60 * 60 * 1000, 60 * 60 * 1000);
}

package com.common.contains;

/**
 * @author: syh
 * @date: 2023/9/26
 * @description: 类描述
 */
public class SyhStringContains {

    /**
     * 点  .
     */
    public final static String POINTS_CHARACTER = ".";

    /**
     * 左 中括号
     */
    public final static String LEFT_MIDDLE = "[";
    /**
     * 右  中括号
     */
    public final static String RIGHT_MIDDLE = "[";


    /**
     * 左 大括号
     */
    public final static String LEFT_BRACE = "{";

    /**
     * 左 大括号
     */
    public final static String RIGHT_BRACE = "}";


}

package com.config.redissonConfig;

import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import com.common.contains.SyhStringContains;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.spring.cache.CacheConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.CacheManager;
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.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.HashMap;
import java.util.Map;

/**
 * @author: syh
 * @date: 2023/9/20
 * @description: 类描述  redis配置类
 */
@Configuration
//开启缓存支持
@EnableCaching
public class RedisConfig {


    @Bean
    //注解表示没有就创建bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        //使用fastjson序列化
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        //redis提供的工厂
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    //比较适用于单纯的key-value 比如redis分布式锁
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }


    //设置缓存过期
    @Bean
    public CacheManager cacheManager(RedissonClient redissonClient) {
        MessageRedissonCacheManager cacheManager = new MessageRedissonCacheManager(redissonClient, getCacheManagerConfigMap(), new JsonJacksonCodec());
        // 设置其他key的默认时间,已有默认24小时,空闲1小时;  设置时间为60秒,空闲30秒
        cacheManager.setDefaultConfig(new CacheConfig(60 * 1000, 30 * 1000));
        // 关闭空值的存储 
        cacheManager.setAllowNullValues(false);
        return cacheManager;
    }


    /**
     * 定制缓存的时间 redisson的桶,cache的命名空间为维度  cacheName,value;
     *
     * @return
     */
    private Map<String, CacheConfig> getCacheManagerConfigMap() {
        Map<String, CacheConfig> configMap = new HashMap<>(16);
        //自定义cache的缓存时间  此处可以定义一些缓存,比如字典等等
        //redisson的缓存以key以hash 桶的形式存在
        // syhToken 过期时间是 12 小时,过期自动删除   空闲之间是1小时 1小时不被防范自动删除
        configMap.put("syhToken", new CacheConfig(5 * 60 * 1000, 5 * 60 * 1000));
        //token 过期时间1小时  最大空闲时间30分钟
        configMap.put("token1", new CacheConfig(60 * 1000, 30 * 1000));
        configMap.put("token666", new CacheConfig(24 * 60 * 60 * 1000, 24 * 60 * 60 * 1000));
        return configMap;
    }

    @Bean("KeyGenerator")
    public KeyGenerator getRequestAll() {
        //拼接缓存参数  类全名称.方法名[请求参数拼接]
        return (o, method, objects) -> {
            StringBuilder builder = new StringBuilder();
            builder.append(o.getClass().getSimpleName());
            builder.append(SyhStringContains.POINTS_CHARACTER);
            builder.append(method.getName());
            builder.append(SyhStringContains.LEFT_MIDDLE);
            //拼接所有的参数
            for (Object object : objects) {
                builder.append(object);
            }
            builder.append(SyhStringContains.RIGHT_MIDDLE);
            return builder.toString();
        };
    }
}

controller

package com.controller;

import com.rest.request.resis.RedisRequest;
import com.rest.response.Response;
import com.service.redis.RedisTestService;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author: syh
 * @date: 2023/9/20
 * @description: redis的测试
 */
@RestController
@RequestMapping("/redis")
public class RedisTestController {

    @Autowired
    private RedisTestService redisTestService;


    @PostMapping("/name")
    public Response getName(@RequestBody RedisRequest request) {
        String result = redisTestService.getName(request);
        return Response.ok(result);
    }

    @PostMapping("/syhToken")
    public Response getSyhToken(@RequestBody RedisRequest request) {
        String result = redisTestService.getSyhToken(request);
        return Response.ok(result);
    }



    @PostMapping("/6667")
    public Response getTest01(@RequestBody RedisRequest request) {
        String result = redisTestService.getTest01(request);
        return Response.ok(result);
    }

}

service

package com.service.redis;

import com.rest.request.resis.RedisRequest;

public interface RedisTestService {

    String getName(RedisRequest request);

    String getSyhToken(RedisRequest request);

    String getTest01(RedisRequest request);

}

package com.service.redis.impl;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonGenerator;
import com.rest.request.resis.RedisRequest;
import com.service.redis.RedisTestService;
import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * @author: syh
 * @date: 2023/9/20
 * @description: 类描述
 */
@Service
public class RedisTestServiceImpl implements RedisTestService {



    @Autowired
    private RedissonClient redissonClient;



    @Cacheable(cacheNames = "name", key = "#request.name")
    @Override
    public String getName(RedisRequest request) {
        return request.getName();
    }

    @Cacheable(cacheNames = "syhToken", key = "#request.key")
    @Override
    public String getSyhToken(RedisRequest request) {
        System.out.println(1);
        return request.toString();
    }
    
    @Cacheable(value = "token",keyGenerator = "KeyGenerator") // keyGenerator拼接测试
    @Override
    public String getTest01(RedisRequest request) {
        return JSON.toJSONString(request);
    }

}