骑着蜗牛行天下
骑着蜗牛行天下

Mybatis的缓存：一级缓存，二级缓存

Mybatis缓存

Mybatis包含了一个非常强大的查询缓存特性，它可以很方便的配置和定制。Mybatis中的缓存实现的很多改进都已经实现了，
使得它更加强大而且易于配置。Mybatis默认情况下只会开启一级缓存，也就是局部的session会话缓存。

什么是查询缓存？查询缓存又有什么作用？
mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。

每一个session会话都有自己的缓存，这缓存是局部的，也就是所谓的一级缓存：

Mybatis的缓存：一级缓存，二级缓存_第1张图片

一级缓存是SqlSession级别的缓存，我们都知道在操作数据库时需要构造sqlSession对象，而在sqlSession对象中有一个数据
结构(HashMap)用于存储缓存数据。

Mybatis的缓存：一级缓存，二级缓存_第2张图片

从上图我们可以看出，一级缓存区域就是根据SqlSession为单位划分的。每次查询都会先从缓存区域找，如果找不到就会从
数据库查询数据，然后将查询到的数据写入一级缓存中，Mybatis内部存储缓存使用的是一个HashMap对象，key为hashCode+
sqlid+sql语句，而value值就是从查询出来的映射生成的Java对象。而为了保证缓存里面的数据肯定是准确数据避免脏读，每
次我们进行数据修改之后(增，删，改操作)就会执行commit操作，清空缓存区域。

Mybatis一级缓存

一级缓存是SqlSession级别的缓存，只要SqlSession没有flush或close，它就存在。

编写用户持久层Dao接口

/*
* 用户的持久层接口
* */
public interface IUserDao {
    //查询所有的用户,同时获取到用户下所有账户的信息
    List findAll();
    //查询方法，根据id进行查询用户信息
    User findById(Integer userId);
    //更新用户信息
    void updateUser(User user);
}

编写用户持久层映射文件

编写测试方法

package com.itheima.test;

import com.itheima.dao.IUserDao;
import com.itheima.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserTest {
    private InputStream resourceAsStream;
    private SqlSession sqlSession;
    private IUserDao userDao;
    private SqlSessionFactory factory;
    @Before
    public void init() throws IOException {
        //读取配制文件，生成字节输入流
        resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
        //获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获取SqlSession对象
        //如果这里传入一个参数true，那么就可以自动实现提交事务。后面就不需要再commit事务了。
        sqlSession = factory.openSession(true);
        //sqlSession = factory.openSession();
        //获取dao的代理对象
        userDao = this.sqlSession.getMapper(IUserDao.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务
        //sqlSession.commit();//这里就不要再提交事务了
        //释放资源
        sqlSession.close();
        resourceAsStream.close();
    }
    //测试同步的缓存
    @Test
    public void testClearCache(){
        //1.根据id查询用户信息
        User user1 = userDao.findById(41);
        System.out.println(user1);

        //2.再次查询id为41的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);

        System.out.println(user1 == user2);
    }
}

测试结果如下：
	我们可以发现，在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是Mybatis提供给我们的一级缓存
	在起作用了，因为一级缓存的存在，导致第二次查询id为41的记录时，并没有发出sql语句从数据库中查询数据，而是从一
	级缓存中查询。

Mybatis的缓存：一级缓存，二级缓存_第3张图片

一级缓存的分析

一级缓存是SqlSession范围的缓存，当调用SqlSession的修改，添加，删除，commit(),close()等方法时，就会清空一级缓存。

第一次查找用户id为41的用户信息，先去查找缓存中是否有id为41的用户信息，如果没有，从数据库中查询用户信息。
得到用户信息，将用户信息存储到一级缓存中。
如果sqlSession去执行commit操作(执行插入，更新，删除)，清空SqlSession中的一级缓存，这样做的目的是为了让缓存中
存储的是最新的信息，避免脏读数据。
第二次查询用户id为41的用户信息，先去查找缓存中是否有id为41的用户信息，缓存中有，直接从缓存中获取用户信息。

Mybatis的缓存：一级缓存，二级缓存_第4张图片

测试一级缓存的清空

public class UserTest {
    private InputStream resourceAsStream;
    private SqlSession sqlSession;
    private IUserDao userDao;
    private SqlSessionFactory factory;
    @Before
    public void init() throws IOException {
        //读取配制文件，生成字节输入流
        resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
        //获取SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获取SqlSession对象
        //如果这里传入一个参数true，那么就可以自动实现提交事务。后面就不需要再commit事务了。
        sqlSession = factory.openSession(true);
        //sqlSession = factory.openSession();
        //获取dao的代理对象
        userDao = this.sqlSession.getMapper(IUserDao.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务
        //sqlSession.commit();//这里就不要再提交事务了
        //释放资源
        sqlSession.close();
        resourceAsStream.close();
    }
    //测试一级缓存
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);

        //sqlSession.close();//关闭缓存
        //再次获取SqlSession对象
        //sqlSession=factory.openSession();
        sqlSession.clearCache();//此方法也可以清空缓存

        userDao=sqlSession.getMapper(IUserDao.class);

        User user2 = userDao.findById(41);
        System.out.println(user2);

        System.out.println(user1==user2);
    }
}
测试结果如图所示：

Mybatis的缓存：一级缓存，二级缓存_第5张图片

测试一级缓存的更新

//测试同步的缓存
    @Test
    public void testClearCache(){
        //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);
    }
测试结果如下：

Mybatis的缓存：一级缓存，二级缓存_第6张图片

Mybatis的二级缓存

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

Mybatis的缓存：一级缓存，二级缓存_第7张图片

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

	二级缓存区域是根据mapper的namespace划分的，相同namespace的mapper查询数据放在同一个区域，如果使用mapper代理
方法每个mapper的namespace都不同，此时可以理解为二级缓存区域是根据mapper划分，也就是根据命名空间来划分的，如果两个
mapper文件的命名空间一样，那样，不同的SqlSession之间就可以共享一个mapper缓存。

Mybatis的缓存：一级缓存，二级缓存_第8张图片

二级缓存的开启与关闭

第一步：在SqlMapperconfig.xml文件中开启二级缓存


    
        
    
因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置，为true代表开启二级缓存；为false代表不开启二级缓存。

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

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


    
    
    
	将 UserDao.xml 映射文件中的