【深入理解MyBatis】- 10Mybatis 缓存Cache实现

最新推荐文章于 2022-10-23 09:17:59 发布
最新推荐文章于 2022-10-23 09:17:59 发布
阅读量233 收藏
点赞数
分类专栏： 深入理解MyBatis
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/108616644
版权 
### 概述

Mybatis 缓存Cache是自己实现的，采用了简单+扩展性极强的装饰者模式实现，下图为缓存Cache实现体系
在这里插入图片描述

Cache实现

缓存Cache统一接口，由于实现是基于Map实现的，提供的方法名称基本上与Map接口一致

public interface Cache {

	/**
	 * @return 标识
	 */
	String getId();

	void putObject(Object key, Object value);

	Object getObject(Object key);

	Object removeObject(Object key);

	void clear();

	int getSize();

	/**
	 * 暂未使用
	 */
	ReadWriteLock getReadWriteLock();

}
PerpetualCache

PerpetualCache 缓存实现，基于HashMap

public class PerpetualCache implements Cache {

	private final String id;

	private Map<Object, Object> cache = new HashMap<Object, Object>();

	public PerpetualCache(String id) {
		this.id = id;
	}

	@Override
	public String getId() {
		return id;
	}

	@Override
	public int getSize() {
		return cache.size();
	}

	@Override
	public void putObject(Object key, Object value) {
		cache.put(key, value);
	}

	@Override
	public Object getObject(Object key) {
		return cache.get(key);
	}

	@Override
	public Object removeObject(Object key) {
		return cache.remove(key);
	}

	@Override
	public void clear() {
		cache.clear();
	}

	@Override
	public ReadWriteLock getReadWriteLock() {
		return null;
	}

	@Override
	public boolean equals(Object o) {
		if (getId() == null) {
			throw new CacheException("Cache instances require an ID.");
		}
		if (this == o) {
			return true;
		}
		if (!(o instanceof Cache)) {
			return false;
		}

		Cache otherCache = (Cache) o;
		return getId().equals(otherCache.getId());
	}

	@Override
	public int hashCode() {
		if (getId() == null) {
			throw new CacheException("Cache instances require an ID.");
		}
		return getId().hashCode();
	}

}

测试

public class PerpetualCacheTest_Copy {

	@Test
	public void shouldDemonstrateHowAllObjectsAreKept() {
		Cache cache = new PerpetualCache("default");
		for (int i = 0; i < 100000; i++) {
			cache.putObject(i, i);
			assertEquals(i, cache.getObject(i));
		}
		assertEquals(100000, cache.getSize());
	}

	@Test
	public void shouldRemoveItemOnDemand() {
		Cache cache = new PerpetualCache("default");
		cache.putObject(0, 0);
		assertNotNull(cache.getObject(0));
		cache.removeObject(0);
		assertNull(cache.getObject(0));
	}

	@Test
	public void shouldFlushAllItemsOnDemand() {
		Cache cache = new PerpetualCache("default");
		for (int i = 0; i < 5; i++) {
			cache.putObject(i, i);
		}
		assertNotNull(cache.getObject(0));
		assertNotNull(cache.getObject(4));
		cache.clear();
		assertNull(cache.getObject(0));
		assertNull(cache.getObject(4));
	}

}

最基础的缓存功能，基于HashMap实现，为什么要定义属性String id，通过一个测试类明白Mybatis设计

public class PerpetualCacheTest_Copy2 {

	public static class MybatisConfiguration {
		protected final Map<String, Cache> caches = new HashMap<>();

		public void addCache(Cache cache) {
			caches.put(cache.getId(), cache);
		}

		public Collection<String> getCacheNames() {
			return caches.keySet();
		}

		public Collection<Cache> getCaches() {
			return caches.values();
		}

		public Cache getCache(String id) {
			return caches.get(id);
		}

		public boolean hasCache(String id) {
			return caches.containsKey(id);
		}
	}
	
	@Test
	public void mybatisCacheImpl() {
		MybatisConfiguration configuration = new MybatisConfiguration();
		
		Cache shopCache = new PerpetualCache("shop");
		for (int i = 0; i < 5; i++) {
			shopCache.putObject(i, i);
		}
		configuration.addCache(shopCache);
		
		Cache productCache = new PerpetualCache("product");
		for (int i = 10; i < 25; i++) {
			productCache.putObject(i, i);
		}
		configuration.addCache(productCache);
		
		assertTrue(configuration.hasCache("shop"));
		assertFalse(configuration.hasCache("store"));

		Cache cache = configuration.getCache("shop");
		assertEquals(0, cache.getObject(0));
		assertEquals(5, cache.getSize());
	}
}

