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:[email protected]: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 = https://www.cnblogs.com/eternityz/p/"神器榜單--查詢關聯關系及商品", 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 = https://www.cnblogs.com/eternityz/p/"型別標簽模板--根據標識查詢型別", 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 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 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 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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/27414.html

標籤：Java

上一篇：LeetCode–青蛙跳臺階問題

下一篇：LeetCode–旋轉陣列的最小數字

SpringBoot將redis和spring-cache集成使用