mybatis的一级缓存详解

最新推荐文章于 2025-03-10 07:45:00 发布

乐乐Java路漫漫

最新推荐文章于 2025-03-10 07:45:00 发布

阅读量879

点赞数

分类专栏： mybatis 文章标签： mybatis

本文链接：https://blog.youkuaiyun.com/b1303110335/article/details/111866779

版权

mybatis 专栏收录该内容

3 篇文章

订阅专栏

文章目录

1、mybatis一级缓存是什么
2、代码示例
- 2.1.结果展示：
- 2.2.现象解析
3、有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据
4、总结

1、mybatis一级缓存是什么

使用缓存可以使应用更快的获取数据，避免频繁的数据库交互，尤其是在查询越多、缓存命中率越高的情况下，使用缓存的作用就越明显。

MyBatis作为持久化框架，提供了非常强大的查询缓存特性，可以非常方便的配置和定制使用。

一级缓存（也叫本地缓存）默认会启用，并且不能控制，因此很少提到，这里仅仅是介绍下一级缓存，了解一级缓存可以避免产生一些难以发现的错误。作为了解即可

2、代码示例

代码如下（示例）：

<select id="findUserById" parameterType="int" resultType="com.kkb.mybatis.phase01.po.User" >
		SELECT * FROM user WHERE id = #{id}
	</select>

@Test
	public void testSelect() {
		//创建UserMapper对象
		SqlSession sqlSession = sqlSessionFactory.openSession();
		UserMapper mapper = sqlSession.getMapper(UserMapper.class);
		//调用UserMapper对象的API
		User user1 = mapper.findUserById(1);
		user1.setUsername("newName");
		System.out.println(user1);

		User user2 = mapper.findUserById(1);
		System.out.println(user2);

		Assert.assertEquals(user1, user2);

		sqlSession.clearCache();

		SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
		UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

		User user3 = mapper2.findUserById(1);
		System.out.println(user3);
		System.out.println("(user1 == user3) = " + (user1 == user3));

		User user = new User();
		user.setSex("女");
		user.setUsername("wy45");
		user.setBirthday(new Date());
		user.setAddress("jx");
		int insert = mapper2.insert(user);
		System.out.println("插入成功 rows = " + insert);

		User user4 = mapper2.findUserById(1);
		System.out.println(user4);
		System.out.println("(user4 == user3) = " + (user4 == user3));

	}

2.1.结果展示：

2020-12-28 14:57:28.28 DEBUG PooledDataSource:405 - Created connection 2127036371.
2020-12-28 14:57:28.28 DEBUG JdbcTransaction:100 - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@7ec7ffd3]
2020-12-28 14:57:28.28 DEBUG findUserById:159 - ==>  Preparing: SELECT * FROM user WHERE id = ? 
2020-12-28 14:57:29.29 DEBUG findUserById:159 - ==> Parameters: 1(Integer)
2020-12-28 14:57:29.29 DEBUG findUserById:159 - <==      Total: 1
User [id=1, username=newName, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]
User [id=1, username=newName, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]


2020-12-28 15:19:54.54 DEBUG PooledDataSource:405 - Created connection 371439501.
2020-12-28 15:19:54.54 DEBUG findUserById:159 - ==>  Preparing: SELECT * FROM user WHERE id = ? 
2020-12-28 15:19:54.54 DEBUG findUserById:159 - ==> Parameters: 1(Integer)
2020-12-28 15:19:54.54 DEBUG findUserById:159 - <==      Total: 1
User [id=1, username=xly17, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]
(user1 == user3) = false
2020-12-28 15:19:54.54 DEBUG insert:159 - ==>  Preparing: insert into user (username, birthday, sex, address) values (?, ?, ?, ?) 
2020-12-28 15:19:54.54 DEBUG insert:159 - ==> Parameters: wy45(String), 2020-12-28(Date), 女(String), jx(String)
2020-12-28 15:19:54.54 DEBUG insert:159 - <==    Updates: 1
插入成功 rows = 1
2020-12-28 15:19:54.54 DEBUG findUserById:159 - ==>  Preparing: SELECT * FROM user WHERE id = ? 
2020-12-28 15:19:54.54 DEBUG findUserById:159 - ==> Parameters: 1(Integer)
2020-12-28 15:19:54.54 DEBUG findUserById:159 - <==      Total: 1
User [id=1, username=xly17, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]
(user4 == user3) = false

2.2.现象解析

从测试的代码看，获取user1后重新设置了userName，之后没有进行任何更新数据库的操作。在获取user2对象后，发现user2对象的userName的值竟然和user1重新设置后的值一样，再往下继续看，原来user1和user2竟然是同一个对象，之所以是这样就是因为MyBatis的一级缓存。

