您的位置：首页 > 其它

MyBatis的一级缓存和二级缓存

2017-04-12 15:20 525 查看

mybatis缓存介绍

如下图，是mybatis一级缓存和二级缓存的区别图解：



一级缓存：

Mybatis一级缓存的作用域是同一个SqlSession，在同一个sqlSession中两次执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。当一个sqlSession结束后该sqlSession中的一级缓存也就不存在了。Mybatis默认开启一级缓存。

二级缓存：

Mybatis二级缓存是多个SqlSession共享的，其作用域可以是当前Mapper，也可以是跨越多个Mapper，可以通过
<cache/>
和
<cache-ref namespace=""/>
进行设置。

注意：MyBatis默认实现的一二级缓存是使用HashMap存储的。

在开启二级缓存的情况下：

在同一个Mapper二级缓存里面，执行多次sql语句的情况是：首先查找二级缓存里面是否有数据，如果没有就找一级缓存，再没有，才会查找数据库。

在二级缓存没有开启的情况下

查找数据的顺序是：查看一级缓存里面是否能够找到，找不到就在数据库里面找！！

Mybatis默认没有开启二级缓存需要在setting全局参数中配置开启二级缓存。

一级缓存

原理

下图是根据id查询用户的一级缓存图解：



一级缓存区域是根据SqlSession为单位划分的。

每次查询会先从缓存区域（这里指的是一级缓存，这里还没有开启二级缓存）找，如果找不到从数据库查询，查询到数据将数据写入缓存。

Mybatis内部存储缓存（包括一级和二级缓存）使用一个HashMap，key为hashCode+sqlId+Sql语句。value为从查询出来映射生成的java对象

一级缓存里面sqlSession执行insert、update、delete等操作会清空一级缓存区域。注意一级缓存清空的时机是insert、update、delete中，commit事务之前。

下面的代码用到的基础类：

实体类Item.java（商品实体）：

