mybatis学习笔记7:缓存

一、mybatis中的延迟加载

1.问题

• 在一对多中，当一个用户含有100个账户。
  • 在查询用户的时候，要不要把所有的关联账户都查询出来？
  • 在查询账户的时候，要不要把关联的用户查询出来？
• 在查询用户时，因为一个用户含有多个账户,如果一次性全部查询出来且暂时不用，势必会浪费内存空间,所以这种时候往往选择什么时候使用，就什么时候查询。
• 在查询账户的时候，因为一个账户一定只对应一个用户，所以应当直接把账户所属的用户信息展示出来

2.延迟加载

• 综上，延迟加载就是在真正使用数据的时候才发起查询，不用的时候不查询。,按需加载(懒加载)

3.立即加载

• 不管用不用，只要一调用方法，马上发起查询。

4.业务选择

• 在对应的四种表关系中：一对多，多对一，一对一，多对多，一般情况下，按如下方式选择查询方式：
  • 一对多，多对多：通常情况下我们都是采用延迟加载。
  • 多对一，一对一：通常情况下我们都是采用立即加载。

5.一对一实现延迟加载

• 我们在前文一对多的示例代码上进行延迟加载的演示，当时实现了查询用户，并展示该用户下所有的账户信息，对于前文的代码，肯定是需要修改的

5.1实现account表的单表查询

• 配置IAccountDao.xml

    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id">id>
        <result property="uid" column="uid">result>
        <result property="money" column="money">result>
        

    resultMap>

    
    
    <select id="findAll" resultMap="accountUserMap">
      select  * from account

    select>

