当前位置:   article > 正文

springboot整合 @Cache和Redis_spring boot redis @caching

spring boot redis @caching

原文链接:https://www.cnblogs.com/wenjunwei/p/10779450.html

spring基于注解的缓存

对于缓存声明,spring的缓存提供了一组java注解:

  • @Cacheable:触发缓存写入。
  • @CacheEvict:触发缓存清除。
  • @CachePut:更新缓存(不会影响到方法的运行)。
  • @Caching:重新组合要应用于方法的多个缓存操作。
  • @CacheConfig:设置类级别上共享的一些常见缓存设置。

@Cacheable注解

顾名思义,@Cacheable可以用来进行缓存的写入,将结果存储在缓存中,以便于在后续调用的时候可以直接返回缓存中的值,而不必再执行实际的方法。 最简单的使用方式,注解名称=缓存名称,使用例子如下:

  1.   @Cacheable("books")
  2. public Book findBook(ISBN isbn) {...}

一个方法可以对应两个缓存名称,如下:

  1. @Cacheable({"books", "isbns"})
  2. public Book findBook(ISBN isbn) {...} 

@Cacheable的缓存名称是可以配置动态参数的,比如选择传入的参数,如下: (以下示例是使用SpEL声明,如果您不熟悉SpEL,可以阅读Spring Expression Language)

  1. @Cacheable(cacheNames="books", key="#isbn")
  2. public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
  3. @Cacheable(cacheNames="books", key="#isbn.rawNumber")
  4. public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
  5. @Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")
  6. public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed) 

@Cacheable还可以设置根据条件判断是否需要缓存

  • condition:取决于给定的参数是否满足条件
  • unless:取决于返回值是否满足条件

以下是一个简单的例子:

  1. @Cacheable(cacheNames="book", condition="#name.length() < 32")
  2. public Book findBook(String name)
  3. @Cacheable(cacheNames="book", condition="#name.length() < 32", unless="#result.hardback")
  4. public Book findBook(String name) 

@Cacheable还可以设置:keyGenerator(指定key自动生成方法),cacheManager(指定使用的缓存管理),cacheResolver(指定使用缓存的解析器)等,这些参数比较适合全局设置,这里就不多做介绍了。

@CachePut注解

@CachePut:当需要更新缓存而不干扰方法的运行时 ,可以使用该注解。也就是说,始终执行该方法,并将结果放入缓存,注解参数与@Cacheable相同。 以下是一个简单的例子:

  1. @CachePut(cacheNames="book", key="#isbn")
  2. public Book updateBook(ISBN isbn, BookDescriptor descriptor) 

通常强烈建议不要对同一方法同时使用@CachePut和@Cacheable注解,因为它们具有不同的行为。可能会产生不可思议的BUG哦。

@CacheEvict注解

@CacheEvict:删除缓存的注解,这对删除旧的数据和无用的数据是非常有用的。这里还多了一个参数(allEntries),设置allEntries=true时,可以对整个条目进行批量删除。 以下是个简单的例子:

  1. @CacheEvict(cacheNames="books")
  2. public void loadBooks(InputStream batch)
  3. //对cacheNames进行批量删除
  4. @CacheEvict(cacheNames="books", allEntries=true)
  5. public void loadBooks(InputStream batch) 

@Caching注解

@Caching:在使用缓存的时候,有可能会同时进行更新和删除,会出现同时使用多个注解的情况.而@Caching可以实现。 以下是个简单的例子:

  1. @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
  2. public Book importBooks(String deposit, Date date) 

@CacheConfig注解

