SpringBoot @Cacheable注解的属性使用

柔光的暖阳◎ 2022-02-23 03:46 625阅读 0赞

#### cacheNames和value ####

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

/** * Alias for {@link #cacheNames}. */
    	@AliasFor("cacheNames")
    	String[] value() default { };
    
    	/** * Names of the caches in which method invocation results are stored. * <p>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 { };

#### key ####

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

/** * Spring Expression Language (SpEL) expression for computing the key dynamically. * <p>Default is {@code ""}, meaning all method parameters are considered as a key, * unless a custom {@link #keyGenerator} has been configured. * <p>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 "";

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>位置</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>methodName</td> 
   <td>root object</td> 
   <td>被调用的方法名称</td> 
   <td>#root.methodName</td> 
  </tr> 
  <tr> 
   <td>Method</td> 
   <td>root object</td> 
   <td>被调用的方法</td> 
   <td>#<a href="http://root.method.name" rel="nofollow">root.method.name</a></td> 
  </tr> 
  <tr> 
   <td>Target</td> 
   <td>root object</td> 
   <td>当前被调用的目标对象</td> 
   <td>#root.target</td> 
  </tr> 
  <tr> 
   <td>targetClass</td> 
   <td>root object</td> 
   <td>当前被调用的目标对象类</td> 
   <td>#root.targetClass</td> 
  </tr> 
  <tr> 
   <td>args</td> 
   <td>root object</td> 
   <td>被调用方法的参数列表#root.args[0]</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>caches</td> 
   <td>root object</td> 
   <td>调用的缓存列表</td> 
   <td>#root.caches[0].name</td> 
  </tr> 
  <tr> 
   <td>argument name</td> 
   <td>evaluation context</td> 
   <td>方法的参数名称可以直接使用#参数名</td> 
   <td>#p0,#a0等等</td> 
  </tr> 
  <tr> 
   <td>result</td> 
   <td>evaluation context</td> 
   <td>执行方法后的返回值</td> 
   <td>#result</td> 
  </tr> 
 </tbody> 
</table>

可以通过这个参数提示列表看看到这个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. * <p>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. * <p>Default is {@code ""}, meaning the method result is always cached. * <p>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. * <p>Unlike {@link #condition}, this expression is evaluated after the method * has been called and can therefore refer to the {@code result}. * <p>Default is {@code ""}, meaning that caching is never vetoed. * <p>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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25paHVpMTIz_size_16_color_FFFFFF_t_70]: /images/20220223/1b7f5a3997154d698ca989f0279847a4.png