• AccountTest

    public void testFindAll(){
     
        //5.执行查询
        List<Account> accounts = accountDao.findAll();
        //6.打印
        for (Account account : accounts) {
     
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

5.2尝试配置xml，实现延迟加载

• IAccountDao.xml

    
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id">id>
        <result property="uid" column="uid">result>
        <result property="money" column="money">result>
        
        <association property="user" column="uid" javaType="user" select="com.xpt.dao.IUserDao.findById">

        association>

    resultMap>

• 测试AccountTest的findAll方法
  - 为什么这里还没有实现延迟呢？
  • 说明我们的配置没有完成

5.3主配置文件中开启延迟加载

   
    <settings>
        
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false">setting>
    settings>

5.4再次执行AccountTest的findAll方法观察

• 代码

    @Test
    public void testFindAll(){
     
        //5.执行查询
        List<Account> accounts = accountDao.findAll();
        //6.打印
        for (Account account : accounts) {
     
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

• 结果
  
• 修改findAll方法，不查询user信息，只是单独的findAll

    @Test
    public void testFindAll(){
     
        //5.执行查询
        List<Account> accounts = accountDao.findAll();
//        //6.打印
//        for (Account account : accounts) {
     
//            System.out.println(account);
            System.out.println(account.getUser());
//        }
    }

• 结果：
  

6.一对多实现延迟加载

查询一个用户的时候，延迟加载其多个关联的账户

6.1 IAccountDao定义根据用户id查询的方法和相关xml文件配置

• 方法

/**
     * 根据用户id 查询用户id
     * @param uid
     * @return
     */
    List<Account> findAccountByUid(Integer uid);

• 配置

 
    
    <select id="findAccountByUid" resultType="account">
        select * from account where uid = #{uid}
    select>

6.2IUserDao.xml配置相关延迟加载

    
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id">id>
        <result property="username" column="username">result>
        <result property="address" column="address">result>
        <result property="sex" column="sex">result>
        <result property="birthday" column="birthday">result>
        
        
        
        <collection property="accounts" ofType="account" select="com.xpt.dao.IAccountDao.findAccountByUid" column="id">

        collection>
    resultMap>


    
    
    <select id="findAll" resultMap="userAccountMap">
        select * from user
    select>

6.2测试方法

• 代码

    @Test
    public void testFindAll(){
     
        //5.执行查询
        List<User> users = userDao.findAll();
//        //6.打印
//        for (User user : users) {
     
//            System.out.println(user);
//            System.out.println(user.getAccounts());
//        }
    }

• 结果:
  

7.延迟查询使用小结

• 1.主配置文件的相关配置
• 2.映射配置文件的相关配置

二、mybatis的缓存

1.缓存的一些基本概念

1.1什么是缓存？

• 存在内存中的临时数据

1.2为什么使用缓存？

• 减少和数据库的交互次数，提高执行效率。

1.3什么样的数据能使用缓存，什么样的数据不能使用？

• 适用于缓存：
  • 经常查询并且不经常改变的。
  • 数据的正确与否对最终结果影响不大的。
• 不适用于缓存：
  • 经常改变的数据
  • 数据的正确与否对最终结果影响很大的。
  • 例如：商品的库存，银行的汇率

2.mybatis中的一级缓存

2.1一级缓存

• 它指的是Mybatis中SqlSession对象的缓存。
• 当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。
• 该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中查询是否有，有的话直接拿出来用。
• 当SqlSession对象消失时，mybatis的一级缓存也就消失了。

2.2代码实现

• 直接在测试类中测试方法

    @Test
    public void testFirstLevelCache(){
     
        User user1 = userDao.findById(41);
        System.out.println(user1);

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

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

    }

• 结果：二者是同一个对象，而且只完成了一次查询
  
  

2.3测试SqlSession对象消失时，mybatis的一级缓存也就消失了

• 代码

   @Test
    public void testFirstLevelCache(){
     
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //关闭当前的sqlSession
        sqlSession.close();
        //重新获取sqlSession
        sqlSession = factory.openSession(true);
        //重新获取mapper对象
        userDao = sqlSession.getMapper(IUserDao.class);

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

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

    }

• 结果:两次查询不再是同一对象，且实施了两次查询
  

2.4sqlSession.clearCache()清空缓存

除了上例的关闭再开启后，实现同样的效果可以利用sqlSession的清空缓存方法

• 代码：

    @Test
    public void testFirstLevelCache(){
     
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //关闭当前的sqlSession
//        sqlSession.close();
//        //重新获取sqlSession
//        sqlSession = factory.openSession(true);
//        //重新获取mapper对象
        sqlSession.clearCache();
        userDao = sqlSession.getMapper(IUserDao.class);

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

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

    }

• 结果：
  

3.触发清空一级缓存的情况

3.1sqlSession完成更新操作，会清空缓存

先完成对id=41的用户查询，然后更新id=41，然后再完成对id=41的查询，在更新id=41的时候，sqlSession会清空掉当前的缓存，当第二次查询的时候，sqlSession缓存中没有相应数据，只好在数据库中完成查询

• 代码

    /**
     * 测试会触发清空缓存的操作
     */
    @Test
    public void testClearCache(){
     
        //1.根据id查询用户
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //2.更新user1
        user1.setUsername("update name");
        user1.setAddress("update address");
        userDao.updateUser(user1);
        //提交事务，清空缓存
        sqlSession.commit();
        //3.再次查询id= user1.id的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);

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

• 结果：
  

3.2常见的清空sqlSession一级缓存的操作

三、mybatis的二级缓存

它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

1.使用步骤

• 第一步：让Mybatis框架支持二级缓存（在主配置文件SqlMapConfig.xml中配置）
• 第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
• 第三步：让当前的操作支持二级缓存（在select标签中配置）

2.实例

• 主配置文件SqlMapConfig.xml中配置

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

• IUserDao.xml中配置

   
    <cache/>

• 在select标签中配置

  
    <select id="findById" parameterType="Integer" resultType="com.xpt.domain.User" useCache="true">
        select * from user where id = #{id}
    select>

• 测试方法

    @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);
    }

• 结果：一次查询，两个不同的对象
  

3.为什么二级缓存查询出来的是两个不同的对象呢？

因为二级缓存，存储的是数据，而不是对象，当有新的查询从二级缓存中拿数据的时候，每一次都是把一个数据封装为一个新的对象。