Spring之Cache缓存详解

最新推荐文章于 2023-07-18 19:43:21 发布
最新推荐文章于 2023-07-18 19:43:21 发布
阅读量5.5k 收藏 4
点赞数 2
分类专栏： spring 文章标签： spring 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1309664161/article/details/120381708
版权

前言

Spring的Cache缓存类似于java的JDBC。是定义了一套规范。第三方缓存需要实现这套规范，才能通过Spring API使用缓存功能。这套规范的核心接口是CacheManager和Cache。其中，CacheMananger是获取Cache的入口。Cache是实现缓存逻辑的接口。下面具体看这两个接口。

CacheManager

我们先看其源码:

public interface CacheManager {

	/**
	 * Get the cache associated with the given name.
	 * <p>Note that the cache may be lazily created at runtime if the
	 * native provider supports it.
	 * @param name the cache identifier (must not be {@code null})
	 * @return the associated cache, or {@code null} if such a cache
	 * does not exist or could be not created
	 */
	@Nullable
	Cache getCache(String name);

	/**
	 * Get a collection of the cache names known by this manager.
	 * @return the names of all caches known by the cache manager
	 */
	Collection<String> getCacheNames();

}

可以看到，接口中定义了两个方法，getCache方法是根据指定的名称返回缓存对象。getCacheNames方法是返回缓存管理器中所有的缓存对象。由此可知缓存管理器的作用就是获取到缓存对象。

Spring为我们提供了最简单的CacheManager实现类ConcurrentMapCacheManager。我们看其实现方式。

public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {

	private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);

	private boolean dynamic = true;

	private boolean allowNullValues = true;

	private boolean storeByValue = false;

	@Nullable
	private SerializationDelegate serialization;


	/**
	 * Construct a dynamic ConcurrentMapCacheManager,
	 * lazily creating cache instances as they are being requested.
	 */
	public ConcurrentMapCacheManager() {
	}

	/**
	 * Construct a static ConcurrentMapCacheManager,
	 * managing caches for the specified cache names only.
	 */
	public ConcurrentMapCacheManager(String... cacheNames) {
		setCacheNames(Arrays.asList(cacheNames));
	}


	/**
	 * Specify the set of cache names for this CacheManager's 'static' mode.
	 * <p>The number of caches and their names will be fixed after a call to this method,
	 * with no creation of further cache regions at runtime.
	 * <p>Calling this with a {@code null} collection argument resets the
	 * mode to 'dynamic', allowing for further creation of caches again.
	 */
	public void setCacheNames(@Nullable Collection<String> cacheNames) {
		if (cacheNames != null) {
			for (String name : cacheNames) {
				this.cacheMap.put(name, createConcurrentMapCache(name));
			}
			this.dynamic = false;
		}
		else {
			this.dynamic = true;
		}
	}

	/**
	 * Specify whether to accept and convert {@code null} values for all caches
	 * in this cache manager.
	 * <p>Default is "true", despite ConcurrentHashMap itself not supporting {@code null}
	 * values. An internal holder object will be used to store user-level {@code null}s.
	 * <p>Note: A change of the null-value setting will reset all existing caches,
	 * if any, to reconfigure them with the new null-value requirement.
	 */
	public void setAllowNullValues(boolean allowNullValues) {
		if (allowNullValues != this.allowNullValues) {
			this.allowNullValues = allowNullValues;
			// Need to recreate all Cache instances with the new null-value configuration...
			recreateCaches();
		}
	}

	/**
	 * Return whether this cache manager accepts and converts {@code null} values
	 * for all of its caches.
	 */
	public boolean isAllowNullValues() {
		return this.allowNullValues;
	}

	/**
	 * Specify whether this cache manager stores a copy of each entry ({@code true}
	 * or the reference ({@code false} for all of its caches.
	 * <p>Default is "false" so that the value itself is stored and no serializable
	 * contract is required on cached values.
	 * <p>Note: A change of the store-by-value setting will reset all existing caches,
	 * if any, to reconfigure them with the new store-by-value requirement.
	 * @since 4.3
	 */
	public void setStoreByValue(boolean storeByValue) {
		if (storeByValue != this.storeByValue) {
			this.storeByValue = storeByValue;
			// Need to recreate all Cache instances with the new store-by-value configuration...
			recreateCaches();
		}
	}

	/**
	 * Return whether this cache manager stores a copy of each entry or
	 * a reference for all its caches. If store by value is enabled, any
	 * cache entry must be serializable.
	 * @since 4.3
	 */
	public boolean isStoreByValue() {
		return this.storeByValue;
	}

	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
		this.serialization = new SerializationDelegate(classLoader);
		// Need to recreate all Cache instances with new ClassLoader in store-by-value mode...
		if (isStoreByValue()) {
			recreateCaches();
		}
	}


	@Override
	public Collection<String> getCacheNames() {
		return Collections.unmodifiableSet(this.cacheMap.keySet());
	}

	@Override
	@Nullable
	public Cache getCache(String name) {
		Cache cache = this.cacheMap.get(name);
		if (cache == null && this.dynamic) {
			synchronized (this.cacheMap) {
				cache = this.cacheMap.get(name);
				if (cache == null) {
					cache = createConcurrentMapCache(name);
					this.cacheMap.put(name, cache);
				}
			}
		}
		return cache;
	}

	private void recreateCaches() {
		for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) {
			entry.setValue(createConcurrentMapCache(entry.getKey()));
		}
	}

	/**
	 * Create a new ConcurrentMapCache instance for the specified cache name.
	 * @param name the name of the cache
	 * @return the ConcurrentMapCache (or a decorator thereof)
	 */
	protected Cache createConcurrentMapCache(String name) {
		SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256), isAllowNullValues(), actualSerialization);
	}

}

