MyBatis从入门到放弃六：延迟加载、一级缓存、二级缓存

前言

使用ORM框架我们更多的是使用其查询功能，那么查询海量数据则又离不开性能，那么这篇中我们就看下mybatis高级应用之延迟加载、一级缓存、二级缓存。使用时需要注意延迟加载必须使用resultMap，resultType不具有延迟加载功能。

一、延迟加载

延迟加载已经是老生常谈的问题，什么最大化利用数据库性能之类之类的，也懒的列举了，总是我一提到延迟加载脑子里就会想起来了Hibernate get和load的区别。OK，废话少说，直接看代码。 先来修改配置项xml。

注意，编写mybatis.xml时需要注意配置节点的先后顺序，settings在最前面，否则会报错。

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

前面提到延迟加载只能通过association、collection来实现，因为只有存在关联关系映射的业务场景里你才需要延迟加载，也叫懒加载，也就是常说的用的时候再去加载。OK，那么我们来配一个association来实现：

我来编写一个加载博客列表的同时加载出博客额作者， 主要功能点在id为blogAuthorResumtMap这个resultmap上，其中使用了association，关键点是它的select属性，该属性也就是你需要懒加载调用的statment id。 当然需要懒加载的statement 返回值当然是resultmap

<resultMap id="blogAuthorResumtMap" type="Blog">
        <id column="id" property="id"/>
        <result column="title" property="title"/>
        <result column="category" property="category"/>
        <result column="author_id" property="author_id"/>
        <!--使用assocition支持延迟加载功能，配置延迟加载关联关系-->
        <association property="author" javaType="Author" select="selectAuthorById" column="author_id"/>
    </resultMap>

    <!--要使用延迟记载的方法-->
    <select id="selectBlogAuthor" resultMap="blogAuthorResumtMap">
        SELECT id,title,category,author_id FROM t_blog
    </select>

    <!--延迟加载查询博客对应的作者方法-->
    <select id="selectAuthorById" parameterType="int" resultType="Author">
        SELECT id,name from t_author where id=#{value}
    </select>

