Caffeine instance analysis of SpringBoot integrated local cache performance-javaTutorial-php.cn

引言

使用缓存的目的就是提高性能，今天码哥带大家实践运用 spring-boot-starter-cache 抽象的缓存组件去集成本地缓存性能之王 Caffeine。

大家需要注意的是：in-memeory 缓存只适合在单体应用，不适合与分布式环境。

分布式环境的情况下需要将缓存修改同步到每个节点，需要一个同步机制保证每个节点缓存数据最终一致。

Spring Cache 是什么

不使用 Spring Cache 抽象的缓存接口，我们需要根据不同的缓存框架去实现缓存，需要在对应的代码里面去对应缓存加载、删除、更新等。

比如查询我们使用旁路缓存策略：先从缓存中查询数据，如果查不到则从数据库查询并写到缓存中。

伪代码如下：

public User getUser(long userId) {
    // 从缓存查询
    User user = cache.get(userId);
    if (user != null) {
        return user;
    }
    // 从数据库加载
    User dbUser = loadDataFromDB(userId);
    if (dbUser != null) {
        // 设置到缓存中
        cache.put(userId, dbUser)
    }
    return dbUser;
}

Copy after login

我们需要写大量的这种繁琐代码，Spring Cache 则对缓存进行了抽象，提供了如下几个注解实现了缓存管理：

@Cacheable：触发缓存读取操作，用于查询方法上，如果缓存中找到则直接取出缓存并返回，否则执行目标方法并将结果缓存。
@CachePut：触发缓存更新的方法上，与 Cacheable 相比，该注解的方法始终都会被执行，并且使用方法返回的结果去更新缓存，适用于 insert 和 update 行为的方法上。
@CacheEvict：触发缓存失效，删除缓存项或者清空缓存，适用于 delete 方法上。

除此之外，抽象的 CacheManager 既能集成基于本地内存的单体应用，也能集成 EhCache、Redis 等缓存服务器。

最方便的是通过一些简单配置和注解就能接入不同的缓存框架，无需修改任何代码。

集成 Caffeine

码哥带大家使用注解方式完成缓存操作的方式来集成，完整的代码请访问 github：在 pom.xml 文件添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

Copy after login

使用 JavaConfig 方式配置 CacheManager：

@Slf4j
@EnableCaching
@Configuration
public class CacheConfig {
    @Autowired
    @Qualifier("cacheExecutor")
    private Executor cacheExecutor;
    @Bean
    public Caffeine<Object, Object> caffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterAccess(7, TimeUnit.DAYS)
                // 初始的缓存空间大小
                .initialCapacity(500)
                // 使用自定义线程池
                .executor(cacheExecutor)
                .removalListener(((key, value, cause) -> log.info("key:{} removed, removalCause:{}.", key, cause.name())))
                // 缓存的最大条数
                .maximumSize(1000);
    }
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(caffeineCache());
        // 不缓存空值
        caffeineCacheManager.setAllowNullValues(false);
        return caffeineCacheManager;
    }
}

Copy after login

准备工作搞定，接下来就是如何使用了。

@Slf4j
@Service
public class AddressService {
    public static final String CACHE_NAME = "caffeine:address";
    private static final AtomicLong ID_CREATOR = new AtomicLong(0);
    private Map<Long, AddressDTO> addressMap;
    public AddressService() {
        addressMap = new ConcurrentHashMap<>();
        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址1").build());
        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址2").build());
        addressMap.put(ID_CREATOR.incrementAndGet(), AddressDTO.builder().customerId(ID_CREATOR.get()).address("地址3").build());
    }
    @Cacheable(cacheNames = {CACHE_NAME}, key = "#customerId")
    public AddressDTO getAddress(long customerId) {
        log.info("customerId：{} 没有走缓存，开始从数据库查询", customerId);
        return addressMap.get(customerId);
    }
    @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")
    public AddressDTO create(String address) {
        long customerId = ID_CREATOR.incrementAndGet();
        AddressDTO addressDTO = AddressDTO.builder().customerId(customerId).address(address).build();
        addressMap.put(customerId, addressDTO);
        return addressDTO;
    }
    @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")
    public AddressDTO update(Long customerId, String address) {
        AddressDTO addressDTO = addressMap.get(customerId);
        if (addressDTO == null) {
            throw new RuntimeException("没有 customerId = " + customerId + "的地址");
        }
        addressDTO.setAddress(address);
        return addressDTO;
    }
    @CacheEvict(cacheNames = {CACHE_NAME}, key = "#customerId")
    public boolean delete(long customerId) {
        log.info("缓存 {} 被删除", customerId);
        return true;
    }
}

Copy after login

使用 CacheName 隔离不同业务场景的缓存，每个 Cache 内部持有一个 map 结构存储数据，key 可用使用 Spring 的 Spel 表达式。

