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命名的中间以"::"分隔

站在巨人肩膀上摘苹果

https://www.cnblogs.com/wenjunwei/p/10779450.html

# Java   Spring  

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×