Hello 大家好，我是鸭血粉丝，2020 注定是一个不平凡的一年，很多小伙伴在后台和星球留言都说今年的工作不好找，也有应届生小伙伴给阿粉发消息问阿粉所在的公司今年是否招应届生，阿粉也只能帮小伙伴问问 HR，但是阿粉也做不了主。

刚好前几天一个小伙伴在微信上问阿粉，说是面试一家公司被问到 Java GC 相关的东西，虽然平时也有准备，但是回答起来总是零零散散，感觉没有逻辑。其实阿粉也能理解，现在面试都是一种问答模式，一个随便问问，一个死记硬背，很多时候面试前准备的好好的一到面试的时候可能紧张就给忘了，事后感觉自己表现的不好。

这篇文章给大家举个例子，在遇到一个问题或者知识点的时候要怎么去理解和学习。

Java GC

目标

遇到一个问题或者一个知识点，我们要理解和明白是要解决什么问题的。说到 Java GC 那这个 GC 的目的是什么呢？很显然是回收内存，因为内存是有限的，随着程序中创建的对象越来越多，如果进行回收就会导致内存越来越大，最后程序就会出现异常。既然目的是为了回收内存，那么新的问题来了，哪些对象可以被回收呢？什么时候进行回收呢？怎么回收呢？

哪些对象可以被回收

简单来说就是无用的对象可以被回收，那么换句话说，如果定义一个对象是无用的呢？这里主要有两种方法，一个叫引用计数法，一个叫可达性分析法。

引用计数

引用计数说的是如果一个对象被别的对象进行了一次引用，那么该对象会有一个引用计数器，这个计数器就会加一；如果被释放一下，引用计数器就会减一。当引用计数器的计数为 0 的时候就表示这个对象是无用的，此时就可以对这样对象进行回收了。表面上看好像挺合理的，实现起来也很方便，但是仔细一想就会发现有问题。既循环引用的问题，比如对象 A 引用了对象 B，但是对象 B 当中也引用了对象 A，那么这个时候对象 A 和对象 B 的引用计数器的计数都不会是 0，但是这两个对象都没有被其他对象引用，理论上来说这两个对象都是可以被回收的。

从上面看到，这种方案是有问题的会导致内存泄露。随之而来的就出现了另一种方案，可就是可达性分析。

可达性分析

可达性分析说的是从 GCRoots 的点作为起点，向下搜索，当找不到任何引用链的时候表示该对象为垃圾对象。那么哪些对象可以被认为是 Roots 节点呢？有 Java 栈中的对象，方法区的静态属性和常量以及本地方法栈中的对象。从这几种对象依次向下搜索，如果没有能达到 Roots 节点的对象就是垃圾对象，就说明可以被回收。

如下图所有，对象 A，B，C都能找到与 Roots 节点的联系，但是对象 D，E，F 三个并不能找到与 Roots 节点的联系，也就是不可达，所以 DEF 这三个对象就是垃圾对象。

什么时候回收

上面的两种方案解决了哪些对象能被回收，那么下个问题，就是什么时候进行垃圾回收呢？在排除人为调用的时候，垃圾回收都是发生在为新生对象进行内存分配的时候，这个时候如果内存空间不足就会触发 GC 进行垃圾回收。

怎么回收

上面我们知道了哪些对象可以被回收，也知道我们应该什么时候进行回收，那下面要解决的就是如何进行垃圾回收了。垃圾回收根据实现的方式不同有多种不同的算法实现。比如有标记清除算法，复制算法，标记整理算法，分代回收算法，下面简单介绍一下，想深入了解的可以自行去研究一下。

标记清除算法

标记清除算法很好理解，主要就是执行两个动作，一个是标记，另一个是对进行标记的对象内存进行清除回收。这个算法有个问题就是会出现内存碎片化严重。如下图所示：

从上图中可以看到，在进行内存回收后出现了严重的内存碎片化，这就导致在分配某些大对象的时候仍然会出现内存不够的情况，但是总体内存确是够的。

复制算法

复制算法的实现方式比较简洁明了，就是霸道的把内存分成两部分，在平时使用的时候只用其中的固定一份，在当需要进行 GC 的时候，把存活的对象复制到另一部分中，然后将已经使用的内存全部清理掉。如下图：

从上图可以看到解决了标记清除的内存碎片化问题，但是很明显复制算法有另一个问题，那就是内存的使用率大大下降，能使用的内存只有原来的一半了。

标记整理算法