OK，来看测试结果：

  @Test
    public void getBlogAuthorByLazyloading(){
        SqlSession sqlSession=null;
        try{
            sqlSession=sqlSessionFactory.openSession();
            List<Blog> list = sqlSession.selectList("com.autohome.mapper.Author.selectBlogAuthor");

            for (Blog blog:list) {
                System.out.println("id:"+blog.getId()+",title:"+blog.getTitle()+",category:"+blog.getCategory());
                System.out.println("author:"+blog.getAuthor().getName());
            }

        }catch(Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

　　

从图一中看出，执行selectBlogAuthor返回List<Blog>对象时只执行了SQL SELECT id,title,category,author_id from t_blog，循环遍历时才去执行select id,name from t_author where id=?。

二、一级缓存

了解缓存前我们先看一张图片（图片来源于传智播客视频图片）。从图中可以了解一级缓存是sqlsession级别、二级缓存是mapper级别。在操作数据库时我们需要先构造sqlsession【默认实现是DefaultSqlSession.java】，在对象中有一个数据结构【hashmap】来存储缓存数据。不同的sqlsession区域是互不影响的。 如果同一个sqlsession之间，如果多次查询之间执行了commit，则缓存失效，mybatis避免脏读。

OK，在看mybatis一级缓存时，我总是觉的一级缓存有点鸡肋，两个查询如果得到一样的数据，你还会执行第二次么，果断引用第一次的返回值了。 可能还没了解到一级缓存的奥妙之处。一级缓存默认是开启的，不需要额外设置，直接使用。

public void testCache(){
        SqlSession sqlSession=null;
        try{
            sqlSession=sqlSessionFactory.openSession();

            Author author = sqlSession.selectOne("com.autohome.mapper.Author.selectAuthorById",1);
            System.out.println("作者信息 id:"+author.getId()+",name:"+author.getName());

            author = sqlSession.selectOne("com.autohome.mapper.Author.selectAuthorById",1);
            System.out.println("作者信息2 id:"+author.getId()+",name:"+author.getName());

        }catch(Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

　　

从DEBUG截图来看，当我们第一次调用方法时执行了SELECT id,name from t_author where id=? 此时缓存中还没有该数据，则执行数据库查询，当再次执行时直接从缓存中读取。

执行demo后我们来看下这个查询过程保存到缓存的源码，先看下DefaultSqlSession.java。我们调用的selectOne()，从代码中看它是直接调用selectList()然后判断返回值size大小。

@Override
  public <T> T selectOne(String statement) {
    return this.<T>selectOne(statement, null);
  }

  @Override
  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.<T>selectList(statement, parameter);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

　　再跟踪到selectList方法，看到先构造MappedStatement对象，然后看到真正执行query()的是一个executor对象，在DefaultSqlSession.java中executor是成员变量，再翻到org.apache.ibatis.executor包中看到executor实际是一个接口。OK，那么我们debug时发现其引用是CachingExecutor。再打开CachingExecutor.java

@Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

　从CachingExecutor.java的两个query()可以看到先去构造CacheKey 再调用抽象类BaseExecutor.query(),这个也是最关键的一步。

//先创建CacheKey
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

//再执行查询方法
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, parameterObject, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

　　BaseExecutor.java

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

　　再看其中关键代码queryFromDatabase

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

　　OK，看了一长串，终于是有点眉目了，我们看到finally中先删除当前key缓存，然后再调用localCache.putObject把最新的结果集存入HashMap中。

　

三、二级缓存

了解二级缓存之前先来看副图（图片来自传智播客视频，非本人编写），那么从图中我们可以看出，mybatis二级缓存是mapper级别，也就是说不同的sqlmapper共享不同的内存区域，不同的sqlsession共享同一个内存区域，用mapper的namespace区别内存区域。

开启mybatis二级缓存： 1、设置mybatis.xml，也就是说mybatis默认二级缓存是关闭的。

2、设置mapper。在mapper.xml内添加标签：<cache/>

3、pojo实现接口Serializable。实现该接口后也就说明二级缓存不仅可以存入内存中，还可以存入磁盘。

OK，看一个二级缓存demo：

@Test
    public void testCache2(){
        SqlSession sqlSession=null;
        SqlSession sqlSession2=null;
        try{
            sqlSession=sqlSessionFactory.openSession();
            sqlSession2=sqlSessionFactory.openSession();

            Author author = sqlSession.selectOne("com.autohome.mapper.Author.selectAuthorById",1);
            System.out.println("作者信息 id:"+author.getId()+",name:"+author.getName());
            sqlSession.close();

            Author author2 = sqlSession2.selectOne("com.autohome.mapper.Author.selectAuthorById",1);
            System.out.println("作者信息2 id:"+author2.getId()+",name:"+author2.getName());
            sqlSession2.close();
        }catch(Exception e){
            e.printStackTrace();
        }finally {

        }
    }

运行demo可以看出二级缓存不同的地方在于Cache Hit Ratio，发出sql查询时先看是否命中缓存，第一次则是0.0 ，再次查询时则直接读取缓存数据，命中率是0.5。当然数据结构还是HashMap。

如果数据实时性要求比较高，可以设置select 语句的　

　

如果数据的查询实时性要求比较高，则设置select语句的useCache="false"，则每次都直接执行sql。

 <select id="selectBlogAuthor" resultMap="blogAuthorResumtMap" useCache="false">
        SELECT id,title,category,author_id FROM t_blog
    </select>

　　

参考

http://www.cnblogs.com/DoubleEggs/p/6243223.html

http://blog.csdn.net/isea533/article/details/44566257

时间： 2024-10-29 19:10:17

MyBatis从入门到放弃六：延迟加载、一级缓存、二级缓存的相关文章

Mybatis一级、二级缓存

一级缓存 首先做一个测试,创建一个mapper配置文件和mapper接口,我这里用了最简单的查询来演示. <mapper namespace="cn.elinzhou.mybatisTest.mapper.UserMapper"> <select id="findUsers" resultType="cn.elinzhou.mybatisTest.pojo.User"> SELECT * FROM user </se

【Hibernate】一级、二级缓存

本文讲述HIbernate中一级.二级缓存的概念以及如何使用. 一.大纲 2.什么是一级缓存 3.一级缓存示例展示 4.二级缓存以及示例展示 5.总结 二.什么是一级缓存 在hibernate中所谓的一级缓存就是session对象,但是一级缓存对提高性能的作用性并不是很大,其session主要的目的是管理实体对象的状态(临时.离线.持久化). 其缓存模型如下图: 三.一级缓存示例 3.1 查询(get,load, HQL) 3.1.1 get/load方法 @Test public void t

hibernate的一级和二级缓存

一级缓存就是Session级别的缓存,close后就没了. 二级缓存就是SessionFactory级别的缓存,全局缓存,要配置其他插件. 什么样的数据适合存放到第二级缓存中? 1.很少被修改的数据 2.不是很重要的数据,允许出现偶尔并发的数据 3.不会被并发访问的数据 4.参考数据 不适合存放到第二级缓存的数据? 1.经常被修改的数据 2.财务数据,绝对不允许出现并发 3.与其他应用共享的数据.         Hibernate的二级缓存策略的一般过程如下: 1) 条件查询的时候,总是发出一

hibernate的获取session的两方法比较，和通过id获取对象的比较，一级缓存二级缓存

opensession与currentsession的联系与区别 在同一个线程中opensession的session是不一样的,而currentsession获取的session是一样的,这就保证了线程的安全性.当然想要后者的session需要在配置文件中手动配置,另外我们可以写一个工具类来获得后者的session. get vs load 如果查询不到数据,get会会返回null但是不会报错 若果load查询不到数据,则会报错 get立即向db发送请求 ,如果你使用的是load查询数据,即使

MyBatis从入门到放弃七：二级缓存原理分析

前言 说起mybatis的一级缓存和二级缓存我特意问了几个身边的朋友他们平时会不会用,结果没有一个人平时业务场景中用. 好吧,那我暂且用来学习源码吧.一级缓存我个人认为也确实有些鸡肋,mybatis默认开启一级缓存,支持在同一个会话(sqlsession)同一个statement执行两次,则第二次会默认会使用第一次创建的缓存对象. 二级缓存前一篇粗略介绍了下,默认使用内存对象[PerpetualCache]内部维护一个HashMap对象来存储.那么先来看几张图片[图片来自一位朋友,文章最后参考连

MyBatis从入门到精通(六)：MyBatis动态Sql之if标签的用法

最近在读刘增辉老师所著的<MyBatis从入门到精通>一书,很有收获,于是将自己学习的过程以博客形式输出,如有错误,欢迎指正,如帮助到你,不胜荣幸! 本篇博客主要讲解如何使用if标签生成动态的Sql,主要包含以下3个场景: 根据查询条件实现动态查询 根据参数值实现动态更新某些列 根据参数值实现动态插入某些列 1. 使用if标签实现动态查询 假设有这样1个需求:根据用户的输入条件来查询用户列表,如果输入了用户名,就根据用户名模糊查询,如果输入了邮箱,就根据邮箱精确查询,如果同时输入了用户名和邮箱

mybatis学习--缓存（一级和二级缓存）

声明:学习摘要! MyBatis缓存 我们知道,频繁的数据库操作是非常耗费性能的(主要是因为对于DB而言,数据是持久化在磁盘中的,因此查询操作需要通过IO,IO操作速度相比内存操作速度慢了好几个量级),尤其是对于一些相同的查询语句,完全可以把查询结果存储起来,下次查询同样的内容的时候直接从内存中获取数据即可,这样在某些场景下可以大大提升查询效率. MyBatis的缓存分为两种: 一级缓存,一级缓存是SqlSession级别的缓存,对于相同的查询,会从缓存中返回结果而不是查询数据库 二级缓存,二级

mybatis一级缓存二级缓存

Mybatis对缓存提供支持,但是在没有配置的默认情况下,它只开启一级缓存,一级缓存只是相对于同一个SqlSession而言.所以在参数和SQL完全一样的情况下,我们使用同一个SqlSession对象调用一个Mapper方法,往往只执行一次SQL,因为使用SelSession第一次查询后,MyBatis会将其放在缓存中,以后再查询的时候,如果没有声明需要刷新,并且缓存没有超时的情况下,SqlSession都会取出当前缓存的数据,而不会再次发送SQL到数据库. 为什么要使用一级缓存,不用多说也知道

Mybatis 的一级、二级缓存?

1)一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存,其存储作用域为 Session,当 Session flush 或 close 之后,该 Session 中的所有 Cache 就 将清空,默认打开一级缓存. 2)二级缓存与一级缓存其机制相同,默认也是采用 PerpetualCache,HashMap 存储,不同在于其存储作用域为 Mapper(Namespace),并且可自定义存储源, 如 Ehcache.默认不打开二级缓存,要开启二级缓存,使用二级缓存属性类需