基于注解的缓存
对于缓存声明，Spring 的缓存提供了一组 Java 注解：
@Cacheable：触发缓存写入。
@CacheEvict：触发缓存清除。
@CachePut：更新缓存(不会影响到方法的运行)。
@Caching : 重新组合要应用于方法的多个缓存操作。
@CacheConfig：设置类级别上共享的一些常见缓存设置。
@Cacheable
顾名思义，@Cacheable 可以用来进行缓存的写入，将结果存储在缓存中，以便于在后续调用的时候可以直接返回缓存中的值，而不必再执行实际方法。 使用方式，注解名称=缓存名称，使用例子如下:
@Cacheable("books")
public Book findBook(ISBN isbn) {
...
}
一个方法可以对应两个缓存名称，如下:
@Cacheable({"books", "isbns"})
public Book findBook(ISBN isbn) {...}
@Cacheable 的缓存 key 是可以配置动态参数的，比如选择传入的参数,如下: (以下示例是使用 SpEL 声明,如果您不熟悉 SpEL，可以阅读Spring Expression Language)
@Cacheable(cacheNames="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
@Cacheable(cacheNames="books", key="#isbn.rawNumber")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
@Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
@Cacheable 还可以设置根据条件判断是否需要缓存
condition：取决于给定的参数是否满足条件
unless：取决于返回值是否满足条件，返回 false 时候说明走缓存
以下是一个简单的例子:
@Cacheable(cacheNames="book", condition="#name.length() < 32")
public Book findBook(String name)
@Cacheable(cacheNames="book", condition="#name.length() < 32", unless="
#result.hardback")
public Book findBook(String name)
@Cacheable 还可以设置：
keyGenerator(指定 key 自动生成方法)
cacheManager(指定使用的缓存管理)
cacheResolver(指定使用缓存的解析器)等,这些参数比较适合全局设置，这里就不多做介绍了。
@CachePut
@CachePut:当需要更新缓存而不干扰方法的运行时 ，可以使用该注解。也就是说，始终执行该方法，并将结果放入缓存，注解参数与 @Cacheable 相同。 以下是一个简单的例子:
@CachePut(cacheNames="book", key="#isbn")
public Book updateBook(ISBN isbn, BookDescriptor descriptor)
通常强烈建议不要对同一方法同时使用 @CachePut 和 @Cacheable 注解，因为它们具有不同的行为。可能会产生不可思议的 BUG 哦。
@CacheEvict
@CacheEvict：删除缓存的注解,这对删除旧的数据和无用的数据是非常有用的。这里还多了一个参数(allEntries),设置 allEntries=true 时，可以对整个条目进行批量删除。 以下是个简单的例子:
@CacheEvict(cacheNames="books")
public void loadBooks(InputStream batch)
//对cacheNames进行批量删除
@CacheEvict(cacheNames="books", allEntries=true)
public void loadBooks(InputStream batch)
@Caching
@Caching：在使用缓存的时候，有可能会同时进行更新和删除，会出现同时使用多个注解的情况.而 @Caching 可以实现。 以下是个简单的例子：
@Caching(evict = { @CacheEvict("primary"),
@CacheEvict(cacheNames="secondary", key="#p0") })
public Book importBooks(String deposit, Date date)
@CacheConfig
@CacheConfig:缓存提供了许多的注解选项，但是有一些公用的操作，我们可以使用 @CacheConfig 在类上进行全局设置。 以下是个简单的例子：
@CacheConfig("books")
public class BookRepositoryImpl implements BookRepository {
@Cacheable
public Book findBook(ISBN isbn) {...}
}
可以共享缓存名称，统一配置 KeyGenerator,CacheManager,CacheResolver。
Redis 整合技巧说明
来看看我们在 springboot 中怎么使用 redis 来作为缓存吧.
cache 配置 redis 作为缓存
pom.xml 引入 redis 依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
springboot 集成 redis，文件配置如下：
spring:
redis:
database: 0 # Database index used by the connection factory.
url: redis://user:@127.0.0.1:6379 # Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379
host: 127.0.0.1 # Redis server host.
password: # Login password of the redis server.
port: 6379 # Redis server port.
ssl: false # Whether to enable SSL support.
timeout: 5000 # Connection timeout.
redis 缓存配置类 CacheConfig，这里对 spring 的缓存进行了配置，包括
KeyGenerator
CacheResolver
CacheErrorHandler
CacheManager
还有 redis 序列化方式。
@Configuration
public class CacheConfig extends CachingConfigurerSupport {
//较低版本为2.0.0以下。以上版本Lettuce，但是含义是一样的
@Resource
private RedisConnectionFactory factory;
/**
* 自定义生成redis-key
* @return
*/
@Override
@Bean
public KeyGenerator keyGenerator() {
return (o, method, objects) -> {
StringBuilder sb = new StringBuilder();
sb.append(o.getClass().getName()).append(".");
sb.append(method.getName()).append(".");
for (Object obj : objects) {
sb.append(obj.toString());
}
return sb.toString();
};
}
@Bean
public RedisTemplate<Object, Object> redisTemplate() {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
return redisTemplate;
}
@Bean
@Override
public CacheResolver cacheResolver() {
return new SimpleCacheResolver(cacheManager());
}
// 用于捕获从Cache中进行CRUD时的异常的回调处理器。
@Bean
@Override
public CacheErrorHandler errorHandler() {
return new SimpleCacheErrorHandler();
}
@Bean
@Override
public CacheManager cacheManager() {
RedisCacheConfiguration cacheConfiguration =
defaultCacheConfig()
.disableCachingNullValues()
.serializeValuesWith(RedisSerializationContext
.SerializationPair.fromSerializer(
new GenericJackson2JsonRedisSerializer()));
return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration).build();
}
}
代码使用
测试 @Cacheable 方法
@Test
public void findUserTest() {
for (int i = 0; i < 3; i++) {
System.out.println("第" + i + "次");
User user = userService.findUser();
System.out.println(user);
}
}
@Override
@Cacheable(value = {"valueName", "valueName2"}, key = "'keyName1'")
public User findUser() {
System.out.println("执行方法...");
return new User("id1", "张三", "深圳", "1234567", 18);
}
执行结果
只有一次输出了'执行方法...',后面直接从缓存获取，不会再进入方法。
第0次
执行方法...
User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
第1次
User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
第2次
User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
测试 @CachePut 方法:对缓存进行了修改
@Test
public void updateUserTest() {
userService.updateUser();
User user = userService.findUser();
System.out.println(user);
}
@Override
@CachePut(value = "valueName", key = "'keyName1'")
public User updateUser() {
System.out.println("更新用户...");
return new User("id1", "李四", "北京", "1234567", 18);
}
执行结果
对缓存进行了更新，获取值的时候取了新的值
更新用户...
User{id='id1', name='李四', address='北京', tel='1234567', age=18}
测试 @CacheEvict 方法:缓存被清空，再次 findUser 的时候又重新执行了方法。
@Test
public void clearUserTest() {
userService.clearUser();
User user = userService.findUser();
System.out.println(user);
}
@Override
@CacheEvict(value = "valueName",allEntries = true)
public void clearUser() {
System.out.println("清除缓存...");
}
执行结果
这里清除了缓存，为什么还是没有执行方法呢？因为这个方法我们定了两个 value 值，清了一个还有一个
清除缓存...
User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
User.java
public class User implements Serializable {
public User() {
}
private String id;
private String name;
private String address;
private String tel;
private Integer age;
//省略get,set,tostring
}
CacheTest.java
@RunWith(SpringRunner.class)
@SpringBootTest
@EnableCaching
public class CacheTest {
@Resource
private UserService userService;
@Test
public void findUserTest() {
for (int i = 0; i < 3; i++) {
System.out.println("第" + i + "次");
User user = userService.findUser();
System.out.println(user);
}
}
@Test
public void updateUserTest() {
userService.updateUser();
User user = userService.findUser();
System.out.println(user);
}
@Test
public void clearUserTest() {
userService.clearUser();
User user = userService.findUser();
System.out.println(user);
}
}
UserService.java
public interface UserService {
/**
* 获取用户
* @return user
*/
User findUser();
/**
* 更新用户信息
* @return user
*/
User updateUser();
/**
* 清除缓存的用户信息
*/
void clearUser();
}
UserServiceImpl.java
@Service
@CacheConfig(cacheNames = "CacheConfigName")
public class UserServiceImpl implements UserService {
@Override
@Cacheable(value = {"valueName", "valueName2"}, key = "'keyName1'")
public User findUser() {
System.out.println("执行方法...");
return new User("id1", "张三", "深圳", "1234567", 18);
}
@Override
@CachePut(value = "valueName", key = "'keyName1'")
public User updateUser() {
System.out.println("更新用户...");
return new User("id1", "李四", "北京", "1234567", 18);
}
@Override
@CacheEvict(value = "valueName",allEntries = true)
public void clearUser() {
System.out.println("清除缓存...");
}
}
至此总体的 Cache 和 Redis 的整合机制全部结束，如果有需要补充或者不对的地方，请读者多多指正！