SpringBoot @Cacheable注解的属性使用

cacheNames和value

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

	/**
	 * 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 {};

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:
	 * 

	 * 
{@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.
	 * 
Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
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.
	 * 
	 */
	String key() default "";

名称	位置	描述	示例
methodName	root object	被调用的方法名称	#root.methodName
Method	root object	被调用的方法	#root.method.name
Target	root object	当前被调用的目标对象	#root.target
targetClass	root object	当前被调用的目标对象类	#root.targetClass
args	root object	被调用方法的参数列表#root.args[0]
caches	root object	调用的缓存列表	#root.caches[0].name
argument name	evaluation context	方法的参数名称可以直接使用#参数名	#p0,#a0等等
result	evaluation context	执行方法后的返回值	#result

可以通过这个参数提示列表看看到这个key所支持的root object对象有哪些，通过这样的方式可以指定对应的key值。

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:
	 * 

	 * 
{@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.
	 * 
Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
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.
	 * 
	 */
	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:
	 * 

	 * 
{@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
	 * 
{@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.
	 * 
Shortcuts for the method name ({@code #root.methodName}) and target class
	 * ({@code #root.targetClass}) are also available.
	 * 
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.
	 * 
	 * @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:
	 * 

	 * 
{@link #unless()} is not supported
	 * 
Only one cache may be specified
	 * 
No other cache-related operation can be combined
	 * 
	 * 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