SpringCache之本地缓存

针对不同的缓存技术，需要实现不同的cacheManager，Spring定义了如下的cacheManger实现。

常规的SpringBoot已经为我们自动配置了EhCache、Collection、Guava、ConcurrentMap等缓存，默认使用ConcurrentMapCacheManager。SpringBoot的application.properties配置文件，使用spring.cache前缀的属性进行配置。

使用

1.添加依赖

   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

2.添加配置类

2.1 ConcurrentMapCacheManager，

spring默认就是ConcurrentMapCache,如果不指定缓存名称，可以不加配置类，直接@EnableCaching写道启动类上

@EnableCaching
@Configuration
public class CacheConfig extends CachingConfigurerSupport {

    @Bean("ConcurrentMapCacheManager")
    @Primary
    public CacheManager caffeineCacheManager() {
        ConcurrentMapCacheManager concurrentMapCacheManager = new ConcurrentMapCacheManager();
        //可以事先指定chcheName
        //Collection<String> cacheNames = concurrentMapCacheManager.getCacheNames();
        //if (CollectionUtils.isEmpty(cacheNames)){
        //    集合
        //    concurrentMapCacheManager.setCacheNames();
        //}
        return concurrentMapCacheManager;
    }

}

2.2 caffeine

同理，如果不需要特殊参数，加入依赖后也可不写配置类

<!-- 使用  caffeine https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine -->
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.6.0</version>
        </dependency>

@EnableCaching
@Configuration
public class CacheConfig extends CachingConfigurerSupport {

    @Bean("caffeineCacheManager")
    @Primary
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        // 方案一(常用)：定制化缓存Cache
        cacheManager.setCaffeine(Caffeine.newBuilder()
                // 缓存项在写入后的过期时间为 5 分钟。
                .expireAfterWrite(5, TimeUnit.MINUTES)
                //设置缓存的初始容量为 100 个缓存项。
                .initialCapacity(100)
                //设置缓存的最大容量为 200 个缓存项。
                .maximumSize(200));
        return cacheManager;
    }
}

3.使用

主要基于Spring缓存注解@Cacheable、@CacheEvict、@CachePut的方式使用

1. @Cacheable ：改注解修饰的方法，若不存在缓存，则执行方法并将结果写入缓存；若存在缓存，则不执行方法，直接返回缓存结果。
2. @CachePut ：执行方法，更新缓存；该注解下的方法始终会被执行。
3. @CacheEvict ：删除缓存

3.1cacheable

调用这个方法的时候，会从缓存中查询，如果没有，查询数据库并将执行的结果存入缓存中，否则返回缓存中的对象。

@Component
public class UserCache {
    @Cacheable(cacheNames = "room", key = "#userId")
    public User getUserId(Interger userId){
        return queryuser();
    }
}

3.2 CachePut

主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用

@Component
public class UserCache {
    @CachePut(cacheNames = "room", key = "#result.deptId+':'+#userId")
    public User getUserId(String userId){
       return queryuser();
    }

}

3.3@CachEvict

主要针对方法配置，能够根据一定的条件对缓存进行清空

@Component
public class UserCache {

    @CacheEvict(cacheNames = "room")
    public User getUserId(String userId){
        return null;
    }

}

3.4 cacheManager的简单使用

//获取缓存
Cache user = cacheManager.getCache("room");
//获取所有缓存数据
User nativeCache = (User)user.getNativeCache();
//获取某个key的数据
Object o1 = user.get("1").get();
//存入数据
 user.putIfAbsent(Object var1, @Nullable Object var2);
 user.put(Object var1, @Nullable Object var2);
//清空数据
user.evictIfPresent("room");

spring cache源码

public interface Cache {
    String getName();

    Object getNativeCache();

    @Nullable
    ValueWrapper get(Object var1);

    @Nullable
    <T> T get(Object var1, @Nullable Class<T> var2);

    @Nullable
    <T> T get(Object var1, Callable<T> var2);

    void put(Object var1, @Nullable Object var2);

    @Nullable
    default ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
        ValueWrapper existingValue = this.get(key);
        if (existingValue == null) {
            this.put(key, value);
        }

        return existingValue;
    }

    void evict(Object var1);

    default boolean evictIfPresent(Object key) {
        this.evict(key);
        return false;
    }

    void clear();

    default boolean invalidate() {
        this.clear();
        return false;
    }

    public static class ValueRetrievalException extends RuntimeException {
        @Nullable
        private final Object key;

        public ValueRetrievalException(@Nullable Object key, Callable<?> loader, Throwable ex) {
            super(String.format("Value for key '%s' could not be loaded using '%s'", key, loader), ex);
            this.key = key;
        }

        @Nullable
        public Object getKey() {
            return this.key;
        }
    }

    @FunctionalInterface
    public interface ValueWrapper {
        @Nullable
        Object get();
    }
}

caffeine扩展的loadingCache

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.github.benmanes.caffeine.cache;

import java.util.Map;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

public interface LoadingCache<K, V> extends Cache<K, V> {
    @Nullable V get(@NonNull K var1);

    @NonNull Map<@NonNull K, @NonNull V> getAll(@NonNull Iterable<? extends @NonNull K> var1);

    void refresh(@NonNull K var1);
}