既然标记清除和复制算法各有优缺点，那自然的我们就想到是否可以把这两种算法结合起来，于是就出现了标记整理算法。标记阶段是标记清除算法一样，先标记出需要回收的部分，不过清除阶段不是直接清除，而是把存活的对象往内存的一端进行移动，然后清除剩下的部分。如下图：

标记整理的算法虽然可以解决上面两个算法的一些问题，但是还是需要先进行标记，然后进行移动，整个效率还是偏低的。

分代回收算法

分代回收算法是目前使用较多的一种算法，这个不是一个新的算法，只是将内存进行的划分，不同区域的内存使用不同的算法。根据对象的存活时间将内存的划分为新生代和老年代，其中新生代包含 Eden 区和 S0，S1。在新生代中使用是复制算法，在进行对象内存分配的时候只会使用 Eden 和 S0 区，当发生 GC 的时候，会将存活的对象复制到 S1 区，然后循环往复进行复制。当某个对象在进行了 15 次GC 后依旧存活，那这个对象就会进入老年代。老年代因为每次回收的对象都会比较少，因此使用的是标记整理算法。

垃圾回收器

讲完了垃圾回收算法，我们再看下垃圾回收器，每一种垃圾回收器都是不同时代的不同产物，都有其独特性。

• Serial 垃圾收集器(单线程、复制算法)
• ParNew垃圾收集器(Serial+多线程)
• Parallel Scavenge 收集器(多线程复制算法、高效)
• SerialOld收集器(单线程标记整理算法)
• ParallelOld收集器(多线程标记整理算法)
• CMS收集器(多线程标记清除算法)
• G1收集器

各个垃圾收集器的配合使用情况可以参考下图，个人觉得对这么多的收集器没有必要全部精通，可以注重关注一下 CMS 和 G1 就可以了。感兴趣的小伙伴可以自己的研究一下。

关于本文的高清脑图已经放到公众号上面了，欢迎关注公众号回复【gc】获得。

写在最后

最后邀请你加入我们的知识星球，这里有 1700+ 优秀的人与你一起进步，如果你是小白那你是稳赚了，很多业内经验和干活分享给你；如果你是大佬，那可以进来我们一起交流分享你的经验，说不定日后我们还可以有合作，给你的人生多一个可能。

关于 ReentrantLock 看这篇文章就够了

啥？你连 AQS 是啥都不知道？

前几天，阿粉的一个朋友去面试，他回来告诉我，面试官问他 IP 地址是怎么存在数据库的？他当时也没多想，直接就回答的存字符串啊（心想：这么简单的问题，怕不是看不起我吧）

Hello 大家好，我是鸭血粉丝，今年闰四月，所以阿粉非常羡慕那些农历四月过生日的朋友，因为今年可以过两个，想想都很激动，但是激动归激动，最激动应该是那些用着三星手机的用户了，因为一个闰四月让他们的手机差点又“爆炸”了。

最近微博上有网友曝出自己的三星手机在 5 月 23 号凌晨的时候突然出现黑屏乱码，自动循环重启的问题。维修手机都用户都需要排队了，客服表示是农历闰年 4 月计算逻辑错误的原因（这个锅不知道哪个程序员要背了），而且升级后数据可能会丢失。

微博上很多用户都表示自己的手机出现了这个问题，出现如下乱码（感觉回到了交互模式的年代，有没有很亲切啊）。

就连专柜里面的手机也没有幸免，堪称尴尬翻车现场，感觉就像出师未捷身先死。

问题出现不就后三星官方微博就发了通知，表示收到了反馈，积极排查中，有点略显尴尬，就像聊天的过程中等了半天等来了一句“嗯，我知道，你等等”。

有网友提供了一个临时解决方案如下，但是阿粉没有用三星手机，不知道是否有效果，只能说慎用。保证安全还是到官方售后去维修吧。

重启之后双击电源键，来到拍照界面，这时候下拉通知栏，点击设置按钮，搜索时间，把日期往前改一个月，就可以解决了，亲测有效。然后就静候官方修复吧。

写在最后

最后邀请你加入我们的知识星球，这里有 1700+ 优秀的人与你一起进步，如果你是小白那你是稳赚了，很多业内经验和干活分享给你；如果你是大佬，那可以进来我们一起交流分享你的经验，说不定日后我们还可以有合作，给你的人生多一个可能。

小朋友，你是不是有很多问号？

hello~各位读者好，我是鸭血粉丝（大家可以称呼我为「阿粉」）。今天，阿粉带着大家来了解一下 mybatis 接口的创建。

1.上期回顾

首先，我们还是回顾一下上篇文件的类容。先看下这个测试类，大家还有印象吗：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MybatisTest {
    @Test
    public void testSelect() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
        try {
            FruitMapper mapper = session.getMapper(FruitMapper.class);
            Fruit fruit = mapper.findById(1L);
            System.out.println(fruit);
        } finally {
            session.close();
        }
    }
}