由源码可以看到，该缓存管理器中通过CurrentHashMap存放着name和Cache对象。通过name获取Cache对象其实就是获取Map对象中的value值。Cache对象也是用的Spring提供的ConcurrentMapCache对象。该对象内部，也是由CurrentMap对象存放缓存数据。由此可知，Spring为我们提供了一个Map形式的缓存。所以在做一些小项目时，可以使用这个简单的缓存管理器来存储缓存。
我们也可以自定义缓存管理器，获取缓存对象，不过像redis这样的厂商已经为我们提供了相应的实现类，所以一般情况下我们无需进行自定义。

Cache接口

public interface Cache {
 
	/**
	 * Return the cache name.
	 */
	String getName();
 
	/**
	 * Return the underlying native cache provider.
	 */
	Object getNativeCache();
 
	//获取缓存的主要方法
	@Nullable
	ValueWrapper get(Object key);
 
	
	@Nullable
	<T> T get(Object key, @Nullable Class<T> type);
 
	
	@Nullable
	<T> T get(Object key, Callable<T> valueLoader);
 
	//添加缓存的主要方法
	void put(Object key, @Nullable Object value);
 
	
	@Nullable
	default ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
		ValueWrapper existingValue = get(key);
		if (existingValue == null) {
			put(key, value);
		}
		return existingValue;
	}
	void evict(Object key);
 
	default boolean evictIfPresent(Object key) {
		evict(key);
		return false;
	}
 
	void clear();
 
	
	default boolean invalidate() {
		clear();
		return false;
	}
 
 
	
	@FunctionalInterface
	interface ValueWrapper {
		@Nullable
		Object get();
	}
 
	@SuppressWarnings("serial")
	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;
		}
	}
 
}
cache的自定义实现类

public class MapCaffeCache implements Cache {
 
//	private ConcurrentMapCache mapCache = new ConcurrentMapCache("mapCache");
 