我们可以看出id是为了区分不同的缓存，等于是一个分层处理

FifoCache

先进先出缓存Cache，设置缓存大小SITE，当缓存容量达到最大值SITE，需就先将remove缓存中的数据，再 put新数据。这里是基于Java中提供的双向队列Deque容器来实现，需要依赖于其addLast和removeFirst方法

public class FifoCache implements Cache {

	private final Cache delegate;
	private final Deque<Object> keyList;
	private int size;

	public FifoCache(Cache delegate) {
		this.delegate = delegate;
		this.keyList = new LinkedList<Object>();
		this.size = 1024;
	}

	@Override
	public String getId() {
		return delegate.getId();
	}

	@Override
	public int getSize() {
		return delegate.getSize();
	}

	public void setSize(int size) {
		this.size = size;
	}

	@Override
	public void putObject(Object key, Object value) {
		cycleKeyList(key);
		delegate.putObject(key, value);
	}

	@Override
	public Object getObject(Object key) {
		return delegate.getObject(key);
	}

	@Override
	public Object removeObject(Object key) {
		return delegate.removeObject(key);
	}

	@Override
	public void clear() {
		delegate.clear();
		keyList.clear();
	}

	@Override
	public ReadWriteLock getReadWriteLock() {
		return null;
	}

	private void cycleKeyList(Object key) {
		keyList.addLast(key);
		if (keyList.size() > size) {
			Object oldestKey = keyList.removeFirst();
			delegate.removeObject(oldestKey);
		}
	}

}

测试

public class FifoCacheTest {

	@Test
	public void shouldRemoveFirstItemInBeyondFiveEntries() {
		FifoCache cache = new FifoCache(new PerpetualCache("default"));
		cache.setSize(5);
		for (int i = 0; i < 5; i++) {
			cache.putObject(i, i);
		}
		assertNull(cache.getObject(5));
		cache.putObject(5, 5);
		assertNull(cache.getObject(0));
		assertEquals(5, cache.getSize());
		assertEquals(5, cache.getObject(5));
	}

	@Test
	public void shouldRemoveItemOnDemand() {
		FifoCache cache = new FifoCache(new PerpetualCache("default"));
		cache.putObject(0, 0);
		assertNotNull(cache.getObject(0));
		cache.removeObject(0);
		assertNull(cache.getObject(0));
	}

	@Test
	public void shouldFlushAllItemsOnDemand() {
		FifoCache cache = new FifoCache(new PerpetualCache("default"));
		for (int i = 0; i < 5; i++) {
			cache.putObject(i, i);
		}
		assertNotNull(cache.getObject(0));
		assertNotNull(cache.getObject(4));
		cache.clear();
		assertNull(cache.getObject(0));
		assertNull(cache.getObject(4));
	}

}
LruCache

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

基于LinkedHashMap实现

public class LruCache implements Cache {

	private final Cache delegate;
	private Map<Object, Object> keyMap;
	private Object eldestKey;

	public LruCache(Cache delegate) {
		this.delegate = delegate;
		setSize(1024);
	}

	@Override
	public String getId() {
		return delegate.getId();
	}

	@Override
	public int getSize() {
		return delegate.getSize();
	}

	public void setSize(final int size) {
		keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
			private static final long serialVersionUID = 4267176411845948333L;

			@Override
			protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
				boolean tooBig = size() > size;
				if (tooBig) {
					eldestKey = eldest.getKey();
				}
				return tooBig;
			}
		};
	}
SoftCache

基于java 软连接实现缓存

public class SoftCache implements Cache {
	private final Deque<Object> hardLinksToAvoidGarbageCollection;
	private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
	private final Cache delegate;
	private int numberOfHardLinks;

	public SoftCache(Cache delegate) {
		this.delegate = delegate;
		this.numberOfHardLinks = 256;
		this.hardLinksToAvoidGarbageCollection = new LinkedList<Object>();
		this.queueOfGarbageCollectedEntries = new ReferenceQueue<Object>();
	}

	@Override
	public String getId() {
		return delegate.getId();
	}

