实现效果

原来的@Cacheable使用方式：

@Cacheable(value = "userinfo", key = "#dto.userId")

实现后的使用方式：

@Cacheable(value = "userinfo#30#m", key = "#dto.userId")

实现代码

1. 创建一个自定义的缓存管理器，继承自RedisCacheManager

public class CustomRedisCacheManager extends RedisCacheManager {
    
    public CustomRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }

    /**
     * 重写createRedisCache方法
     * @param name 原来的name只是作为redis存储键名
     *             重写的name可通过"#"拼接过期时间：
     *             1. 如果没有"#"则默认不设置过期时间
     *             2. 拼接的第一个"#"后面为过期时间，第二个"#"后面为时间单位
     *             3. 时间单位的表示使用: d(天)、h(小时)、m(分钟)、s(秒), 默认为h(小时)
     * @param cacheConfig
     * @return
     */
    @Override
    protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
        // 解析name,设置过期时间
        if (StringUtils.isNotEmpty(name) && name.contains("#")) {
            String[] split = name.split("#");

            // 缓存键名
            String cacheName = split[0];
            // "#"后第一位是时间
            int expire = Integer.parseInt(split[1]);
            // 过期时间，默认为h(小时)
            Duration duration = Duration.ofHours(expire);
            // 根据"#"后第二位字符判断过期时间的单位，设置相应的过期时间，默认时间单位是h(小时)
            if (split.length == 3) {
                switch (split[2]){
                    case "d":
                        duration = Duration.ofDays(expire);
                        break;
                    case "m":
                        duration = Duration.ofMinutes(expire);
                        break;
                    case "s":
                        duration = Duration.ofSeconds(expire);
                        break;
                    default:
                        duration = Duration.ofHours(expire);
                }
            }
            return super.createRedisCache(cacheName, cacheConfig.entryTtl(duration));
        }
        return super.createRedisCache(name, cacheConfig);
    }
}

2. 在redis配置类中，将上面自定义的缓存管理器注册为Bean

@Configuration
@EnableCaching
public class RedisConfig {
    
    /**
     * 自定义RedisTemplate
     * 设置Redis序列化方式，默认使用的是JDKSerializer的序列化方式，效率低，所以这里设置使用FastJsonRedisSerializer
     * @param connectionFactory
     * @return
     */
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        // 设置redis连接（LettuceConnectionFactory实现了RedisConnectionFactory）
        redisTemplate.setConnectionFactory(connectionFactory);

        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);

        // key设置StringRedisSerializer序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // value设置FastJsonRedisSerializer序列化
        redisTemplate.setValueSerializer(serializer);

        // Hash key设置序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash value设置序列化
        redisTemplate.setHashValueSerializer(serializer);

        return redisTemplate;
    }


    /**
     * 实例化自定义的缓存管理器
     * @param redisTemplate
     * @return
     */
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(Objects.requireNonNull(redisTemplate.getConnectionFactory()));
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
        return new CustomRedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }
}