Spring-Cache key设置注意事项，及自定义keyGenerator

BestClever

已于 2022-06-15 11:31:14 修改

阅读量1.4w

点赞数

分类专栏：后端文章标签： spring java 缓存

于 2019-04-29 21:06:30 首次发布

原文链接：https://blog.csdn.net/tongshuixu8025/article/details/89682948

版权

后端专栏收录该内容

24 篇文章

订阅专栏

本文深入探讨了如何在项目中使用Spring Cache和Guava Cache来提高并发性能，通过实例详细介绍了不同场景下缓存key的配置方法，包括基本形式、组合形式、对象形式以及自定义Key生成器，解决了多参数、原子类型数组、方法名识别等问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为了提升项目的并发性能，考虑引入本地内存Cache，对：外部数据源访问、Restful API调用、可重用的复杂计算等3种类型的函数处理结果进行缓存。目前采用的是Spring Cache的@Cacheable注解方式，缓存具体实现选取的是Guava Cache。

具体缓存的配置此处不再介绍，重点对于key的配置进行说明：

1、基本形式

@Cacheable(value="cacheName", key"#id")
public ResultDTO method(int id);

2、组合形式

@Cacheable(value="cacheName", key"T(String).valueOf(#name).concat('-').concat(#password))
public ResultDTO method(int name, String password);

3、对象形式

@Cacheable(value="cacheName", key"#user.id)
public ResultDTO method(User user);

4、自定义Key生成器

@Cacheable(value="gomeo2oCache", keyGenerator = "keyGenerator")
public ResultDTO method(User user);

有一个尤其需要注意的坑：Spring默认的SimpleKeyGenerator是不会将函数名组合进key中的

举个栗子：

@Component  
    public class CacheTestImpl implements CacheTest {
    
        @Cacheable("databaseCache")
        public Long test1()
        { return 1L; }
        
        @Cacheable("databaseCache")

        public Long test2()

        { return 2L; }

        @Cacheable("databaseCache")

        public Long test3()

        { return 3L; }

        @Cacheable("databaseCache")

        public String test4()

        { return "4"; }

    }

我们期望的输出是：

而实际上的输出是：

1
1
1
ClassCastException: java.lang.Long cannot be cast to java.lang.String

此外，原子类型的数组，直接作为key使用也是不会生效的

为了解决上述2个问题，自定义了一个KeyGenerator如下：

class CacheKeyGenerator implements KeyGenerator {

	// custom cache key
	
    public static final int NO_PARAM_KEY = 0;

    public static final int NULL_PARAM_KEY = 53;

    @Override

    public Object generate(Object target, Method method, Object... params) {

        StringBuilder key = new StringBuilder();
        key.append(target.getClass().getSimpleName()).append(".").append(method.getName()).append(":");
        if (params.length == 0) {
			return key.append(NO_PARAM_KEY).toString();
		   }



        for (Object param : params) {



            if (param == null) {



                log.warn("input null param for Spring cache, use default key={}", NULL_PARAM_KEY);



                key.append(NULL_PARAM_KEY);



            } else if (ClassUtils.isPrimitiveArray(param.getClass())) {



                int length = Array.getLength(param);



                for (int i = 0; i < length; i++) {



                    key.append(Array.get(param, i));



                    key.append(',');



                }



            } else if (ClassUtils.isPrimitiveOrWrapper(param.getClass()) || param instanceof String) {



                key.append(param);



            } else {



                log.warn("Using an object as a cache key may lead to unexpected results. " +



                        "Either use @Cacheable(key=..) or implement CacheKey. Method is " + target.getClass() + "#" + method.getName());



                key.append(param.hashCode());



            }



            key.append('-');



        }



 



        String finalKey = key.toString();



        long cacheKeyHash = Hashing.murmur3_128().hashString(finalKey, Charset.defaultCharset()).asLong();



        log.debug("using cache key={} hashCode={}", finalKey, cacheKeyHash);



        return key.toString();



    }



}

采用此方式后可以解决：多参数、原子类型数组、方法名识别等问题

https://blog.csdn.net/syani/article/details/52239967