单元测试走起：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = CaffeineApplication.class)
@Slf4j
public class CaffeineApplicationTests {
    @Autowired
    private AddressService addressService;
    @Autowired
    private CacheManager cacheManager;
    @Test
    public void testCache() {
        // 插入缓存 和数据库
        AddressDTO newInsert = addressService.create("南山大道");
        // 要走缓存
        AddressDTO address = addressService.getAddress(newInsert.getCustomerId());
        long customerId = 2;
        // 第一次未命中缓存，打印 customerId：{} 没有走缓存，开始从数据库查询
        AddressDTO address2 = addressService.getAddress(customerId);
        // 命中缓存
        AddressDTO cacheAddress2 = addressService.getAddress(customerId);
        // 更新数据库和缓存
        addressService.update(customerId, "地址 2 被修改");
        // 更新后查询，依然命中缓存
        AddressDTO hitCache2 = addressService.getAddress(customerId);
        Assert.assertEquals(hitCache2.getAddress(), "地址 2 被修改");
        // 删除缓存
        addressService.delete(customerId);
        // 未命中缓存, 从数据库读取
        AddressDTO hit = addressService.getAddress(customerId);
        System.out.println(hit.getCustomerId());
    }
}

Copy after login

大家发现没，只需要在对应的方法上加上注解，就能愉快的使用缓存了。需要注意的是，设置的 cacheNames 一定要对应，每个业务场景使用对应的 cacheNames。

另外 key 可以使用 spel 表达式，大家重点可以关注 @CachePut(cacheNames = {CACHE_NAME}, key = "#result.customerId")，result 表示接口返回结果，Spring 提供了几个元数据直接使用。

名称	地点	描述	例子
methodName	根对象	被调用的方法的名称	#root.methodName
method	根对象	被调用的方法	#root.method.name
target	根对象	被调用的目标对象	#root.target
targetClass	根对象	被调用的目标的类	#root.targetClass
args	根对象	用于调用目标的参数（作为数组）	#root.args[0]
caches	根对象	运行当前方法的缓存集合	#root.caches[0].name
参数名称	评估上下文	任何方法参数的名称。如果名称不可用（可能是由于没有调试信息），则参数名称也可在#a where#arg代表参数索引（从开始0）下获得。	#iban或#a0（您也可以使用#p0或#p表示法作为别名）。
result	评估上下文	方法调用的结果（要缓存的值）。仅在unless 表达式、cache put表达式（计算key）或cache evict 表达式（when beforeInvocationis false）中可用。对于支持的包装器（例如 Optional），#result指的是实际对象，而不是包装器。	#result

Core Principles

Java Caching defines 5 core interfaces, namely CachingProvider, CacheManager, Cache, Entry and Expiry.

Caffeine instance analysis of SpringBoot integrated local cache performance

Core class diagram:

Caffeine instance analysis of SpringBoot integrated local cache performance

##Cache: abstracts cache operations, such as, get(), put();
CacheManager: manages Cache, which can be understood as collection management of Cache. The reason why there are multiple Cache is because different caches can be used according to different scenarios. Expiration time and quantity limit.
CacheInterceptor, CacheAspectSupport, AbstractCacheInvoker: CacheInterceptor is an AOP method interceptor that does additional logic before and after the method, such as query operations, checking the cache first, and then executing the method if the data is not found. And writes the results of the method to the cache, etc. It inherits CacheAspectSupport (the main logic of the cache operation) and AbstractCacheInvoker (encapsulates the reading and writing of the Cache).
CacheOperation, AnnotationCacheOperationSource, SpringCacheAnnotationParser: CacheOperation defines the cache name, cache key, cache condition, CacheManager, etc. of the cache operation. AnnotationCacheOperationSource is a class that obtains the cache annotation corresponding to CacheOperation, and SpringCacheAnnotationParser It is a class that parses annotations. After parsing, it will be encapsulated into a CacheOperation collection for AnnotationCacheOperationSource to find.

CacheAspectSupport: Cache aspect support class, the parent class of CacheInterceptor, encapsulates the main logic of all cache operations.

The main process is as follows:

Get all CacheOperation lists through CacheOperationSource
If there is @CacheEvict annotation and mark To execute before calling, delete/clear the cache
If there is @Cacheable annotation, query the cache
If the cache misses (The query result is null), it is added to cachePutRequests, and the original method will be written to the cache after subsequent execution.
When the cache hits, the cache value is used as the result; the cache misses, or there is When @CachePut is annotated, you need to call the original method and use the return value of the original method as the result
If there is @CachePut annotation, add it to cachePutRequests
If the cache misses, the query result value is written to the cache; if there is a @CachePut annotation, the method execution result is also written to the cache
If there is a @CacheEvict annotation, and If marked to be executed after the call, delete/clear the cache

The above is the detailed content of Caffeine instance analysis of SpringBoot integrated local cache performance. For more information, please follow other related articles on the PHP Chinese website!