MyBatis的一级缓存存在于SqlSession的生命周期中，在同一个sqlSession中查询时，MyBatis会把执行的方法和参数通过算法生成缓存的键值，将键值和查询结果一起放入Map对象中。如果同一个SqlSession中执行的方法和参数完全一致，那么通过算法会生成相同的键值。当Map缓存对象中已经存在该键值时，则会返回缓存中的对象。

缓存中的对象和我们得到的结果是同一个对象那个，反复使用相同参数执行同一个方法时，总是返回同一个对象。

如果不想让findUserById使用一级缓存，可以做如下调整 flushCache="true"

<select id="findUserById" parameterType="int" resultType="com.kkb.mybatis.phase01.po.User" flushCache="true">
		SELECT * FROM user WHERE id = #{id}
	</select>

flushCache="true"后，每次在查询数据前都会清空当前的以及缓存，因此该方法每次都会从数据库中查询，此时user1, user2就是两个不同的实例了。要避免这样使用，会增加数据库的负担。

在关闭第一个SqlSession后了重新获取了一个SqlSession，因此有重新查询了user3，这时日志中输出了数据库的查询SQL，user3是一个新的实例，和 user1没有任何关系。 因为一级缓存是和SqlSession绑定的，只存在与SqlSession的生命周期中。

接下来执行insert操作，然后使用相同的方法和参数获取了user4。从日志和结果看，user3和user4是完全不同的两个对象。 因为任何的insert update delete 操作都会清空一级缓存，所以查询user4时由于缓存不存在，就会再次进行数据库的查询操作。

关于一级缓存的跟踪情况，通过上面的示例介绍完了，由于一级缓存是在默默的工作，因此要避免在使用过程中由于不了解而发生察觉不到的错误。

3、有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据

3.1代码如下：

//创建UserMapper对象
		SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
		UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
		SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
		UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

		//调用UserMapper对象的API
		User user1 = mapper1.findUserById(1);
		System.out.println("user1 = "+user1);

		User user = new User();
		user.setId(1);
		user.setUsername("xly22");
		int rows = mapper2.updateByPrimaryKey(user);
		System.out.println("更新成功 rows = " + rows);

		User user2 = mapper2.findUserById(1);
		System.out.println("user2 = " + user2);

		User user3 = mapper1.findUserById(1);
		System.out.println("user3 = " + user3);

3.2结果：

2020-12-28 15:34:22.22 DEBUG findUserById:159 - ==>  Preparing: SELECT * FROM user WHERE id = ? 
2020-12-28 15:34:22.22 DEBUG findUserById:159 - ==> Parameters: 1(Integer)
2020-12-28 15:34:22.22 DEBUG findUserById:159 - <==      Total: 1
user1 = User [id=1, username=xly17, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]
2020-12-28 15:34:22.22 DEBUG PooledDataSource:405 - Created connection 371439501.
2020-12-28 15:34:22.22 DEBUG updateByPrimaryKey:159 - ==>  Preparing: update user set username = ? where id = ? 
2020-12-28 15:34:22.22 DEBUG updateByPrimaryKey:159 - ==> Parameters: xly22(String), 1(Integer)
2020-12-28 15:34:22.22 DEBUG updateByPrimaryKey:159 - <==    Updates: 1
更新成功 rows = 1
2020-12-28 15:34:22.22 DEBUG findUserById:159 - ==>  Preparing: SELECT * FROM user WHERE id = ? 
2020-12-28 15:34:22.22 DEBUG findUserById:159 - ==> Parameters: 1(Integer)
2020-12-28 15:34:22.22 DEBUG findUserById:159 - <==      Total: 1
user2 = User [id=1, username=xly22, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]
user3 = User [id=1, username=xly17, birthday=Sun Dec 27 00:00:00 CST 2020, sex=男, address=浙江]

在session2将结果更新了之后，session1查询的user3仍旧是缓存中的数据，导致了脏数据。

3.3.我们的解决办法是:

1: xml增加配置 flushCache="true"

<select id="findUserById" parameterType="int" resultType="com.kkb.mybatis.phase01.po.User" flushCache="true">
		SELECT * FROM user WHERE id = #{id}
	</select>

2:一级缓存有连个选项，SESSION或者STATEMENT，默认是SESSION。
SESSION：这种情况下会缓存一个会话（SqlSession）中执行的所有查询
STATEMENT：本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据，在完成一次查询后就会清空掉一级缓存
<settings> <setting name="localCacheScope" value="STATEMENT"/> </settings>