public class Item{
private Integer id;
private String name;
private Double price;
private String detail;
private byte[] pic;
private Date createtime;


实体类User.java（用户实体）：

public class User{
private Integer id;
private String username;
private Date birthday;
private Integer sex;
private String address;


ItemMapper.xml映射文件：

<?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="cn.domarvel.dao.ItemMapper">
<select id="findItemByLikeName" resultType="cn.domarvel.po.Item">
SELECT * FROM items WHERE name LIKE concat('%',#{name},'%')
</select>
</mapper>


UserMapper.xml映射文件：

<?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="cn.domarvel.dao.UserMapper">
<select id="findUserByLikeName" resultType="cn.domarvel.po.User">
SELECT * FROM user WHERE username LIKE concat('%',#{username},'%')
</select>
<update id="updateUserById">
UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
</update>
</mapper>


ItemMapper.java

public interface ItemMapper {
public List<Item> findItemByLikeName(String name) throws Exception;
}


UserMapper.java

public interface UserMapper {
public List<User> findUserByLikeName(String username) throws Exception;
public void updateUserById(User user) throws Exception;
}


测试代码一（关闭sqlSession清空缓存区）：

@Test
public void testUserAndItems() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

//关闭sqlSession就清空一级缓存
sqlSession.close();

sqlSession=sqlSessionFactory.openSession();
userMapper=sqlSession.getMapper(UserMapper.class);
itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


日志输出：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 988458918.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - Returned connection 988458918 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 988458918 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1


测试代码二（更新操作清空缓存）：

@Test
public void testUserAndItemsClearOneCache() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

User targetUpdateUser=new User(34, "小Q", new Date(), 1, "四川南充");
userMapper.updateUserById(targetUpdateUser);
//只有提交事务后，数据库数据才会被修改。但是可以看到这里并没有commit事务操作就清空一级缓存了，说明清空一级缓存的时机是在userMapper.updateUserById()方法中

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


日志输出

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 988458918.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - ==>  Preparing: UPDATE user SET username=?,birthday=?,sex=?,address=? where id=?
DEBUG [main] - ==> Parameters: 小Q(String), 2017-04-12 21:45:45.107(Timestamp), 1(Integer), 四川南充(String), 34(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1


总结：

一级缓存总是开启的。

清空缓存有两种情况：1.关闭sqlSession，缓存被清空。2.用同一个sqlSession进行增加，更新，删除操作，sqlSession里面的缓存被清空。注意这里一级缓存被清空的时机是insert、update、delete中，commit事务之前。

手动通过代码
sqlSession.clearCache();
也能够清空一级缓存。

清空缓存是清空sqlSession里面存储的所有信息，包括不同sql查询的信息

一级缓存应用

正式开发，是将mybatis和spring进行整合开发，事务控制在service中。

一个service方法中包括 很多mapper方法调用。

service{
//开始执行时，开启事务，创建SqlSession对象
//第一次调用mapper的方法findUserById(1)

//第二次调用mapper的方法findUserById(1)，从一级缓存中取数据
//方法结束，sqlSession关闭
}


如果是执行两次service调用查询相同 的用户信息，不走一级缓存，因为session方法结束，sqlSession就关闭，一级缓存就清空。

二级缓存

原理



二级缓存默认是关闭的，所以首先开启mybatis的二级缓存。

sqlSession1去查询用户id为1的用户信息，查询到的用户信息将在sqlSession1被关闭时存储到二级缓存，未关闭sqlSession时是被存储到一级缓存中的。

sqlSession2去查询用户id为1的用户信息，去二级缓存中找是否存在数据，如果存在直接从二级缓存中取出数据。二级不存在就在一级缓存中查找。一级不存在就在数据库中查找。

如果SqlSession3去执行相同 mapper下sql，执行commit提交，清空该 mapper下的二级缓存区域的数据。注意清空是删除所有缓存数据。

二级缓存与一级缓存区别，二级缓存的范围更大，一个Mapper里面多个sqlSession共享一个二级缓存区域。

每个Mapper配置文件都可以有一个二级缓存，通过标签
<cache/>
进行配置，通过
<cache/>
配置的是Mapper中独立的二级缓存。如果某个Mapper不想要重新申请独立的二级缓存，而是想要共用其它Mapper的二级缓存，可以通过
<cache-ref namespace=""/>
进行分享共用。

开启二级缓存

mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中声明使用哪种类型的二级缓存或者是共用其它Mapper的二级缓存。
<cache/>
默认是使用MyBatis自身实现的二级缓存，以后我们可能会用到分布式缓存，那个时候我们就需要配置其它的缓存实现。

<caChe/>
标签的常用参数讲解

第一步：

在核心配置文件SqlMapConfig.xml的settings标签中加入

<setting name="cacheEnabled" value="true"/>


第一步目的：开启总的二级缓存

名称描述允许值默认值
cacheEnabled对在此配置文件下的所有cache 进行全局性开/关设置。true或者falsetrue
sqlMapConfig.xml核心配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 和spring整合后 environments配置将废除-->
<!--
下面的两个标签environments和environment对应的属性default和id能够填入的值：
work：工作模式
development：开发模式
注意：不能够乱写
-->
<properties resource="db.properties"></properties>

<settings>
<!-- 打开延迟加载 的开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 将积极加载改为消极加载即按需要加载 -->
<setting name="aggressiveLazyLoading" value="false"/>
<setting name="cacheEnabled" value="true"/>
</settings>

<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理，事务控制由MyBatis-->
<transactionManager type="JDBC" />
<!-- 数据库连接池，由MyBatis管理-->
<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文件 -->
<package name="cn.domarvel.dao"/>
</mappers>
</configuration>


db.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?&useServerPrepStmts=true&cachePrepStmts=true
jdbc.username=root
jdbc.password=


第二步：

在Mapper映射文件中修改配置：

ItemMapper.xml

<?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="cn.domarvel.dao.ItemMapper">
<!-- 开启当前Mapper的独立二级缓存，当然可以通过配置共用其它Mapper的二级缓存。 -->
<cache/>
<select id="findItemByLikeName" resultType="cn.domarvel.po.Item">
SELECT * FROM items WHERE name LIKE concat('%',#{name},'%')
</select>
</mapper>


UserMapper.xml

<?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="cn.domarvel.dao.UserMapper">
<!-- 共用ItemMapper中的二级缓存 -->
<cache-ref namespace="cn.domarvel.dao.ItemMapper"/>
<select id="findUserByLikeName" resultType="cn.domarvel.po.User">
SELECT * FROM user WHERE username LIKE concat('%',#{username},'%')
</select>
<update id="updateUserById">
UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
</update>
</mapper>


第三步：

在开启了二级缓存后，pojo等实体类还必须实现序列化接口！！

Item.java实体类：

public class Item implements Serializable{
private Integer id;
private String name;
private Double price;
private String detail;
private byte[] pic;
private Date createtime;


User.java实体类：

public class User implements Serializable{
private Integer id;
private String username;
private Date birthday;
private Integer sex;
private String address;


实现序列化接口的目的是为了将缓存数据取出执行反序列化操作。因为二级缓存数据存储介质多种多样，不一定在内存。存储在内存中就不需要序列化操作。

理论测试：

不同Mapper共用一个二级缓存

测试代码：

@Test
public void testUserAndItems() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

//关闭流，清空一级缓存。在清空一级缓存的同时才会保存数据到二级缓存。注意是关闭流的sqlSession的时候才会保存数据到二级缓存。
//想想为什么要关闭sqlSession才会保存数据到二级缓存？？因为未关闭sqlSession之前一直是使用一级缓存，而关闭后，一级缓存就才会用不了，这个时候就应该把数据从一级缓存转到二级缓存。
sqlSession.close();

sqlSession=sqlSessionFactory.openSession();
userMapper=sqlSession.getMapper(UserMapper.class);
itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


输出日志：

DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250391581.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Returned connection 1250391581 to pool.
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.3333333333333333
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.5


可以看出，两个Mapper共用一个二级缓存成功！！

同时我们也能够知道当sqlSession关闭时，会把一级缓存清空，并且会把数据保存到二级缓存。

其中Cache Hit Ratio是缓存的击中率！

测试数据查询顺序：

@Test
public void testUserAndItems() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

//如果不关闭sqlSession流，数据就还没有被保存到二级缓存中。
//而我们查找数据时顺序是：二级缓存->一级缓存->数据库
//既然二级缓存没有，他就会到一级缓存中查找，一级缓存只要没有被更新、删除、增加数据和关闭sqlSession就不会被清空。
//一级缓存的清空时机是更新、删除、增加中，commit提交事务之前

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


输出日志：

DEBUG [main] - Reader entry: <?xml version="1.0" encoding="UTF-8" ?>
DEBUG [main] - Checking to see if class cn.domarvel.dao.ItemMapper matches criteria [is assignable to Object]
DEBUG [main] - Checking to see if class cn.domarvel.dao.UserMapper matches criteria [is assignable to Object]
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250391581.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0


可以看到几次的二级缓存查找的点中率都为0.0，而且也没有发送sql语句去查询数据库，所以只能是从一级缓存中查找到数据。

所以上面的操作并没有发生把数据保存到二级缓存中的事件。

这也证实了开启二级缓存后的查找数据顺序：二级缓存->一级缓存->数据库

其中没有开启二级缓存时查找数据的顺序：一级缓存->数据库

测试当数据未存储到二级缓存时，反而中途清空一级缓存，第二次查找时会怎么找数据：

当然，不用测试都能知道，肯定是数据库查找啦！！哈哈。

@Test
public void testUserAndItems() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

//通过修改数据来清空一级缓存，其中清空一级缓存的时机是在事务commit之前,updateUserById()中。读者可以用DEBUG调试查看！！
User targetUpdateUser=new User(34, "小狼", new Date(), 1, "四川南充");
userMapper.updateUserById(targetUpdateUser);
sqlSession.commit();

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


日志输出：

DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250391581.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - ==>  Preparing: UPDATE user SET username=?,birthday=?,sex=?,address=? where id=?
DEBUG [main] - ==> Parameters: 小狼(String), 2017-04-12 19:05:57.134(Timestamp), 1(Integer), 四川南充(String), 34(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1


注意：就算清空了一级缓存，当sqlSesion.close()关闭后，也能够保存数据到二级缓存！！

二级缓存清空时机：

@Test
public void testUserAndItemsTwoCacheXX() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

//关闭sqlSession就清空一级缓存
sqlSession.close();

sqlSession=sqlSessionFactory.openSession();
userMapper=sqlSession.getMapper(UserMapper.class);
itemMapper=sqlSession.getMapper(ItemMapper.class);

User targetUpdateUser=new User(34, "小K", new Date(), 1, "四川南充");
userMapper.updateUserById(targetUpdateUser);
//注意，这里并没有进行sqlSession.commit()进行事务提交，在事务提交之前就已经"清空"缓存数据了。"清空"二级缓存是在insert,update,delete中。

List<User> users3=userMapper.findUserByLikeName("小明");
List<Item> items3=itemMapper.findItemByLikeName("本");

}


日志输出：

DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250391581.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Returned connection 1250391581 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 1250391581 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: UPDATE user SET username=?,birthday=?,sex=?,address=? where id=?
DEBUG [main] - ==> Parameters: 小K(String), 2017-04-14 08:59:45.899(Timestamp), 1(Integer), 四川南充(String), 34(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.3333333333333333
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.5
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1


总结：

看日志可以看到，虽然有击中率，但是还是查询了数据库，通过update方法没有真正的清空二级缓存数据，因为击中率的问题。但是起到的效果和完全清空二级缓存数据的效果一样，都查询了数据库，并且返回的也是最新数据库中的数据。

想要真正的清空二级缓存，可以使用sqlSession.commit()操作。

读者可以用上面的例子进行试验，在update后把sqlSession.commit()操作加上。

对于笔者我来说，清空二级缓存的时机还是在update中。

笔者认为本质上清空缓存的时机是在：insert,update,delete中，sqlSession.commit()事务之前。而sqlSession.commit()是清除表面上的东西。

清空二级缓存的时机和清空一级缓存类似，都有在insert、update、delete中，sqlSession.commit()之前。其中清空一级缓存的时机还有，在sqlSession关闭时也会清空一级缓存。

这里要说一点
<caChe/>
里面有个
readOnly="true"
的参数，如果为true则返回缓存对象的引用，如果为false则返回缓存对象的copy对象。这个过程比较慢，但是安全。readOnly的默认值为false。

温馨提示：

有很多程序员误以为只要是在同一个namespace下就是共有一个二级缓存。其实并不是这样的。事实是每个Mapper通过
<cache/>
能够申请独立且互不干扰的二级缓存，如果某个Mapper想不申请二级缓存，而是想要共用其它的二级缓存，可以通过
<cache-ref namespace=""/>
进行配置共用。在相同命名空间下也是这样操作的。

MyBatis可以很细粒度的控制某些sql语句是否需要二级缓存：

在statement中设置useCache=false可以禁用当前select语句的二级缓存，即该sql查询不会去访问二级缓存，当sqlSession关闭时，数据也不会保存到二级缓存。默认情况是true，即该sql使用二级缓存。

<select id="findUserByLikeName" resultType="cn.domarvel.po.User" useCache="true">
SELECT * FROM user WHERE username LIKE concat('%',#{username},'%')
</select>


总结：如果数据想要比较新的可以设置此条sql不进行二级缓存。注意 
userCache="false"
只能够关闭当前sql语句的二级缓存，并不能关闭一级缓存，所以如果一级缓存中有比较老的数据可以使用
sqlSession.clearCache();
进行清空一级缓存。

修改UserMapper.xml文件，修改查询不需要二级缓存：

<?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="cn.domarvel.dao.UserMapper">
<!-- 共用ItemMapper中的二级缓存 -->
<cache-ref namespace="cn.domarvel.dao.ItemMapper"/>
<select id="findUserByLikeName" resultType="cn.domarvel.po.User" useCache="true">
SELECT * FROM user WHERE username LIKE concat('%',#{username},'%')
</select>
<update id="updateUserById">
UPDATE user SET username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
</update>
</mapper>


关闭User模糊查询的二级缓存后的效果

@Test
public void testUserAndItemsTwoCacheShutDown() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

sqlSession.close();
sqlSession=sqlSessionFactory.openSession();
userMapper=sqlSession.getMapper(UserMapper.class);
itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


输出结果：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1177377518.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@462d5aee]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@462d5aee]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@462d5aee]
DEBUG [main] - Returned connection 1177377518 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 1177377518 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@462d5aee]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.5


可以看到关闭User模糊查询的二级缓存后，User模糊查询并没有通过二级缓存来保存数据，也没有通过二级缓存取数据，和Item的查询比较后就知道区别。

因为中途关闭了sqlSession，清空了一级缓存，所以User就从数据库中查找，而Item就从二级缓存中查找。

如果需求中需要最新的数据，我们可以这么做：

@Test
public void testUserAndItemsTwoCacheClearCache() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
//在这里我们已经指定关闭了User模糊查询的二级缓存
//清空一级缓存
sqlSession.clearCache();

List<User> users2=userMapper.findUserByLikeName("小明");
}


日志输出：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1177377518.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@462d5aee]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3


我们看到，每一次的查询都是发送的sql语句，所以这查询的是最新的数据，适合需要最新数据的需求！！

刷新缓存（清空缓存）

在同一个Mapper的二级缓存中，如果有其它insert、update、delete操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读。
flushCache="true"
能够防止脏读。

设置statement配置中的
flushCache="true"
属性，默认情况下为true即刷新缓存，如果改成false则不会刷新。使用缓存时如果手动修改数据库表中的查询数据会出现脏读。

设置insert、update、delete是否刷新缓存的设置代码如下：

<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User" flushCache="true">


总结：一般执行完insert、update、delete后都会刷新缓存（虽然要commit后才会生效，但是它在commit之前就已经清空缓存了，可以通过DEBUG调试测试），flushCache=true表示刷新缓存，这样可以避免数据库脏读。

在测试一级缓存前要关闭二级缓存，虽然能够达到目的，但是看起来不好看！！

测试
flushCache=“true”
是否对一级缓存有效果：

@Test
public void testUserAndItemsClearxOneCache() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

User targetUpdateUser=new User(34, "小Q", new Date(), 1, "四川南充");
userMapper.updateUserById(targetUpdateUser);
//这里并没有写sqlSession.commit()进行数据库更新，但是在updateUserById()时就会清空缓存
//但是我们设置了刷新缓存为false，我们的目的就是测试此设置是否对一级缓存有效果。

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


日志输出：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 988458918.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3aeaafa6]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - ==>  Preparing: UPDATE user SET username=?,birthday=?,sex=?,address=? where id=?
DEBUG [main] - ==> Parameters: 小Q(String), 2017-04-13 17:31:05.49(Timestamp), 1(Integer), 四川南充(String), 34(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1


可以看到，
fluchCache="false"
对关闭一级缓存的刷新没有效果。

现在测试更新操作时是否关闭二级缓存的刷新缓存效果：

@Test
public void testUserAndItemsClearxTwoCache() throws Exception{
SqlSession sqlSession=sqlSessionFactory.openSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
ItemMapper itemMapper=sqlSession.getMapper(ItemMapper.class);

List<User> users1=userMapper.findUserByLikeName("小明");
List<Item> items1=itemMapper.findItemByLikeName("本");

sqlSession.close();

sqlSession=sqlSessionFactory.openSession();
userMapper=sqlSession.getMapper(UserMapper.class);
itemMapper=sqlSession.getMapper(ItemMapper.class);

User targetUpdateUser=new User(34, "小Q", new Date(), 1, "四川南充");
userMapper.updateUserById(targetUpdateUser);
//这里没有写sqlSession.commit()进行数据库更新，但是在updateUserById()时就会清空缓存

List<User> users2=userMapper.findUserByLikeName("小明");
List<Item> items2=itemMapper.findItemByLikeName("本");
}


日志输出：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 1250391581.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE username LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 小明(String)
DEBUG [main] - <==      Total: 3
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM items WHERE name LIKE concat('%',?,'%')
DEBUG [main] - ==> Parameters: 本(String)
DEBUG [main] - <==      Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - Returned connection 1250391581 to pool.
DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Checked out connection 1250391581 from pool.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4a87761d]
DEBUG [main] - ==>  Preparing: UPDATE user SET username=?,birthday=?,sex=?,address=? where id=?
DEBUG [main] - ==> Parameters: 小Q(String), 2017-04-13 17:39:49.396(Timestamp), 1(Integer), 四川南充(String), 34(Integer)
DEBUG [main] - <==    Updates: 1
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.3333333333333333
DEBUG [main] - Cache Hit Ratio [cn.domarvel.dao.ItemMapper]: 0.5


很明显，更新操作执行后，第二次进行查询数据时并没有发送sql语句查询数据库，说明
flushCache="false"
不进行刷新二级缓存配置生效。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航