	private com.github.benmanes.caffeine.cache.@NonNull Cache<Object, Object> mapCache = Caffeine.newBuilder()
			.expireAfterWrite(5, TimeUnit.SECONDS).expireAfterAccess(5, TimeUnit.SECONDS).maximumSize(5).build();
	private com.github.benmanes.caffeine.cache.@NonNull Cache<Object, Object> caffeCache = Caffeine.newBuilder()
			.expireAfterWrite(1, TimeUnit.MINUTES).expireAfterAccess(1, TimeUnit.MINUTES).maximumSize(100).build();
 
	@Autowired
	private StringRedisTemplate redisTemplate;
 
	private String name = "userCache";
 
	@Override
	public String getName() {
		return this.name;
	}
 
	@Override
	public Object getNativeCache() {
		return this;
	}
 
	@Override
	public ValueWrapper get(Object key) {
 
		@Nullable
		Object ob = mapCache.getIfPresent(key);
		// 如果一级缓存有数据 直接返回 不触发二级缓存
		if (ob != null) {
			System.out.println(String.format("Cache L1 (CaffeineCache) :: %s = %s", key, ob));
			SimpleValueWrapper valueWrapper = new SimpleValueWrapper(ob);
			return valueWrapper;
		}
 
		Object obj = caffeCache.getIfPresent(key);
		if (obj != null) {
			SimpleValueWrapper valueWrapper2 = new SimpleValueWrapper(obj);
			System.out.println(String.format("Cache L2 (CaffeineCache) :: %s = %s", key, obj));
			// 如果二级缓存有数据 则更新到一级缓存
			mapCache.put(key, obj);
			return valueWrapper2;
		}
		return null;
	}
 
	@Override
	public <T> T get(Object key, Class<T> type) {
		return (T) get(key).get();
	}
 
	@Override
	public <T> T get(Object key, Callable<T> valueLoader) {
		return (T) get(key).get();
	}
 
	@Override
	public void put(Object key, Object value) {
		mapCache.put(key, value);
		caffeCache.put(key, value);
		//当nginx搭建集群时 用redis 订阅/发布 功能同步各项目点的缓存一致性
		redisTemplate.convertAndSend("ch1", key + ":>" + value);
	}
 
	@Override
	public void evict(Object key) {
		mapCache.asMap().remove(key);
		caffeCache.asMap().remove(key);
	}
 
	@Override
	public void clear() {
		mapCache.asMap().clear();
		caffeCache.asMap().clear();
	}
 
}

可以看到，接口中定义了put,get等方法，就是在往缓存中存放和取值。该接口就是往各自的第三方缓存中进行存值和取值的规范。这个接口我们一般也不用自定义实现，也是由第三方缓存厂商进行实现。
并且，Cache中存缓存和取缓存的方法，也无需我们自己调用。Spring在缓存切面中，会进行这些方法的调用。所以，使用Spring的缓存，为我们省去了存取缓存的代码。

@Cacheable注解

缓存管理器和缓存对象都有了，Spring是如何进行缓存的存取的呢，这就涉及到我们使用者使用的@Cacheable注解了。
我们在方法上用@Cacheable注解进行修饰，Spring AOP生成代理对象，当调用方法时，代理对象判断是否有缓存，有缓存则调用缓存，不再调用目标方法，没有缓存，则调用目标方法，且将返回值存入缓存中。
@Cacheable的具体用法，请看@Cacheable详解

缓存配置流程

1.使用@EnableCaching注解开启缓存功能。
2.配置CacheManager类
3.配置Cache类
4.使用@Cacheable注解修饰要缓存的方法。

