前面我们说了mybatis的缓存设计体系，这里我们来正式看一下这玩意到底是咋个用法。
首先我们是知道的，Mybatis中存在两级缓存。分别是一级缓存(会话级)，和二级缓存(全局级)。
下面我们就来看看这两级缓存。

一、准备工作

1、准备数据库

在此之前我们先来准备一个数据库，并且设计一个表user用户表，加几条数据进去。

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (`id` int(32) NOT NULL COMMENT '主键id',`name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '名字',PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, '张飞');
INSERT INTO `user` VALUES (2, '关羽');
INSERT INTO `user` VALUES (3, '孙权');SET FOREIGN_KEY_CHECKS = 1;

2、然后我们创建一个mybatis中的DAO接口。

public interface IUserDao {// 查询所有用户List<User> findAll();
}

3、创建UserMapper.xml文件

<mapper namespace="com.yx.dao.IUserDao"><select id="findAll" resultType="com.yx.domain.User" statementType="CALLABLE">SELECT * FROM `user`</select
</mapper>

4、创建Mybatis核心配置文件

<configuration><!--加载外部properties文件，位置必须在第一个--><properties resource="jdbc.properties"/><settings><!-- 控制台输出sql语句 --><setting name="logImpl" value="STDOUT_LOGGING" /></settings><typeAliases><!--给单独的实体类取别名--><!--<typeAlias type="com.lwq.domain.User" alias="user"/>--><!--批量给实体类取别名：指定包下面所有的类的别名默认为其类名，不区分大小写--><package name="com.yx.domain"/></typeAliases><environments default="development"><!--开发环境，可以配置多套环境，default指定用哪个--><environment id="development"><!--當前事務交給jdbc處理--><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></dataSource></environment></environments><mappers><mapper resource="UserMapper.xml"/></mappers>
</configuration>

5、创建jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatis22
jdbc.username=root
jdbc.password=root

好了，我们现在可以使用mybatis来操作数据库了。

二、一级缓存

1、验证

一级缓存在mybatis中是默认开启的，我们先来测试一下，他到底存在不存在，并且是不是能用，是不是默认开启的。我们来做一个测试代码。

@Test
public void test1() throws IOException {// 读取配置文件转化为流InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = factory.openSession();//这⾥不调⽤SqlSession的api,⽽是获得了接⼝对象，调⽤接⼝中的⽅法。使用JDK动态代理产生代理IUserDao userDao = sqlSession.getMapper(IUserDao.class);// 第一次执行查询List<User> userList = userDao.findAll();userList.forEach(user -> {System.out.println(user.toString());});System.out.println("*************************************************");// 第二次执行相同的查询List<User> userList2 = userDao.findAll();userList2.forEach(user -> {System.out.println(user.toString());});
}这里我们做了两次查询，第一次和第二次的查询是一模一样的，如果存在缓存，那它一定第二次就不会去查数据库
了，下面我们来验证一下。

输出如下：

Opening JDBC Connection
Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
Created connection 1011044643.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3c435123]
==>  Preparing: SELECT * FROM `user`
==> Parameters: 
<==    Columns: id, name
<==        Row: 1, 张飞
<==        Row: 2, 关羽
<==        Row: 3, 孙权
<==      Total: 3
User{id=1, username='张飞'}
User{id=2, username='关羽'}
User{id=3, username='孙权'}
*************************************************
User{id=1, username='张飞'}
User{id=2, username='关羽'}
User{id=3, username='孙权'}

我们看到第一次调用进行了创建connection连接，下面执行了sql，然后输出，但是第二次再执行，他就不会再去查库了，而是直接输出了缓存，这就说明了这个缓存是存在并且开启的。

2、注意

2.1、注意点1

一级缓存只在当前sqlsession中生效，也就是他是会话级别的，每一次连接内的多次相同查询可以共享这次缓存，如果你换了sqlsession，新的sqlsession和其他的sqlsession的查询是不能共享缓存使用的。下面我们来验证一下。

@Test
public void test2() throws IOException {// 读取配置文件转化为流InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = factory.openSession();SqlSession sqlSession2 = factory.openSession();//这⾥不调⽤SqlSession的api,⽽是获得了接⼝对象，调⽤接⼝中的⽅法。使用JDK动态代理产生代理对象IUserDao userDao = sqlSession.getMapper(IUserDao.class);IUserDao userDao2 = sqlSession2.getMapper(IUserDao.class);// 第一次执行查询List<User> userList = userDao.findAll();userList.forEach(user -> {System.out.println(user.toString());});System.out.println("*************************************************");// 第二次执行相同的查询List<User> userList2 = userDao2.findAll();userList2.forEach(user -> {System.out.println(user.toString());});
}

我们开启创建了两个不同的sqlSession分别是sqlSession和sqlSession2，然后执行相同的查询。
输出如下：

Opening JDBC Connection
Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
Created connection 1011044643.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3c435123]
==>  Preparing: SELECT * FROM `user`
==> Parameters: 
<==    Columns: id, name
<==        Row: 1, 张飞
<==        Row: 2, 关羽
<==        Row: 3, 孙权
<==      Total: 3
User{id=1, username='张飞'}
User{id=2, username='关羽'}
User{id=3, username='孙权'}
*************************************************
Opening JDBC Connection
Created connection 156199931.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@94f6bfb]
==>  Preparing: SELECT * FROM `user`
==> Parameters: 
<==    Columns: id, name
<==        Row: 1, 张飞
<==        Row: 2, 关羽
<==        Row: 3, 孙权
<==      Total: 3
User{id=1, username='张飞'}
User{id=2, username='关羽'}
User{id=3, username='孙权'}

此时我们就看到，第二次查询并没有利用到缓存，而是又开始了一次新的查询。所以这种跨sqlsession是不能使用缓存的。不是不存在，而是使用不到。

2.2、注意点2

我们既然知道了在sqlseeion不同的时候，缓存是不能利用的，那么问题来了，你的以后的日常开发中这个sqlsession他会经常变吗，如果变了，那岂不是走不了缓存了。
实际上就是经常变的，比如你页面上有一个按钮就是搜索，每次都会查询数据库，实际上你每次点击都会建立新的sqlsession，因为这玩意是伴随着连接的。你每次请求都会创建新的连接，那你的缓存就没用，除非你在你的service里面连着调用了两次一样的查询，这个，，，你没事吧。
所以你的一级缓存大部分情况下，没卵用。
那你为啥说每次请求都是单独的sqlSession或者单独的jdbc connection呢，因为这里牵扯到要控制事务，不同请求必须是独立隔离的连接，这样才能独立控制事务，如果共享事务，可能会造成混乱。比如请求1，请求2开启一个连接，那请求1还没完呢，你请求2就提交了事务，这不就寄了。

2.3、注意点3

那么查询是不是不需要事务呢，查询是不是就可以共享连接了，不对，查询也需要，select后面可以加锁。需要事务。
后面的二级缓存，这里也是需要的。后面我们再说，而且设计的时候肯定是统一处理的，不会说为了你一个加锁或者二级缓存就去区分开代码处理。

所以基于一级缓存的苛刻条件，我们知道这个一级缓存其实在使用者层面，他用处不大，实际上他也是在内部他自己的使用的。
既然我们说了他没啥用，那他设计出来干嘛呢，必然是有用处，下面我们来看下源码来分析一下他的用处。但是在进入源码之前，我们先来看一个设计模式，就是适配器设计模式。

3、适配器设计模式

我们在前面看到了mybatis的设计结构，大致如下。

我们看到首先他是一个Executor的接口，然后下面一个BaseExecutor来实现了这个接口，下面又是三个子类继承了BaseExecutor这个类，这其实就是一个适配器模式。我们看下他的类结构。

1、什么是适配器。

这个玩意一般资料都会拿出一个电压的例子，比如中国的常规电压是220伏特，人能承受的大概是36伏特，那我们要是碰到220伏特就寄了，于是我们可以使用一个变压器，放在中间。

这个变压器的作用就是适配器，这个例子你是不是在无数地方都看吐了，我们还是直接在代码说吧。
比如此时有一个Servlet的接口，里面有五个接口(我简化了一下)。

public interface Servlet {void init();void service();void destory();String getServletInfo();void getServletConfig();
}

此时我想实现一个自己的Servlet就叫做MyServlet，其中我只想实现 String getServletInfo();这个方法，但是java的语法就是我只要实现这个接口，就得实现他所有的方法，这个压力太大，等于直接把220V的电压给我了，我不想这么整，所以此时需要一个变压器。也就是适配器登场。
此时我们在创建一个类，去实现这个接口，如下：

public abstract class MyServletAdapter implements Servlet{@Overridepublic void init() {}@Overridepublic void service() {}@Overridepublic void destory() {}@Overridepublic String getServletInfo() {return null;}public abstract void getServletConfig();
}

你看到我们此时实现了这个接口，并且实现了其中四个方法，最后一个我们做成了抽象方法，其他四个你想不想实现看你。最后一个我们做成抽象的，给我们自己的那个servlet去实现。
于是就变为这样、

public  class MyServlet extends MyServletAdapter{@Overridepublic void getServletConfig() {System.out.println("我自己的servlet实现单独的一个方法");}
}

此时我们的这个类就完成了变压器到达终端，此时就只需要实现一个即可，而因为这个在变压器里面是抽象方法，所以这里是存在必须实现的约束的。还是有接口的作用。这就是适配器模式。

2、mybatis中的适配器

这样我们知道了适配器模式，那么其实上面那张图中的BaseExecutor就是适配器了。

BaseExecutor把接口中的一部分方法实现了，没实现的最后交个那三个子类各自实现各自定制化的东西，而公共的则由适配器里面去实现了。子类里面的还能用这些公共的，节省了代码量。这和模板设计模式很像。但虽然像，只是他们实现过程中表现出来的抽象，因为设计模式都是为了复用，抽象，扩展这些特点的，而适配器模式实际上出发点他是为了"变压"。

4、一级缓存的静态源码分析

我们说其实不管你哪个Excutor子类都是有这个缓存的，所以我么能猜出来，这个缓存功能其实是放在适配器里面的公共部分让子类使用的，我们看下这个适配器BaseExecutor。

public abstract class BaseExecutor implements Executor {......protected PerpetualCache localCache;// 一级缓存protected PerpetualCache localOutputParameterCache;// 存储过程的，一般不用@Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// 根据你传进来的参数，动态生成sql，返回的boundSql就有这个sqlBoundSql boundSql = ms.getBoundSql(parameter);// 为本次查询创建缓存的keyCacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);//重载方法，实现查询return query(ms, parameter, rowBounds, resultHandler, key, boundSql);}// 在这里重载@SuppressWarnings("unchecked")@Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());// 判断执行器是不是被关闭，关闭直接抛出异常if (closed) {throw new ExecutorException("Executor was closed.");}// 清空本地缓存，如果queryStack为0，就要清空本地缓存if (queryStack == 0 && ms.isFlushCacheRequired()) {clearLocalCache();}List<E> list;try {queryStack++;// localCache.getObject(key)取出一级缓存里面的查询结果list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) {// 如果缓存中有，就直接返回缓存的handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else {//如果缓存中没有本次查找的值，那么queryFromDatabase方法从数据库中查询list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {queryStack--;}if (queryStack == 0) {// 执行延迟加载for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601deferredLoads.clear();if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}return list;}}private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {List<E> list;// 在缓存中添加占位对象，此处的占位符和延迟加载有关，见DeferredLoad#canLoad()localCache.putObject(key, EXECUTION_PLACEHOLDER);try {//doQuery是真正的最后的去执行读操作list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);} finally {// 从缓存中溢出占位对象localCache.removeObject(key);}// 查询完把结果添加到缓存中localCache.putObject(key, list);// 暂时忽略，存储过程相关if (ms.getStatementType() == StatementType.CALLABLE) {localOutputParameterCache.putObject(key, parameter);}return list;}

所以这里大致你能看到这个过程，就是他会读取缓存，没有缓存就去读取数据库，并且设置缓存，这是我们基于代码看到的效果，实际上的过程我们需要debug来看一下，就能看到如何读取，并且跨sqlSession是如何不生效的，这个可以直接在debug看到，每个sqlsession下面有不同的localCache，实现了缓存隔离。这个我们下面再来debug追踪源码。这里先简单贴个图。