28Mybatis_查询缓存-二级缓存-二级缓存测试-

二级缓存原理：

aaarticlea/png;base64,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" alt="" />

首先开启mybatis的二级缓存。

sqlSession1去查询用户id为1的用户信息，查询到用户信息会将查询数据存储到二级缓存中。

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

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

二级缓存与一级缓存区别，二级缓存的范围更大，多个sqlSession可以共享一个UserMapper的二级缓存区域。

UserMapper有一个二级缓存区域（按namespace分），其它mapper也有自己的二级缓存区域（按namespace分）。

每一个namespace的mapper都有一个二缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。

准备工作：

开启二级缓存

mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。

在核心配置文件SqlMapConfig.xml中加入

	描述	允许值	默认值
cacheEnabled	对在此配置文件下的所有cache 进行全局性开/关设置。	true false	true

aaarticlea/png;base64,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" alt="" />

在UserMapper.xml中开启二缓存，UserMapper.xml下的sql执行完成会存储到它的缓存区域（HashMap）。

aaarticlea/png;base64,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" alt="" />

测试：

第一步：在ordersMapperCustom.xml中开启二级缓存：

<mapper namespace="cn.itcast.mybatis.mapper.OrdersMapperCustom">

  <cache></cache>

第二步：编写pojo类(要实现Serializable)必须要实现的：

为什么要实现Serializable接口呢：

为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一样在内存。

package cn.itcast.mybatis.po;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

public class User implements Serializable {

private int id;//对应数据库中主键

private String username;//对应数据库中用户的名称

private Date birthday;//对应数据库中的生日

private String sex;//性别

private String address;//地址

//一个用户对应多个订单表

private List<Orders> ordersList;

public List<Orders> getOrdersList() {

    return ordersList;

}

public void setOrdersList(List<Orders> ordersList) {

    this.ordersList = ordersList;

}

public int getId() {

    return id;

}

public void setId(int id) {

    this.id = id;

}

public String getUsername() {

    return username;

}

public void setUsername(String username) {

    this.username = username;

}

public Date getBirthday() {

    return birthday;

}

public void setBirthday(Date birthday) {

    this.birthday = birthday;

}

public String getSex() {

    return sex;

}

public void setSex(String sex) {

    this.sex = sex;

}

public String getAddress() {

    return address;

}

public void setAddress(String address) {

    this.address = address;

}

}

第三步；编写测试代码：

package cn.itcast.mybatis.test;

import java.io.IOException;

import java.io.InputStream;

import java.util.Date;

import java.util.List;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.Before;

import org.junit.Test;

import cn.itcast.mybatis.mapper.OrdersMapperCustom;

import cn.itcast.mybatis.mapper.userMapper;

import cn.itcast.mybatis.po.Orders;

import cn.itcast.mybatis.po.User;

import cn.itcast.mybatis.po.UserCustom;

import cn.itcast.mybatis.po.UserQueryVo;

public class Mybatis_mappertest {

    private SqlSessionFactory sqlSessionFactory;

    @Before

    public void setup() throws IOException

    {   String resource="SqlMapConfig.xml";

        InputStream inputStream= Resources.getResourceAsStream(resource);

        //主要是生成SqlsessionFactory。

        this.sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);

    }

    @Test

    public void testMaper()

    {

        SqlSession sqlSession1=null;

        SqlSession sqlSession2=null;

        sqlSession1=sqlSessionFactory.openSession();

        sqlSession2=sqlSessionFactory.openSession();

        //生成代理类

        OrdersMapperCustom orderMapper=sqlSession1.getMapper(OrdersMapperCustom.class);

         OrdersMapperCustom orderMapper2=sqlSession2.getMapper(OrdersMapperCustom.class);


        User user=orderMapper.finduserByid(1);

        //这个close必须要加，不然缓存存不进去。

        sqlSession1.close();

        User user2=orderMapper2.finduserByid(1);

        sqlSession2.close();

    }

}

运行结果：DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5bae4145]
DEBUG [main] - ==> Preparing: SELECT * FROM USER WHERE ID=?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <== Total: 1
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@5bae4145]
DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@5bae4145]
DEBUG [main] - Returned connection 1538146629 to pool.
DEBUG [main] - Cache Hit Ratio [cn.itcast.mybatis.mapper.OrdersMapperCustom]: 0.5

发现只有一条select语句，说明在执行第二条 User user2=orderMapper2.finduserByid(1)时，二级缓存发挥了作用。

我们注意到：

 //生成两个sqlsession。因为二级缓存，多个sqlSession可以共享一个UserMapper的二级缓存区域。UserMapper有一个二级缓存区域（按namespace分）      
        SqlSession sqlSession1=null;

        SqlSession sqlSession2=null;

        sqlSession1=sqlSessionFactory.openSession();

        sqlSession2=sqlSessionFactory.openSession();

        //生成代理类

        OrdersMapperCustom orderMapper=sqlSession1.getMapper(OrdersMapperCustom.class);

        OrdersMapperCustom orderMapper2=sqlSession2.getMapper(OrdersMapperCustom.class);

                  User user=orderMapper.finduserByid(1);

                    User user2=orderMapper2.finduserByid(1);

这里的orderMapper，orderMapper2是不同的sqlSession生成的。但是没关系，二级缓存的作用范围是1.跨sqlSession.  2.

每一个namespace的mapper都有一个二缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。

--------------------------------------------------------------------------------------------------------------------------------------------------------------

清空缓存的操作：

// 二级缓存测试

    @Test

    public void testCache2() throws Exception {

        SqlSession sqlSession1 = sqlSessionFactory.openSession();

        SqlSession sqlSession2 = sqlSessionFactory.openSession();

        SqlSession sqlSession3 = sqlSessionFactory.openSession();

        // 创建代理对象

        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);

        // 第一次发起请求，查询id为1的用户

        User user1 = userMapper1.findUserById(1);

        System.out.println(user1);

        //这里执行关闭操作，将sqlsession中的数据写到二级缓存区域

        sqlSession1.close();

        //使用sqlSession3执行commit()操作

        UserMapper userMapper3 = sqlSession3.getMapper(UserMapper.class);

        User user  = userMapper3.findUserById(1);

        user.setUsername("张明明");

        userMapper3.updateUser(user);

        //执行提交，清空UserMapper下边的二级缓存

        sqlSession3.commit();

        sqlSession3.close();

        UserMapper userMapper2 =    sqlSession2.getMapper(UserMapper.class);

        // 第二次发起请求，查询id为1的用户，因为前面的操作清除了缓存，所以这里的操作会重新从数据库中去查询。

        User user2 = userMapper2.findUserById(1);

        System.out.println(user2);

        sqlSession2.close();

    }

---------------------------------------------------------------------------------------------------------------------------------------------------------

有没有这样的一种情况，一个mapper.xml中，有些sql语句是要缓存功能的，但是有些sql语句我不想他具有缓存功能，需要每次都从数据库中得到数据？可以

在statement中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。

<select id="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">

总结：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

这样的话这个mapper.xml中别的sql语句具有二级缓存的功能，这句sql语句就没有了缓存功能，每次读取数据时都要从数据库中去读数据。

--------------------------------------------------------------------------------------------------------------------------------------------------------

刷新缓存（就是清空缓存）

在mapper的同一个namespace中，如果有其它insert、update、delete操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读。

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

如下：

总结：一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。