上篇源码分析讲了 mybatis 一级缓存的实现原理。这次，我们来了解下 mybatis 接口的创建。

2. mapper接口的创建流程

2.1 SqlSession的getMapper()

首先，我们来看下 FruitMapper mapper = session.getMapper(FruitMapper.class); 这段代码，意思很简单，根据传入的class 获取这个对象的实例。这个流程有点复杂，阿粉带着大家来跟下源码：

首先还是ctrl + 左键点击 getMapper 方法，然后会进入到 SqlSession 的 getMapper() 方法。然后之前阿粉也带着大家了解了， SqlSession 的默认实现类是 DefaultSqlSession ，所以我们直接看下 getMapper() 在 DefaultSqlSession 里面的实现：

1
2
3
4

@Override
public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
}

2.2 Configuration 的getMapper()

这里从 configuration 里面去获取， configuration 是全局配置对象，也就是上下文。参数 this 是当前的SqlSession 对象，继续跟进去看下：

1
2
3

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
}

2.3 MapperRegistry 的getMapper()

mapperRegistry 对象是干什么的呢？继续点进去：

1
2
3
4
5
6
7
8
9
10
11

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
        return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}

这里就不好看懂了，需要先看下了解下 MapperRegistry 这个类，我们一步一步来，跟着阿粉的思路走：

1
2
3
4
5
6
7
8
9
10

public class MapperRegistry {

  private final Configuration config;
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

  public MapperRegistry(Configuration config) {
    this.config = config;
  }
    ...
}

了解一个类，首先看下成员变量和构造方法。这里 config 不用多说了吧，主要的是 knownMappers 这个成员变量。这就是个map 对象，只是这个 map 对象的 value值是个对象，所以又要去看下 MapperProxyFactory 这个对象,点进去：

1
2
3
4
5
6
7
8
9

public class MapperProxyFactory<T> {
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }
    ...
}

首先，单独看下这个类名 MapperProxyFactory ，取名是很有学问的，好的名字让你一下就知道是干啥的。所以一看 MapperProxyFactory ，首先就会联想到工厂模式，工厂模式是干啥的？创建对象的，创建什么对象呢？创建 MapperProxy 对象的。 MapperProxy 也是有玄机的，Proxy 的是什么？看到这个一般都是使用代理模式来创建代理对象的。所以就很清楚了， MapperProxyFactory 这个类就是个工厂，创建的是 mapper 的代理对象。

然后这个类里面存的是 mapper 的接口和接口里面的方法。

最后，我们回到 MapperRegistry 类里面的 getMapper() 方法。现在是不是要清楚一些，通过 mapper 接口去 map 里面获取工厂类 MapperProxyFactory ，然后通过工厂类去创建我们的 mapper 代理对象。然后在看下 getMapper() 方法里面的 mapperProxyFactory.newInstance(sqlSession); 这段代码，继续点进去：

1
2
3
4

public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
}

你看，阿粉猜测对不对，MapperProxy 对象是不是出来了。然后看 newInstance() 这个方法：

1
2
3

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

两个 newInstance() 方法都在MapperProxyFactory 这个类里面，这里就很明显嘛。典型的 JDK 代理对象的创建。

好了，到这里我们的 mapper 对象就获取到了。大家可以想一想，为什么获取一个 mapper 对象会那么复杂？或者说 mapper 对象有什么作用？其实就是为了通过 mapper 接口的方法获取到 mapper.xml 里面的 sql，具体怎么获取的，请允许阿粉卖个关子，请听阿粉下回分解。

3.总结

最后，阿粉以一个时序图来结束本篇文章，喜欢的话，记得点个赞哦。么么哒~

一起来探讨下

前几天阿粉的朋友面试，在面试的时候，面试官问到了框架，项目，JVM还有一些关于线程池的内容，而这个线程池，让阿粉的朋友分分钟被面试官吊打，只能出门左拐，地铁站回家了。为什么呢？因为线程池他是真的没有下功夫去准备，只能凉凉了。

之前看一个“伪科学”专家的各种推算，说中国的“单身汪”中，程序员在其中占了非常大的占比，在阿粉看来，这明显就是撒谎，毕竟阿粉作为一名程序员，不但生活美满，还猫狗双全。

RPC 远程过程调用可以说是分布式系统的基础，本文将通过 Java 演示一次普通的 rpc 调用到底发生了什么。