@CacheConfig:缓存提供了许多的注解选项,但是有一些公用的操作,我们可以使用@CacheConfig在类上进行全局设置。 以下是个简单的例子:

  1. @CacheConfig("books")
  2. public class BookRepositoryImpl implements BookRepository {
  3. @Cacheable
  4. public Book findBook(ISBN isbn) {...}

可以共享缓存名称,统一配置KeyGenerator,CacheManager,CacheResolver。

实例

来看看我们在springboot中怎么使用redis来作为缓存吧.

为spring cache配置redis作为缓存

1.在pom.xml引入redis依赖

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency> 

2.springboot集成redis配置文件(在本地启动的redis),在springboot中使用redis,只要配置文件写有redis配置,代码就可以直接使用了。

  1. spring:
  2. redis:
  3. database: 0 # Database index used by the connection factory.
  4. 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
  5. host: 127.0.0.1 # Redis server host.
  6. password: # Login password of the redis server.
  7. port: 6379 # Redis server port.
  8. ssl: false # Whether to enable SSL support.
  9. timeout: 5000 # Connection timeout. 

3.redis缓存配置类CacheConfig,这里对spring的缓存进行了配置,包括KeyGenerator,CacheResolver,CacheErrorHandler,CacheManager,还有redis序列化方式。

  1. /**
  2. * @author wwj
  3. */
  4. @Configuration
  5. public class CacheConfig extends CachingConfigurerSupport {
  6. @Resource
  7. private RedisConnectionFactory factory;
  8. /**
  9. * 自定义生成redis-key
  10. *
  11. * @return
  12. */
  13. @Override
  14. @Bean
  15. public KeyGenerator keyGenerator() {
  16. return (o, method, objects) -> {
  17. StringBuilder sb = new StringBuilder();
  18. sb.append(o.getClass().getName()).append(".");
  19. sb.append(method.getName()).append(".");
  20. for (Object obj : objects) {
  21. sb.append(obj.toString());
  22. }
  23. System.out.println("keyGenerator=" + sb.toString());
  24. return sb.toString();
  25. };
  26. }
  27. @Bean
  28. public RedisTemplate<Object, Object> redisTemplate() {
  29. RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  30. redisTemplate.setConnectionFactory(factory);
  31. GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  32. redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
  33. redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
  34. redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  35. redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
  36. return redisTemplate;
  37. }
  38. @Bean
  39. @Override
  40. public CacheResolver cacheResolver() {
  41. return new SimpleCacheResolver(cacheManager());
  42. }
  43. @Bean
  44. @Override
  45. public CacheErrorHandler errorHandler() {
  46. // 用于捕获从Cache中进行CRUD时的异常的回调处理器。
  47. return new SimpleCacheErrorHandler();
  48. }
  49. @Bean
  50. @Override
  51. public CacheManager cacheManager() {
  52. RedisCacheConfiguration cacheConfiguration =
  53. defaultCacheConfig()
  54. .disableCachingNullValues()
  55. .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
  56. return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration).build();
  57. }

代码使用

测试@Cacheable方法

  1. @Test
  2. public void findUserTest() {
  3. for (int i = 0; i < 3; i++) {
  4. System.out.println("第" + i + "次");
  5. User user = userService.findUser();
  6. System.out.println(user);
  7. }
  8. }
  9. @Override
  10. @Cacheable(value = {"valueName", "valueName2"}, key = "'keyName1'")
  11. public User findUser() {
  12. System.out.println("执行方法...");
  13. return new User("id1", "张三", "深圳", "1234567", 18);

执行结果

只有一次输出了'执行方法...',后面直接从缓存获取,不会再进入方法。

  1. 第0次
  2. 执行方法...
  3. User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
  4. 第1次
  5. User{id='id1', name='张三', address='深圳', tel='1234567', age=18}
  6. 第2次
  7. User{id='id1', name='张三', address='深圳', tel='1234567', age=18}

 

测试@CachePut方法:对缓存进行了修改

  1. @Test
  2. public void updateUserTest() {
  3. userService.updateUser();
  4. User user = userService.findUser();
  5. System.out.println(user);
  6. }
  7. @Override
  8. @CachePut(value = "valueName", key = "'keyName1'")
  9. public User updateUser() {
  10. System.out.println("更新用户...");
  11. return new User("id1", "李四", "北京", "1234567", 18);

执行结果

对缓存进行了更新,获取值的时候取了新的值

  1. 更新用户...
  2. User{id='id1', name='李四', address='北京', tel='1234567', age=18}

 

 

测试@CacheEvict方法:缓存被清空,再次findUser的时候又重新执行了方法。

  1. @Test
  2. public void clearUserTest() {
  3. userService.clearUser();
  4. User user = userService.findUser();
  5. System.out.println(user);
  6. }
  7. @Override
  8. @CacheEvict(value = "valueName",allEntries = true)
  9. public void clearUser() {
  10. System.out.println("清除缓存...");

执行结果

这里清除了缓存,为什么还是没有执行方法呢?因为这个方法我们定了两个value值,清了一个还有一个

  1. 清除缓存...
  2. User{id='id1', name='张三', address='深圳', tel='1234567', age=18}

 

最后贴一下代码吧

User.java

  1. package com.wwj.springboot.model;
  2. import java.io.Serializable;
  3. /**
  4. * @author wwj
  5. */
  6. public class User implements Serializable {
  7. public User() {
  8. }
  9. private String id;
  10. private String name;
  11. private String address;
  12. private String tel;
  13. private Integer age;
  14. //省略get,set,tostring
  15. }

CacheTest.java

  1. package com.wwj.springboot.cache;
  2. import com.wwj.springboot.model.User;
  3. import com.wwj.springboot.service.UserService;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7. import org.springframework.cache.annotation.EnableCaching;
  8. import org.springframework.test.context.junit4.SpringRunner;
  9. import javax.annotation.Resource;
  10. /**
  11. * @author wwj
  12. */
  13. @RunWith(SpringRunner.class)
  14. @SpringBootTest
  15. @EnableCaching
  16. public class CacheTest {
  17. @Resource
  18. private UserService userService;
  19. @Test
  20. public void findUserTest() {
  21. for (int i = 0; i < 3; i++) {
  22. System.out.println("第" + i + "次");
  23. User user = userService.findUser();
  24. System.out.println(user);
  25. }
  26. }
  27. @Test
  28. public void updateUserTest() {
  29. userService.updateUser();
  30. User user = userService.findUser();
  31. System.out.println(user);
  32. }
  33. @Test
  34. public void clearUserTest() {
  35. userService.clearUser();
  36. User user = userService.findUser();
  37. System.out.println(user);
  38. }
  39. }

UserService.java

  1. package com.wwj.springboot.service;
  2. import com.wwj.springboot.model.User;
  3. import java.util.List;
  4. /**
  5. * @author wwj
  6. */
  7. public interface UserService {
  8. /**
  9. * 获取用户
  10. * @return user
  11. */
  12. User findUser();
  13. /**
  14. * 更新用户信息
  15. * @return user
  16. */
  17. User updateUser();
  18. /**
  19. * 清除缓存的用户信息
  20. */
  21. void clearUser();
  22. }

UserServiceImpl.java

  1. package com.wwj.springboot.service.impl;
  2. import com.wwj.springboot.model.User;
  3. import com.wwj.springboot.service.UserService;
  4. import org.springframework.cache.annotation.CacheConfig;
  5. import org.springframework.cache.annotation.CacheEvict;
  6. import org.springframework.cache.annotation.CachePut;
  7. import org.springframework.cache.annotation.Cacheable;
  8. import org.springframework.stereotype.Service;
  9. /**
  10. * @author wwj
  11. */
  12. @Service
  13. @CacheConfig(cacheNames = "CacheConfigName")
  14. public class UserServiceImpl implements UserService {
  15. @Override
  16. @Cacheable(value = {"valueName", "valueName2"}, key = "'keyName1'")
  17. public User findUser() {
  18. System.out.println("执行方法...");
  19. return new User("id1", "张三", "深圳", "1234567", 18);
  20. }
  21. @Override
  22. @CachePut(value = "valueName", key = "'keyName1'")
  23. public User updateUser() {
  24. System.out.println("更新用户...");
  25. return new User("id1", "李四", "北京", "1234567", 18);
  26. }
  27. @Override
  28. @CacheEvict(value = "valueName",allEntries = true)
  29. public void clearUser() {
  30. System.out.println("清除缓存...");
  31. }
  32. }
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/喵喵爱编程/article/detail/745026
推荐阅读
相关标签
  

闽ICP备14008679号