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>

以上这篇mybatis 延迟加载、一级缓存、二级缓存(详解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。

原文链接：http://www.cnblogs.com/sword-successful/p/7400685.html