Hello 大家好，我是鸭血粉丝，不知道你有没有过这样的经历，经常在面试的时候被问到 JDK 相关的命令，如何排查线上的问题，线上程序突然崩了要怎么处理，等等类似这种场景。其实并不是每个开发人员都能有这种实战经验，现实工作中往往很多开发人员是接触不到线上环境的。但是作为一个以 Java 谋生的程序员，如果连这些 JDK 自带的一些命令都不知道，那也说不过去。

阿粉以前也是这样，从来没有接触过线上环境，有任何问题都是运维人员去处理，因为相关制度不允许开发人员接触生产服务器。但是作为一个有梦想的开发人员，不能接触不代表就不用学，阿粉还是私下好好学习了一波，万一哪天就用上了呢。

嵌入式数据库一个很陌生的词汇，以前只是听说，但是没有真正使用过，今天小编和大家一起来揭开它的面纱。

Hello 大家好，我是鸭血粉丝，不知道你有没有过这样的经历，经常在手机上参与各种抽奖，但是明明眼看着就要中特等奖了，但是最后还是中了个谢谢参与，阿粉我就是一个中奖绝缘体，以前总是觉得是自己的运气不好，但是自从知道了背后的暗箱操作过后，阿粉就见怪不怪了。

synchronized 关键字

说到锁，都会提 synchronized 。这个英文单词儿啥意思呢？翻译成中文就是「同步」的意思

今天差点儿被妹子难住了，具体情况容我慢慢说

hello~各位读者好，我是鸭血粉丝（大家可以称呼我为「阿粉」）。今天，阿粉带着大家来了解一下 mybatis 一级缓存的实现原理。

1.上期回顾

首先，我们还是回顾一下上篇文件的类容。毕竟离上次讲 mybatis还是过去了很久，汗~。

还是先看下这个测试类，大家还有印象吗：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MybatisTest {
    @Test
    public void testSelect() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
        try {
            FruitMapper mapper = session.getMapper(FruitMapper.class);
            Fruit fruit = mapper.findById(1L);
            System.out.println(fruit);
        } finally {
            session.close();
        }
    }
}

上篇源码分析讲了 SqlSession 构建的过程。这次，我们来了解下 mybatis 一级缓存的实现原理。

2.mybatis缓存

2.1 缓存的作用

mybatis 缓存的作用就是提升查询的效率和减少数据库的压力。

2.2 mybatis的缓存类

mybatis缓存相关的类都在cache包里面，有个 Cache 的接口，默认实现是 PerpetualCache 类。当然，还有一些其他缓存类，是通过装饰器模式实现的。我们来看下包结构：

然后看下这些缓存类的作用：

• PerpetualCache ：基本缓存类，默认实现。
• LruCache ：LRU策略的缓存，作用是当缓存到达上限时候，删除最近最少使用的缓存。
• FifoCache ： FIFO 策略的缓存，作用是当缓存到达上限时候，删除最先入队的缓存。
• SoftCache ： 带清理策略的缓存，作用是通过JVM 的软引用来实现缓存，当JVM内存不足时，会自动清理掉这些缓存。
• WeakCache ：带清理策略的缓存，作用是通过JVM 的弱引用来实现缓存，当JVM内存不足时，会自动清理掉这些缓存。
• LoggingCache ： 带日志功能的缓存。
• SynchronizedCache ： 同步缓存，基于synchronized 关键字实现，作用是解决并发问。
• BlockingCache ： 阻塞缓存，通过在get/put 方式中加锁，保证只有一个线程操作缓存，基于Java 重入锁实现
• SerializedCache ： 支持序列化的缓存，将对象序列化以后存到缓存中，取出时反序列化。
• ScheduledCache ：定时调度的缓存，在进行get/put/remove/getSize 等操作前，判断缓存时间是否超过了设置的最长缓存时间（默认是一小时），如果是则清空缓存–即每隔一段时间清 空一次缓存。这个有点像 redis 设置的超时时间。
• TransactionalCache ：事务缓存。

2.3 一级缓存

一级缓存也叫本地缓存，MyBatis 的一级缓存是在会话（SqlSession）层面进行缓存的。MyBatis 的一级缓存是默认开启的，不需要任何的配置。

上面说到缓存的默认实现对象是 PerpetualCache ，那么这个对象是在哪里维护的呢？MyBatis 的一级缓存是在会话共享，那么我们先看下 SqlSession 这个里面有没有维护。SqlSession 是接口，阿粉上一篇源码讲了创建 SqlSession 最后返回的是 DefaultSqlSession 对象。我们看下这个类的成员变量：

1
2
3
4
5
6
7
8
9
10

public class DefaultSqlSession implements SqlSession {