敲代码的小小酥
关注
专栏目录
Spring ： ConcurrentMapCacheManager
九师兄
07-04 1170
1.美图 2.概述 3.源码 public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware { // 所有的cache组件都是有名字的 private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentH...
Spring Boot 3.x 系列【25】Spring Cache缓存技术使用详解
记录知识、锤炼自我
04-14 906
在实际开发中，最常见的就是**数据库缓存**，将热点的数据保存在缓存中，减少数据库的查询，不仅能减轻数据库压力，更能提升响应速度。 如何去实现**缓存**，目前也有很多种策略，最常用的就是`Cache-Aside `（边缘缓存模式），适用于读多写少的业务场景，当然关于数据一致性的问题这里不讨论。
SpringCache
weixin_42412601的博客
08-27 1504
目录简介整合SpringCache简化缓存开发@Cacheable使用原理自定义缓存配置@CacheEvict的使用SpringCache的不足 简介 给每一个需要缓存的业务加上缓存的使用逻辑。 缓存的使用，就得考虑缓存的两种用法模式 读模式：先从缓存中读取，缓存没有，在从数据库中读取，并把数据放到缓存中，然后返回数据 写模式：如何保证缓存与数据库中的数据是一致的？可以使用双写模式或者失效模式 双写模式：写完数据库，缓存跟着改一下 失效模式: 写完数据库，对应的缓存删了，等待下次主动查询，更新缓存即可
SpringCache通用缓存学习
软件开发实战项目分享
05-23 516
Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能，大大简化我们在业务中操作缓存的代码。 Spring Cache只是提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。
springcache
ss123mlk的博客
04-25 99
分布式锁有单独的框架去做 但面对不同的缓存 spring应该如何对接 缓存功能大体相似 spring可否有一套框架操作不同的缓存 就像jdbc操作所有的数据库 要想通过一个框架去应对所有的缓存模式 缓存管理器 按照业务来划分缓存的区 以后想要删除所有薪水相关的缓存 就删除这一个区就好了 要有面向不同缓存模式的 动态生成配置类管理器的 代码CacheAutoConfiguration 然后动态的去生成对应的选择的缓存模式 这样就可以操作无限种缓存 只要实现缓存管理器接口 然后生成对应的配置类
Spring Cache
weixin_47109902的博客
01-02 516
Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单的添加一个注解，就可以实现缓存功能Spring Cache提供了一层抽象，底层可以切换不同的Cache来实现。具体就是通过CacheManager接口来统一不同的缓存技术CacheManager是Spring提供的各种缓存技术的抽象接口。
Spring Boot集成Spring Cache过程详解
08-25
Spring Boot集成Spring Cache过程详解介绍了如何使用Spring Boot框架集成Spring Cache来实现缓存机制。通过使用Spring Cache，可以提高应用程序的性能和效率，减少数据库的负载，提高应用程序的可扩展性。
Spring Cache的基本使用与实现原理详解
08-27
Spring Cache 是Spring框架提供的一种缓存抽象，从Spring 3.1版本开始引入，目的是为了简化应用程序中的缓存管理，实现缓存透明化。通过在方法上添加特定注解，如@Cacheable、@CacheEvict等，可以轻松地启用缓存功能...
【分布式缓存】springboot整合jetcache使用详解
最新发布
congge
07-18 5626
springboot整合jetcache使用详解
Spring 缓存抽象示例详解
08-27
Spring提供了如`RedisCache`、`EhCacheCache`和`ConcurrentMapCache`等不同实现来适配不同的缓存系统。而`CacheManager`接口则作为缓存的管理者，负责创建和管理`Cache`实例，它可以根据配置动态地选择合适的缓存...
MyBatis3---动态SQL和缓存
Srwici的博客
09-14 131
目录12 动态SQL12.1 创建数据库环境12.2 创建一个基础工厂12.3 if12.4 choose(when otherwise)12.5 trim(where set) 12 动态SQL 什么是动态SQL? 动态SQL就是指根据不同的条件生成不同的SQL语句。 官方描述：用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了
Spring Data Redis 实现数据缓存详解
Spring框架从3.1版本开始引入了Cache抽象，即Spring Cache，它提供了一套通用的缓存注解，如@Cacheable、@CachePut、@CacheEvict和@Caching。这些注解可以直接应用在方法上，使得缓存管理变得简单。 - @Cacheable：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

敲代码的小小酥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值