Spring Boot Cache使用方法整合_F11 - 专业站长和开发者的学习网站

分享到

Spring Boot Cache使用方法整合

java 来源：互联网搜集作者：秩名发布时间：2020-02-27 16:13:27 人浏览

摘要

使用本地Caffeine缓存引入依赖包 ? 1 2 3 4 5 6 7 8 9 dependency groupId org.springframework.boot/ groupId artifactId spring-boot-starter-cache/ artifactId / dependency dependency groupId com.github.ben-manes.caffeine/ groupId artifactId caf

使用本地Caffeine缓存

引入依赖包

			?

								<dependency>

								  <groupId>org.springframework.boot</groupId>

								  <artifactId>spring-boot-starter-cache</artifactId>

								</dependency>

								<dependency>

								  <groupId>com.github.ben-manes.caffeine</groupId>

								  <artifactId>caffeine</artifactId>

								  <version>2.6.2</version>

								</dependency>

自定义Caffeine配置

CachingConfig.java

			?

								package com.vcredit.vmp.checkcenter.config;

								import com.github.benmanes.caffeine.cache.Cache;

								import com.github.benmanes.caffeine.cache.Caffeine;

								import com.vcredit.vmp.checkcenter.common.properties.CaffeineCacheProperties;

								import org.springframework.beans.factory.annotation.Autowired;

								import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

								import org.springframework.cache.CacheManager;

								import org.springframework.cache.annotation.EnableCaching;

								import org.springframework.cache.caffeine.CaffeineCache;

								import org.springframework.cache.support.SimpleCacheManager;

								import org.springframework.context.annotation.Bean;

								import org.springframework.context.annotation.Configuration;

								import org.springframework.context.annotation.Primary;

								import java.time.Duration;

								import java.util.*;

								/**

								 * 缓存配置

								 * @author kancy

								 */

								@Configuration

								@EnableCaching

								public class CachingConfig {

								  @Autowired

								  CaffeineCacheProperties caffeineCacheProperties;

								  /**

								   * 创建基于Caffeine的Cache Manager

								   * @return

								   */

								  @Bean

								  @Primary

								  @ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")

								  public CacheManager caffeineCacheManager() {

								    SimpleCacheManager cacheManager = new SimpleCacheManager();

								    Map<String, CaffeineCache> cacheMap = new HashMap();

								    // 设置全局配置的本地缓存

								    List<String> globalCacheNames = caffeineCacheProperties.getCacheName();

								    if(globalCacheNames !=null && !globalCacheNames.isEmpty()){

								      addCacheObject(cacheMap, globalCacheNames, caffeineCacheProperties.getExpireAfterWrite(),

								          caffeineCacheProperties.getExpireAfterAccess(), caffeineCacheProperties.getMaximumSize());

								    }

								    // 设置自定义属性缓存, 可以覆盖全局缓存

								    List<CaffeineCacheProperties.Config> configs = caffeineCacheProperties.getConfigs();

								    if(configs != null && !configs.isEmpty()){

								      for (CaffeineCacheProperties.Config config : configs) {

								        List<String> cacheNames = config.getCacheName();

								        if (cacheNames == null || cacheNames.isEmpty()){

								          continue;

								        }

								        Duration expireAfterWrite = Optional.ofNullable(config.getExpireAfterWrite()).orElse(caffeineCacheProperties.getExpireAfterWrite());

								        Duration expireAfterAccess = Optional.ofNullable(config.getExpireAfterAccess()).orElse(caffeineCacheProperties.getExpireAfterAccess());

								        Long maximumSize = Optional.ofNullable(config.getMaximumSize()).orElse(caffeineCacheProperties.getMaximumSize());

								        addCacheObject(cacheMap, cacheNames, expireAfterWrite, expireAfterAccess, maximumSize);

								      }

								    }

								    // 加入到缓存管理器进行管理

								    cacheManager.setCaches(cacheMap.values());

								    return cacheManager;

								  }

								  private void addCacheObject(Map<String, CaffeineCache> cacheMap, List<String> cacheNames, Duration expireAfterWrite, Duration expireAfterAccess, Long maximumSize) {

								    for (String cacheName : cacheNames) {

								      // spring.cache.caffeine: maximumSize=500,expireAfterAccess=10s,expireAfterWrite=15s

								      Caffeine<Object, Object> recordStats = Caffeine.newBuilder().recordStats().maximumSize(maximumSize);

								      if(expireAfterAccess != null) recordStats.expireAfterAccess(expireAfterAccess);

								      if(expireAfterWrite != null) recordStats.expireAfterWrite(expireAfterWrite);

								      Cache<Object, Object> cache = recordStats.build();

								      CaffeineCache caffeineCache = new CaffeineCache(cacheName,cache);

								      // 覆盖添加

								      cacheMap.put(cacheName, caffeineCache);

								    }

								  }

								}

