Mybatis（四）— 一级缓存和二级缓存

• 介绍： 像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。

一级缓存

• 证明一级缓存的存在
  一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。
• 编写用户持久层 Dao 接口

public interface IUserDao {
	/**
	* 根据 id 查询
	* @param userId
	* @return
	*/
	User findById(Integer userId);
}

• 编写用户持久层映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="com.itheima.dao.IUserDao">
	<!-- 根据 id 查询 --> 
	<select id="findById" resultType="UsEr" parameterType="int" useCache="true">
		select * from user where id = #{uid}
	</select>
</mapper>

• 编写测试方法

public class UserTest {
	private InputStream in ;
	private SqlSessionFactory factory;
	private SqlSession session;
	private IUserDao userDao;
	
	@Test
	public void testFindById() {
		//6.执行操作
		User user = userDao.findById(41);
		System.out.println("第一次查询的用户："+user);
		User user2 = userDao.findById(41);
		System.out.println("第二次查询用户："+user2);
		System.out.println(user == user2);
	}
	
	@Before
	//在测试方法执行之前执行
	public void init()throws Exception {
		//1.读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2.创建构建者对象
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		//3.创建 SqlSession 工厂对象
		factory = builder.build(in);
		//4.创建 SqlSession 对象
		session = factory.openSession();
		//5.创建 Dao 的代理对象
		userDao = session.getMapper(IUserDao.class);
	}
	
	@After
	//在测试方法执行完成之后执行
	public void destroy() throws Exception{
		//7.释放资源
		session.close();
		in.close();
	} 
}

测试结果如下：

• 我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是 Mybatis 提供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询 id 为 41 的记录时，并没有发出 sql 语句从数据库中查询数据，而是从一级缓存中查询。
• 一级缓存的分析
  一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。
  
• 测试一级缓存的清空

	/**
	* 测试一级缓存
	*/
	@Test
	public void testFirstLevelCache(){
		User user1 = userDao.findById(41);
		System.out.println(user1);
		
		sqlSession.clearCache();//此方法也可以清空缓存

		userDao = sqlSession.getMapper(IUserDao.class);
		User user2 = userDao.findById(41);
		System.out.println(user2);
		System.out.println(user1 == user2);
	}
	/**
	* 测试缓存的同步
	*/
	@Test
	public void testClearlCache(){
		//1.根据 id 查询用户
		User user1 = userDao.findById(41);
		System.out.println(user1);
		//2.更新用户信息
		user1.setUsername("update user clear cache");
		user1.setAddress("北京市海淀区");
		userDao.updateUser(user1);
		//3.再次查询 id 为 41 的用户
		User user2 = userDao.findById(41);
		System.out.println(user2);
		System.out.println(user1 == user2);
	}
当执行sqlSession.close()后，再次获取sqlSession并查询id=41的User对象时，又重新执行了sql 
语句，从数据库进行了查询操作。

Mybatis 二级缓存

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

• 二级缓存结构图
  
  首先开启 mybatis 的二级缓存。
  sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
  如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。
  sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

二级缓存的开启与关闭

• 第一步：在 SqlMapConfig.xml 文件开启二级缓存

<settings>
	<!-- 开启二级缓存的支持 --> 
	<setting name="cacheEnabled" value="true"/>
</settings>
因为 cacheEnabled 取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；
为false 代表不开启二级缓存。

• 第二步：配置相关的 Mapper 映射文件

<cache>标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace值。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
	<mapper namespace="com.itheima.dao.IUserDao">
		<!-- 开启二级缓存的支持 -->
		<cache></cache>
	</mapper>

• 第三步：配置 statement 上面的 useCache 属性

<!-- 根据 id 查询 --> 
<select id="findById" resultType="user" parameterType="int" useCache="true">
	select * from user where id = #{uid}
</select> 
	将 UserDao.xml 映射文件中的<select>标签中设置 useCache=”true”代表当前这个 
statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

• 二级缓存测试

public class SecondLevelCacheTest {
private InputStream in;
private SqlSessionFactory factory; @Before//用于在测试方法执行之前执行
public void init()throws Exception{
//1.读取配置文件，生成字节输入流
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.获取 SqlSessionFactory
factory = new SqlSessionFactoryBuilder().build(in);
}@After//用于在测试方法执行之后执行
public void destroy()throws Exception{
in.close();
}
/**
* 测试一级缓存
*/
@Test
public void testFirstLevelCache(){
	SqlSession sqlSession1 = factory.openSession();
	IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
	User user1 = dao1.findById(41);
	System.out.println(user1);
	sqlSession1.close();//一级缓存消失
	
	SqlSession sqlSession2 = factory.openSession();
	IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
	User user2 = dao2.findById(41);
	System.out.println(user2);
	sqlSession2.close();
	System.out.println(user1 == user2);
	}
}

经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。

• 二级缓存注意事项

	当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，
这种就可以使用序列化
方式来保存对象。
public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address; 
} 

转载：https://blog.csdn.net/Mr_OO/article/details/102573733