SpringBoot将redis和spring-cache集成使用
spring基于注解的缓存
对于缓存声明，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的缓存名称是可以配置动态参数的，比如选择传入的参数,如下: (以下示例是使用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:取决于返回值是否满足条件
以下是一个简单的例子:
@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。
实例
来看看我们在springboot中怎么使用redis来作为缓存吧.
1.在pom.xml引入redis依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2.springboot集成redis配置文件(在本地启动的redis),在springboot中使用redis，只要配置文件写有redis配置，代码就可以直接使用了。
spring:
redis:
database: 0 # Database index used by the connection factory.
# Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379
url: redis://user:@127.0.0.1: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.
3.redis缓存配置类CacheConfig,这里对spring的缓存进行了配置，包括KeyGenerator,CacheResolver,CacheErrorHandler,CacheManager,还有redis序列化方式。
/**
* @author wwj
*/
@Configuration
public class CacheConfig extends CachingConfigurerSupport {
@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());
}
System.out.println("keyGenerator=" + sb.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());
}
@Bean
@Override
public CacheErrorHandler errorHandler() {
// 用于捕获从Cache中进行CRUD时的异常的回调处理器。
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();
}
}
自己配置
@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {
@Resource
private LettuceConnectionFactory lettuceConnectionFactory;
// /**
// * @description 自定义的缓存key的生成策略 若想使用这个key
// * 只需要讲注解上keyGenerator的值设置为keyGenerator即可</br>
// * @return 自定义策略生成的key
// */
// @Override
// @Bean
// public KeyGenerator keyGenerator() {
// return new KeyGenerator() {
// @Override
// public Object generate(Object target, Method method, Object... params) {
// StringBuilder sb = new StringBuilder();
// sb.append(target.getClass().getName());
// sb.append(method.getDeclaringClass().getName());
// Arrays.stream(params).map(Object::toString).forEach(sb::append);
// return sb.toString();
// }
// };
// }
/**
* RedisTemplate配置
*
* @param lettuceConnectionFactory
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
// 设置序列化
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
om.enableDefaultTyping(DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置redisTemplate
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(lettuceConnectionFactory);
RedisSerializer<?> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer);// key序列化
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 缓存配置管理器
*
* @param factory
* @return
*/
@Bean
public CacheManager cacheManager(LettuceConnectionFactory factory) {
// 配置序列化（缓存默认有效期 6小时）
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(6));
RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
// 以锁写入的方式创建RedisCacheWriter对象
//RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
// 创建默认缓存配置对象
/* 默认配置，设置缓存有效期 1小时*/
//RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1));
/* 自定义配置test:demo 的超时时间为 5分钟*/
RedisCacheManager cacheManager = RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(factory)).cacheDefaults(redisCacheConfiguration)
.withInitialCacheConfigurations(singletonMap(CacheConstant.TEST_DEMO_CACHE, RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(5)).disableCachingNullValues()))
.transactionAware().build();
return cacheManager;
}
}
使用缓存
public static final String APP_QUERY_GOODS = "app:machineList:goods";
@ApiOperation(value = "神器榜单--查询关联关系及商品", notes = "查询关联关系及商品")
@ApiImplicitParam(name = "inputVO", value = "查询商品模板(goodsId不用填写,首次查询使用category和typeTagFirst,点击一级标签查询传递category和typeTagFirst和typeTagSecond)", required = true, dataType = "GoodsModelRelatedInputVO")
@PostMapping("queryGoodsModels")
@Cacheable(value = Constants.APP_QUERY_GOODS, key = "'ZJ-'+#inputVO.getCategory()+':machineList-'+#inputVO.getTypeTagFirst()+':firstTag-'+#inputVO.getTypeTagSecond()")
public WebResult queryGoodsModels(@RequestBody @Valid GoodsModelRelatedInputVO inputVO) {
List<TreeModel> list = relatedService.queryGoodsModels(inputVO);
return WebResult.getInstance().success(list);
}
清除缓存
@ApiOperation(value = "类型标签模板--根据标识查询类型", notes = "根据标识查询类型")
@ApiImplicitParam(name = "typeTags", value = "TypeTag数组", required = true, dataType = "TypeTag")
@PostMapping("addTypeTagModel")
@CacheEvict(value = Constants.APP_QUERY_GOODS,allEntries = true)
public WebResult addTypeTagModel(@RequestBody List<TypeTag> typeTags) {
typeTagModelService.addTypeTagModel(typeTags);
return WebResult.getInstance().operateSuccess();
}
@ApiOperation(value = "类型标签模板--删除模板", notes = "删除模板")
@ApiImplicitParam(name = "inputVO", value = "删除模板inputVO", required = true, dataType = "TypeTagModelInputVO")
@PostMapping("deleteTypeTagModel")
@CacheEvict(value = Constants.APP_QUERY_GOODS,allEntries = true)
public WebResult deleteTypeTagModel(@RequestBody @Valid TypeTagModelDelInputVO inputVO) {
Boolean flag = typeTagModelService.deleteTypeTagModel(inputVO);
return WebResult.getInstance().operateSuccess();
}
@ApiOperation(value = "类型标签模板--在模板下新增商品", notes = "在模板下新增商品")
@ApiImplicitParam(name = "goodsModelRelated", value = "商品实体", required = true, dataType = "GoodsModelRelated")
@PostMapping("insertGoodsModelRelated")
@CacheEvict(value = Constants.APP_QUERY_GOODS,allEntries = true)
public WebResult insertGoodsModelRelated(@RequestBody @Valid List<GoodsModelRelated> goodsModelRelateds) {
relatedService.insertGoodsModelRelatedBatch(goodsModelRelateds);
return WebResult.getInstance().operateSuccess();
}
@ApiOperation(value = "类型标签模板--在模板下删除商品", notes = "在模板下删除商品")
@DeleteMapping("deleteGoodsModelRelatedBatch")
@CacheEvict(value = Constants.APP_QUERY_GOODS,allEntries = true)
public WebResult deleteGoodsModelRelatedBatch(@RequestBody @Valid @ApiParam(name = "ids", value = "商品关联记录的自增ids", required = true)List<Long> ids) {
relatedService.deleteGoodsModelRelatedBatch(ids);
return WebResult.getInstance().operateSuccess();
}
说明
在查询的时候将数据进行缓存,在进行数据更改的时候,根据 APP_QUERY_GOODS = "app:machineList:goods"名字将此名字下缓存的数据删掉
APP_QUERY_GOODS的命名使用":"分隔,"app:machineList:goods"在rdm中查看的时候就是三个层级
app第一层级,machineList第二层级,goods第三层级
然后后面会以key命名的规则添加
value命名的和key命名的中间以"::"分隔
