写点什么

🏆【SpringBoot 技术专题】「Cache 缓存组件」Redis 缓存使用技巧及注解大全

发布于: 1 小时前
🏆【SpringBoot技术专题】「Cache缓存组件」Redis缓存使用技巧及注解大全

基于注解的缓存

对于缓存声明,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 作为缓存

  1. pom.xml 引入 redis 依赖

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-data-redis</artifactId></dependency> 
复制代码
  1. 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. 
复制代码
  1. redis 缓存配置类 CacheConfig,这里对 spring 的缓存进行了配置,包括

  2. KeyGenerator

  3. CacheResolver

  4. CacheErrorHandler

  5. CacheManager

  6. 还有 redis 序列化方式。

@Configurationpublic 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@EnableCachingpublic 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 的整合机制全部结束,如果有需要补充或者不对的地方,请读者多多指正!


发布于: 1 小时前阅读数: 3
用户头像

🏆【2021年InfoQ写作平台】签约作者 2020.03.25 加入

🎗【酷爱计算机技术、醉心开发编程、喜爱健身运动、热衷悬疑推理的”极客狂人“】 🏅 【Java技术领域,MySQL技术领域,APM全链路追踪技术及微服务、分布式方向的技术体系等】 我们始于迷惘,终于更高水平的迷惘

评论

发布
暂无评论
🏆【SpringBoot技术专题】「Cache缓存组件」Redis缓存使用技巧及注解大全