SpringBoot @Cacheable注解的属性使用

拼搏现实的明天。 2023-02-13 00:22 2阅读 0赞

**cacheNames和value**

**指定缓存组件的名字，通过下面代码可以看出可以将返回结果放在哪个缓存中，可以通过数组的方式指定多个缓存**

一般标准在有返回实体得方法上，表示第一次进来，如果从指定缓存得名字获取数据，如果获取为空，就从方法得具体实现获取，第二次进来，就获取就直接获取缓存名称为CategoryListByParentId得值，key得parentId作为条件值缓存中查询

/**
 	 * Alias for {@link #cacheNames}.
 	 */
 	@AliasFor("cacheNames")
 	String[] value() default {};
 
 	/**
 	 * Names of the caches in which method invocation results are stored.
 	 * Names may be used to determine the target cache (or caches), matching
 	 * the qualifier value or bean name of a specific bean definition.
 	 * @since 4.2
 	 * @see #value
 	 * @see CacheConfig#cacheNames
 	 */
 	@AliasFor("value")
 	String[] cacheNames() default {};

![20200526175312648.png][]

**key**

**缓存数据的时候使用的key，它是用来指定对应的缓存，模拟使用方法参数值作为key的值。也可以使用SpEL表达式的值来指定**

/**
 	 * Spring Expression Language (SpEL) expression for computing the key dynamically.
 	 * Default is {@code ""}, meaning all method parameters are considered as a key,
 	 * unless a custom {@link #keyGenerator} has been configured.
 	 * The SpEL expression evaluates against a dedicated context that provides the
 	 * following meta-data:
 	 * <ul>
 	 * <li>{@code #root.method}, {@code #root.target}, and {@code #root.caches} for
 	 * references to the {@link java.lang.reflect.Method method}, target object, and
 	 * affected cache(s) respectively.</li>
 	 * <li>Shortcuts for the method name ({@code #root.methodName}) and target class
 	 * ({@code #root.targetClass}) are also available.
 	 * <li>Method arguments can be accessed by index. For instance the second argument
 	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
 	 * can also be accessed by name if that information is available.</li>
 	 * </ul>
 	 */
 	String key() default "";

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MjA0NzY0_size_16_color_FFFFFF_t_70][]

**可以通过这个参数提示列表看看到这个key所支持的root object对象有哪些，通过这样的方式可以指定对应的key值。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]

**keyGenerator**

这个是表示指定的key的生成器，当然在之前分享中我们说过一个简单的key的生成策略。这里我们还可以通过自定的方式来实现这个key的生成策略。

import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import java.lang.reflect.Method;
    import java.util.Arrays;
    @Configuration
    public class MyCacheConfig {
        @Bean("myKeyGenerator")
        public KeyGenerator keyGenerator(){
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    return method.getName()+"["+ Arrays.asList(params).toString()+"]";
                }
            };
        }
    }

在使用的时候可以通过一下的方式进行配置

@Cacheable(cacheNames = {"emp"},keyGenerator = "myKeyGenerator")

**cacheManager指定缓存管理器**

/**
 	 * The bean name of the custom {@link org.springframework.cache.CacheManager} to use to
 	 * create a default {@link org.springframework.cache.interceptor.CacheResolver} if none
 	 * is set already.
 	 * Mutually exclusive with the {@link #cacheResolver} attribute.
 	 * @see org.springframework.cache.interceptor.SimpleCacheResolver
 	 * @see CacheConfig#cacheManager
 	 */
 	String cacheManager() default "";
 	/**
 	 * The bean name of the custom {@link org.springframework.cache.interceptor.CacheResolver}
 	 * to use.
 	 * @see CacheConfig#cacheResolver
 	 */
 	String cacheResolver() default "";

**condition**

指定复合条件的情况下才缓存。也可以通过SpEL表达式进行设置。这个配置规则和上面表格中的配置规则是相同的。

/**
 	 * Spring Expression Language (SpEL) expression used for making the method
 	 * caching conditional.
 	 * Default is {@code ""}, meaning the method result is always cached.
 	 * The SpEL expression evaluates against a dedicated context that provides the
 	 * following meta-data:
 	 * <ul>
 	 * <li>{@code #root.method}, {@code #root.target}, and {@code #root.caches} for
 	 * references to the {@link java.lang.reflect.Method method}, target object, and
 	 * affected cache(s) respectively.</li>
 	 * <li>Shortcuts for the method name ({@code #root.methodName}) and target class
 	 * ({@code #root.targetClass}) are also available.
 	 * <li>Method arguments can be accessed by index. For instance the second argument
 	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
 	 * can also be accessed by name if that information is available.</li>
 	 * </ul>
 	 */
 	String condition() default "";

**unless(除非)**

当这个条件为true的时候，方法的返回值就不会被缓存

/**
 	 * Spring Expression Language (SpEL) expression used to veto method caching.
 	 * Unlike {@link #condition}, this expression is evaluated after the method
 	 * has been called and can therefore refer to the {@code result}.
 	 * Default is {@code ""}, meaning that caching is never vetoed.
 	 * The SpEL expression evaluates against a dedicated context that provides the
 	 * following meta-data:
 	 * <ul>
 	 * <li>{@code #result} for a reference to the result of the method invocation. For
 	 * supported wrappers such as {@code Optional}, {@code #result} refers to the actual
 	 * object, not the wrapper</li>
 	 * <li>{@code #root.method}, {@code #root.target}, and {@code #root.caches} for
 	 * references to the {@link java.lang.reflect.Method method}, target object, and
 	 * affected cache(s) respectively.</li>
 	 * <li>Shortcuts for the method name ({@code #root.methodName}) and target class
 	 * ({@code #root.targetClass}) are also available.
 	 * <li>Method arguments can be accessed by index. For instance the second argument
 	 * can be accessed via {@code #root.args[1]}, {@code #p1} or {@code #a1}. Arguments
 	 * can also be accessed by name if that information is available.</li>
 	 * </ul>
 	 * @since 3.2
 	 */
 	String unless() default "";

**sync**

是否异步

/**
 	 * Synchronize the invocation of the underlying method if several threads are
 	 * attempting to load a value for the same key. The synchronization leads to
 	 * a couple of limitations:
 	 * <ol>
 	 * <li>{@link #unless()} is not supported</li>
 	 * <li>Only one cache may be specified</li>
 	 * <li>No other cache-related operation can be combined</li>
 	 * </ol>
 	 * This is effectively a hint and the actual cache provider that you are
 	 * using may not support it in a synchronized fashion. Check your provider
 	 * documentation for more details on the actual semantics.
 	 * @since 4.3
 	 * @see org.springframework.cache.Cache#get(Object, Callable)
 	 */
 	boolean sync() default false;

注意在使用这个属性的时候，当这个属性为true的时候，unless属性是不能使用的。

*  \{@link \#unless()\} is not supported

[20200526175312648.png]: https://img-blog.csdnimg.cn/20200526175312648.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MjA0NzY0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200526175611599.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MjA0NzY0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190406141851257.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz,size_16,color_FFFFFF,t_70