	@Override
	public int getSize() {
		removeGarbageCollectedItems();
		return delegate.getSize();
	}

	public void setSize(int size) {
		this.numberOfHardLinks = size;
	}

	@Override
	public void putObject(Object key, Object value) {
		removeGarbageCollectedItems();
		delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries));
	}

	@Override
	public Object getObject(Object key) {
		Object result = null;
		@SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache
		SoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);
		if (softReference != null) {
			result = softReference.get();
			if (result == null) {
				delegate.removeObject(key);
			} else {
				// See #586 (and #335) modifications need more than a read lock
				synchronized (hardLinksToAvoidGarbageCollection) {
					hardLinksToAvoidGarbageCollection.addFirst(result);
					if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
						hardLinksToAvoidGarbageCollection.removeLast();
					}
				}
			}
		}
		return result;
	}

	@Override
	public Object removeObject(Object key) {
		removeGarbageCollectedItems();
		return delegate.removeObject(key);
	}

	@Override
	public void clear() {
		synchronized (hardLinksToAvoidGarbageCollection) {
			hardLinksToAvoidGarbageCollection.clear();
		}
		removeGarbageCollectedItems();
		delegate.clear();
	}

	@Override
	public ReadWriteLock getReadWriteLock() {
		return null;
	}

	private void removeGarbageCollectedItems() {
		SoftEntry sv;
		while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {
			delegate.removeObject(sv.key);
		}
	}

	private static class SoftEntry extends SoftReference<Object> {
		private final Object key;

		SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {
			super(value, garbageCollectionQueue);
			this.key = key;
		}
	}

}

其他的就不分析了，有兴趣的自己看看