  private final Configuration configuration;
  private final Executor executor;

  private final boolean autoCommit;
  private boolean dirty;
  private List<Cursor<?>> cursorList;
    。。。
}

首先，Configuration 对象是全局的，不可能放在这个里面。后面3个也不像，我们看下 Executor 类。

Executor 类也是一个接口，我们看下它的抽象实现 BaseExecutor ：

1
2
3
4
5
6
7
8
9
10
11
12
13

public abstract class BaseExecutor implements Executor {

  private static final Log log = LogFactory.getLog(BaseExecutor.class);

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  protected PerpetualCache localCache;
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;
    。。。
}

看到没，缓存对象是在这个对象里面维护的。Executor 这个类就是执行 sql 的，可以理解为 sql 执行器。

然后再来看下 PerpetualCache 类是怎么实现缓存的。

1
2
3
4
5
6
7

public class PerpetualCache implements Cache {

  private final String id;

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

很明显，是用 HashMap 实现的。既然是 HashMap ，那么用什么作为 key 呢？我们看下 BaseExecutor 里面有一个 createCacheKey() 的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

然后我们来看下：

• ms.getId() ：ms 是解析 mapper.xml 创建的对象，每个 select/update/delete/insert 标签会创建一个 MappedStatement 对象。id 就是 mapper 的 namespace 加上 4种标签的 id。
• rowBounds.getOffset() ：分页参数。
• rowBounds.getLimit() ： 分页参数。
• boundSql.getSql() ： sql 语句。
• value ：这个是解析的 sql 传入的参数。
• configuration.getEnvironment().getId() ： 这个是配置的数据源 id ，spring 里面，数据源不会在 mybatis里面配置。

这就是缓存 key 的组成。

最后阿粉还是用例子来验证一下一级缓存是否是在 session 中共享的。判断是否命中缓存，可以根据是否打印 sql 来判断，没有缓存就会去数据库查询，所有会打印 sql，否则就是有缓存，不会打印sql。来看下例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 @Test
    public void testSelect() throws IOException {

        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session = sqlSessionFactory.openSession();
        try {
            FruitMapper mapper = session.getMapper(FruitMapper.class);
            Fruit fruit = mapper.findById(1L);
            System.out.println("第一次查询:"+ fruit);
            Fruit fruit1 = mapper.findById(1L);
            System.out.println("第二次查询:" + fruit1);
        } finally {
            session.close();
        }
    }

结果为:

1
2
3
4
5
6
7
8

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@42f48531]
==>  Preparing: select id,name from fruit where id =? 
==> Parameters: 1(Long)
<==    Columns: id, name
<==        Row: 1, 苹果
<==      Total: 1
第一次查询:Fruit(id=1, name=苹果)
第二次查询:Fruit(id=1, name=苹果)

说明同一个 session 里面，缓存是共享的。接下来我们在不同的 session 中看下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class MybatisTest {

    @Test
    public void testSelect() throws IOException {

        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            FruitMapper mapper = session.getMapper(FruitMapper.class);
            FruitMapper mapper2 = session2.getMapper(FruitMapper.class);
            Fruit fruit = mapper.findById(1L);
            System.out.println("第一次查询:"+ fruit);
            Fruit fruit1 = mapper2.findById(1L);
            System.out.println("第二次查询:" + fruit1);
        } finally {
            session.close();
        }

    }
}

结果为:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@42f48531]
==>  Preparing: select id,name from fruit where id =? 
==> Parameters: 1(Long)
<==    Columns: id, name
<==        Row: 1, 苹果
<==      Total: 1
第一次查询:Fruit(id=1, name=苹果)
Opening JDBC Connection
Created connection 1358857082.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@50fe837a]
==>  Preparing: select id,name from fruit where id =? 
==> Parameters: 1(Long)
<==    Columns: id, name
<==        Row: 1, 苹果
<==      Total: 1
第二次查询:Fruit(id=1, name=苹果)

说明不同的 session ，缓存是不共享的。

3.总结

今天的 mybatis 一级缓存到这里就结束了。喜欢阿粉的同学记得点个赞哦。我们下次再见。

首图来自最近热播的『鬼吹灯之龙岭迷窟』，看过上一部『鬼吹灯之怒晴湘西』同学应该能看懂这个笑点。 潘粤明老师上一部还是卸岭魁首陈玉楼，这一部摇身一变成了胡八一。

hello~各位读者好，我是鸭血粉丝（大家可以称呼我为「阿粉」）。最近阿粉下班写作没灵感的时候就会去刷刷知乎，找找灵感，这不就有了今天这篇文章

是一种什么体验呢？