Mybatis并发下的缓存机制

Mybatis并发下的缓存机制

Mybatis的一级和二级缓存

一级缓存：默认是开启的，一次会话中的多次相同操作，只有第一次会去数据库查询，后续直接去缓存中拿数据！
1. 第1次查询记录，将查询到的数据写入到缓存中
2. 第2次查询的时候，首先从缓存中去读取数据，如果缓存中有数据，直接返回，而不去访问数据库了。
3. 如果这个会话执行了添加，修改，删除，提交，关闭清空当前会话的1级缓存。

二级缓存：默认是关闭的。
1.开启二级缓存配置：再核心配置文件mybatis-config.xml

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

2.如果是映射文件中的查询操作需要使用二级缓存，同学们直接在映射文件中上方加上 标签。
本映射文件中的全部查询将开启二级缓存！

3.注解的方式实现二级缓存
@CacheNamespace 对注解下的接口中的全部查询实现二级缓存

注意：二级缓存的对象必须实现序列化接口,如果缓存的对象太多，Mybatis可以把对象缓存到文件中。

那么并发下mybatis的缓存机制是怎么样的呢？接下来开始测试，本测试使用mysql数据库，为了测试全面，本文幅度偏长…

准备阶段：

项目结构：

mybatis工具类：

/**
 *  mybatis的会话工厂，提供获取会话和关闭会话的静态方法
 */
public class MybatisSqlSessionFactoryUtils {
    private static SqlSessionFactory factory;

    static {
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            factory = builder.build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *  获得会话对象
     * @return 会话对象
     */
    public static SqlSession getSqlSession() {
        return factory.openSession();
    }

    /**
     *  释放资源
     * @param sqlSession 会话对象
     */
    public static void close(SqlSession sqlSession) {
        if (sqlSession != null) {
            sqlSession.close();
        }
    }

数据库user表：

User包装类：

public class User implements Serializable {
    private static final long serialVersionUID = 1L;  //二级缓存使用
    private String loginName;
    private String userName;
    private String password;
    private Date createDate;

    public User() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", createDate=" + createDate +
                '}' + "\n";
    }

​ dao层：

@CacheNamespace	 //开启二级缓存时候使用
public interface UserMapper {

    //查询所有用户
    @Select("select * from tb_user")
    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "loginName", column = "login_name"),
            @Result(property = "userName", column = "user_name"),
            @Result(property = "createDate", column = "create_date")
    })
    List<User> findAll();

    //根据id修改用户
    @Update("update tb_user set user_name = #{userName} where id = #{id}")
    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "loginName", column = "login_name"),
            @Result(property = "userName", column = "user_name"),
            @Result(property = "createDate", column = "create_date")
    })
    int update(User user);
}

1. 本会话内提交事务：

/**
 *  1.Mybatis的一级缓存 本会话内提交事务
 */
@Test
public void testCacheSelect() {
    SqlSession sqlSession = null;
    try {
        sqlSession = MybatisSqlSessionFactoryUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //第一次查询user表数据
        List<User> users1 = userMapper.findAll();
        System.out.println(users1);

        User user = new User();
        user.setId(3);
        user.setUserName("天蓬元帅");  //将猪八戒修改为天蓬元帅
        int row = userMapper.update(user);
        //提交事务
        sqlSession.commit();
        System.out.println(row);

        System.out.println("----------------------------");

        //第二次查询user表数据
        List<User> users2 = userMapper.findAll();
        System.out.println(users2);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        MybatisSqlSessionFactoryUtils.close(sqlSession);
    }
}

控制台输出：

本会话内提交事务：通过日志清楚的看到执行了两次sql，即更新了缓存

2. Mybatis一级缓存 不同会话并发提交事务：

/**
 *  2.Mybatis一级缓存 不同会话并发提交事务：
 */
public void testCacheSelect1() {
    SqlSession sqlSession = null;
    try {
        sqlSession = MybatisSqlSessionFactoryUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //第一次查询user表数据
        List<User> users1 = userMapper.findAll();
        System.out.println(users1);

        System.out.println("----------------------------");
        //休眠10秒，先让其他线程提交事务
        Thread.sleep(10000);
        
        //第二次查询user表数据
        List<User> users2 = userMapper.findAll();
        System.out.println(users2);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        MybatisSqlSessionFactoryUtils.close(sqlSession);
    }
}

public void testCacheUpdate1() {
    SqlSession sqlSession = null;
    try {
        sqlSession = MybatisSqlSessionFactoryUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        User user = new User();
        user.setId(3);
        user.setUserName("天蓬元帅");
        int row = userMapper.update(user);
        //提交事务
        sqlSession.commit();
        System.out.println(row);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        MybatisSqlSessionFactoryUtils.close(sqlSession);
    }
}

testCacheSelect1 查询user表的控制台输出：

testCacheUpdate1 修改user表的控制台输出：

数据库数据：

Mybatis并发下的的一级缓存：
在第一次查询之后，哪怕有其他会话提交事务，重复读取缓存内的未更新数据

3. Mybatis二级缓存 不同会话并发提交事务

首先开启二级缓存：
文头详细说明了开启二级缓存的步骤，不多赘述，值得注意的是：User类需要序列化，否则控制台报错NotSerializableException

/**
 *  3.Mybatis的二级缓存:
 */
public void testCacheSelect2() {
    SqlSession sqlSession = null;
    try {
        sqlSession = MybatisSqlSessionFactoryUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

         //第一次查询user表数据
        List<User> users1 = userMapper.findAll();
        System.out.println(users1);

        System.out.println("----------------------------");
        //休眠10秒，先让其他线程提交事务
        Thread.sleep(10000);

        //第二次查询user表数据
        List<User> users2 = userMapper.findAll();
        System.out.println(users2);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        MybatisSqlSessionFactoryUtils.close(sqlSession);
    }
}

public void testCacheUpdate2() {
    SqlSession sqlSession = null;
    try {
        sqlSession = MybatisSqlSessionFactoryUtils.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        User user = new User();
        user.setId(3);
        user.setUserName("天蓬元帅");
        int row = userMapper.update(user);
         //提交事务
        sqlSession.commit();
        System.out.println(row);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        MybatisSqlSessionFactoryUtils.close(sqlSession);
    }
}

testCacheSelect2 查询user表的控制台输出：

testCacheUpdate2 修改user表的控制台输出：

数据库数据：

Mybatis并发下的的二级缓存：
在第一次查询之后，哪怕有其他会话提交事务，重复读取缓存内的未更新数据

总结

​1， 同一个会话内提交事务，mybatis会更新缓存，重新执行sql语句从数据 库中获取数据.

2， 不同会话并发提交事务，如果一个会话已经进行了数据库查询，即将数据加载进缓存中，那么即使不同会话提交了事务，再次执行相同的查询方法时， mybatis也不会更新缓存，而是直接命中缓存。考虑到这种缓存机制于mysql(本次测试用的数据库为mysql)的事务隔离级别"可重复读取"机制及其相似，有数据库类型因素的影响，后期继续测试不同数据库是否结果不同…