dengjili
关注
专栏目录
带你彻底搞懂MyBatis的底层实现之缓存模块(Cache)-吊打面试官必备技能
波波烤鸭的博客
05-28 1310
  基础支持层位于MyBatis整体架构的最底层，支撑着MyBatis的核心处理层，是整个框架的基石。基础支持层中封装了多个较为通用的、独立的模块。不仅仅为MyBatis提供基础支撑，也可以在合适的场景中直接复用。   上篇文章我们给大家聊了下binding模块，本篇文章我们重点来聊下缓存(Cache)模块。 缓存模块   MyBatis作为一个强大的持久层框架，缓存是其必不可少的功能之一，Mybatis中的缓存分为一级缓存和二级缓存。但本质上是一样的，都是使用Cache接口实现的。缓存位于 org.ap
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
热门推荐
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
深入浅出Mybatis-改造Cache
追求极致的人
11-25 1万+
在前面的文章里，我开发了两个插件：根据注解实现的sql自动生成插件和分页插件。这两个插件在没有开启cache的情况下可以很好的使用，但开启cache后却出现了一些问题，为了解决这些问题，我编写了拦截cache的插件，通过这个拦截器修正了这些问题。 问题 什么问题 最容易出现的问题是开启cache后，分页查询时无论查询哪一页都返回第一页的数据。另外，使用sql自动生成插件生成get方法的sql
在mybatis中实现缓存技术
学子的博客
06-01 168
1、什么是缓存 [ Cache ]？ 存在内存中的临时数据。 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。 2、为什么使用缓存？ 减少和数据库的交互次数，减少系统开销，提高系统效率。 3、什么样的数据能使用缓存？ 经常查询并且不经常改变的数据。 Mybatis缓存 MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。 MyBatis系统中
Mybatis 缓存Cache
憧憬的专栏
11-15 1128
一、什么是缓存（Cache） Cache是高速缓冲存储器 一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问。在Java中简单的理解缓存就是实现数据的拷贝，提高系统性能，减少数据库压力。 二、为什么要用缓存（Cache） 因为如果使用了缓存，在缓存中有需要的数据，就不用从数据库中获取转而从缓存中获取，这样就大大提高了系统性能。 三、一级缓存 Mybatis的一级缓存不需要任何配置，在每一个 SqlSession 当中都有一个一级缓存区，作用范围是 SqlSession 。 （一）原理 Myb
Mybatis一级缓存，二级缓存的实现就是这么简单
好好学java
07-26 344
介绍又到了一年面试季，所以打算写一点面试常问的东西，争取说的通俗易懂。面试高级岗，如果你说熟悉Mybatis，下面这些问题基本上都会问Mybatis插件的实现原理？如何写一个分页插件？M...
Mybatis-plus基于redis实现二级缓存过程解析
08-18
Mybatis-plus基于Redis实现二级缓存过程解析 Mybatis-plus是一款基于Java语言的持久层框架，旨在简化数据库交互操作。然而，在高并发、高性能的应用场景中，数据库的查询操作可能会成为性能瓶颈。为了解决这个问题...
Mybatis-ehcache 1.2.1源码（ehcache-cache-mybatis-ehcache-1.2.1.zip）
07-05
通过阅读源码，我们可以深入理解Mybatis-ehcache如何利用Ehcache实现缓存功能，以及它如何与Mybatis的运行机制无缝对接。这不仅有助于我们定制自己的缓存解决方案，还能帮助我们在实际项目中更高效地使用Mybatis和...
Mybatis-ehcache 1.2.1源码（ehcache-cache-mybatis-ehcache-1.2.1.tar
07-05
2. **Cache 接口实现**：Ehcache 实现了 Mybatis 的 Cache 接口，提供了缓存的生命周期管理和数据存取操作。 3. **插件机制**：Mybatis 使用插件机制来集成 Ehcache，通过拦截器（Interceptor）在 SQL 执行前后进行...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.zip）
02-07
- MyBatis 提供了本地缓存（Local Cache）和二级缓存（Second Level Cache），可以有效提高数据读取效率。缓存策略可配置，支持读写分离和清空操作。 9. **插件支持** - MyBatis 允许开发者自定义插件，拦截特定...
MyBatis的Cache机制解析
御风大世界 | https://blog.bywind.cn
04-09 713
### 1. MyBatis缓存机制的核心构件 1.1 Cache接口 接口简单明了，Cache的基本操作；put/get/remove/clear。 public interface Cache { String getId();//分组ID void putObject(Object key, Object value);//put Ob...
Mybatis 的 CacheKey
日有寸进
05-02 2412
前置文章 Mybatis 的一级缓存与二级缓存 结合 Mybatis 的 cache 包源码理解装饰器模式 CacheKey 是干嘛的 简单的说就是 cache 的 key 值，如下图 MyBatis 中涉及到动态 SQL 的原因，缓存项的 key 不能仅仅通过一个 String 来表示，所以通过CacheKey 来封装缓存的 key 值，CacheKey 可以封装多个影响缓存项的因素 nam...
简单仿写Mybatis中的Cache
Light_makeup的博客
07-12 270
仿写Mybatis中的Cache 在mybatis中提供了很多Cache，每一个Cache都有不同的特性 其中，我们使用了装饰者模式来仿写Cache 首先定义规范接口 public interface Cache { public void putObject(Object key,Object value); public Object getObject(Object key); public Object removeObject(Object key); .
MyBatis的缓存机制（一）分析Cache责任链的设计以及构建过程
最新发布
qq_43152622的博客
10-23 484
1. 分析了Cache接口类型，以及它使用的责任链设计模式 2. 探究Mybatis在初始化时是如何构建这样一条责任链的 3. 自己尝试复现它的实现
Mybatis缓存（二）-Cache的各个实现类的分析
daliucheng的博客
09-13 325
继上一篇之后，继续介绍了Cache的各个实现类，和对Cache的思考。从源码角度来分析Mybatis缓存的具体实现。快来看看吧
实现 MyBatis Cache 接口，用于自定义缓存为 Redis
caoniuniu25的专栏
12-21 369
package com.funtl.itoken.common.utils; import com.funtl.itoken.common.context.ApplicationContextHolder; import org.apache.ibatis.cache.Cache; import org.slf4j.Logger; import org.slf4j.LoggerFactory;...
mybatis缓存机制详解（一）——Cache
weixin_34326179的博客
02-24 497
2019独角兽企业重金招聘Python工程师标准>>> ...
mybatis3.5.6的cachekey
Myd
04-24 487
        mybatis有一级缓存和二级缓存，默认开启一级缓存；在查询的时候会先查缓存，缓存中没有数据才会查询数据库；那么是根据什么来确定当前要查询的数据已经在缓存中呢？一个叫cacheKey对象，可以确定前要查询的数据是否在缓存中。         cacheKey和我们缓存的数据有什么联系呢？由于一条查询语句，会查询到相应的数据；所以会根据
mybatis核心数据结构详解——CacheKey
weixin_33759269的博客
02-23 671
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值