CaffeineCacheProperties.java

			?

								package com.vcredit.vmp.checkcenter.common.properties;

								import lombok.Getter;

								import lombok.Setter;

								import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

								import org.springframework.boot.context.properties.ConfigurationProperties;

								import org.springframework.context.annotation.Configuration;

								import java.time.Duration;

								import java.util.List;

								/**

								 * Caffeine本地缓存自定义配置

								 * @author kancy

								 */

								@Getter

								@Setter

								@Configuration

								@ConfigurationProperties("system.cache.caffeine")

								@ConditionalOnProperty(prefix = "system.cache.caffeine" , name = "enabled", havingValue = "true")

								public class CaffeineCacheProperties {

								  private List<String> cacheName;

								  private Duration expireAfterWrite;

								  private Duration expireAfterAccess;

								  private Long maximumSize = Long.valueOf(-1);

								  private List<Config> configs;

								  @Getter

								  @Setter

								  public static class Config {

								    private List<String> cacheName;

								    Duration expireAfterWrite;

								    Duration expireAfterAccess;

								    Long maximumSize;

								  }

								}

application.yml

			?

								system.cache.caffeine:

								 enabled: true

								 # 全局配置

								 cacheName: cache1,cache2,cache3

								 expireAfterWrite: 60s

								 expireAfterAccess: 30s

								 maximumSize: 500

								 # 自定义配置，cacheName相同可覆盖全局

								 configs:

								 - cacheName: checkApplyCache

								  expireAfterAccess: 10s

								 - cacheName: userQueryCache

								  expireAfterAccess: 15s

使用缓存

			?

								@Cacheable(value = { "checkApplyCache" }, key="#req.md5")

								public Result check(CheckReq req) {

								  // your code...

								  return Result.ok();

								}

您可能感兴趣的文章 :

原文链接 : https://www.cnblogs.com/kancy/p/11162950.html

Tag : spring(67)boot(13)Cache(3)

SpringBoot自定义错误处理逻辑介绍

1. 自定义错误页面将自定义错误页面放在 templates 的 error 文件夹下，SpringBoot 精确匹配错误信息，使用 4xx.html 或者 5xx.html 页面可以打印错误
Java实现手写一个线程池的代码

线程池技术想必大家都不陌生把，相信在平时的工作中没有少用，而且这也是面试频率非常高的一个知识点，那么大家知道它的实现原理和
Java实现断点续传功能的代码

题目实现：网络资源的断点续传功能。二、解题思路获取要下载的资源网址显示网络资源的大小上次读取到的字节位置以及未读取的字节
你可知HashMap为什么是线程不安全的

HashMap 的线程不安全 HashMap 的线程不安全主要体现在下面两个方面在 jdk 1.7 中，当并发执行扩容操作时会造成环形链和数据丢失的情况在
ArrayList的动态扩容机制的介绍

对于 ArrayList 的动态扩容机制想必大家都听说过，之前的文章中也谈到过，不过由于时间久远，早已忘却。所以利用这篇文章做做笔记，加
JVM基础之字节码的增强技术介绍

字节码增强技术在上文中，着重介绍了字节码的结构，这为我们了解字节码增强技术的实现打下了基础。字节码增强技术就是一类对现有字
Java中的字节码增强技术

1.字节码增强技术字节码增强技术就是一类对现有字节码进行修改或者动态生成全新字节码文件的技术。参考地址 2.常见技术技术分类类
Redis BloomFilter布隆过滤器原理与实现

Bloom Filter 概念布隆过滤器（英语：Bloom Filter）是1970年由一个叫布隆的小伙子提出的。它实际上是一个很长的二进制向量和一系列随机映射
Java C++算法题解leetcode801使序列递增的最小交换次

题目要求思路：状态机DP 实现一：状态机 Java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution { public int minSwap(int[] nums1, int[] nums2) { int n
Mybatis结果集映射与生命周期介绍

一、ResultMap结果集映射 1、设计思想对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了 2、resultMap的应用场