Mybatis框架及原理实例分析

摘要

本篇文章只是个人阅读mybatis源码总结的经验或者个人理解mybatis的基本轮廓，作为抛砖引玉的功能，希望对你有帮助，如果需要深入了解细节还需亲自去阅读源码。

mybatis基本架构

mybatis的源码应该算是比较容易阅读的，首先mybatis核心功能就是执行sql语句，但在其基础上又有许多增强的地方（动态sql,orm等）。看一个框架的时候，第一步是对整个框架有一个大体的了解。例如mybatis，我们可以从初始化到完成一个sql请求为主线，看一下涉及了哪些类。我个人总结了一下，mybatis的框架主要的核心类有4个

configuration

configuration就是用于解析、保存、处理mybatis的配置内容，包括了

• mybatis基本配置，例如支持数据库中的字段支持下标转驼峰mapunderscoretocamelcase=true等等，参看mybatis配置说明
• sqlmapper管理，也就是通过xml或者注解写的一些sql映射。相关的类可以查看源码中mappedstatement类。
• 创建类,configuration还有一些创建类的功能，例如executor、statementhandler。这个2个类后面还会说到

小节configuration

总结configuration的功能，当然，如何读取和解析相关文件是configuration中大部分代码做的事。这些都是为了准备后面mybatis运行的基本条件。configuration中创建类是因为创建的这些类都依赖于configuration(但这样做数据和逻辑没有做到分离)。

sqlsession

sqlsession可能是mybatis中我们最常用的类，其实他是一个门面类，直接对外提供服务

public interface sqlsession extends closeable {
 <t> t selectone(string statement);
 <e> list<e> selectlist(string statement, object parameter);
 int delete(string statement);
 void rollback();
 void commit();
 ...

}

这些方法都是直接提供给外部调用的。看到这些方法是不是很亲切。（我个人在看源码的时候看到一些自己用过的一些类或方法的时候都有种莫名的亲近感。感觉终于和我的认知世界有交集了）

sqlsession的创建

sqlsessionfactor是用于创建sqlsession建造者，提供给外部快速创建一个sqlsession。是一个工厂类，而sqlsessionfactor的创建则是由sqlsessionfactorbuilder。

executor

前面说了sqlsession只是一个门面类，executor才是负责sql语句执行的。因此executor才是整个mybatis核心。executor的实现类有

• baseexecutor:看名字知道是最基础executor，其他的executor都和这个类有一定的关系
• cachingexecutor:每次查询的时候会先从缓存中获取，每次有增删改的时候会让缓存失效。cachingexecutor其实是一个代理内，内部代理了baseexecutor（或其子类）。在baseexecutor基础上增加了缓存操作。

相关类

我们看一个executor参数最多的一个方法

<e> list<e> query(mappedstatement ms, object parameter, rowbounds rowbounds, resulthandler resulthandler, cachekey cachekey, boundsql boundsql) throws sqlexception;

这些类都对执行sql有一定关系

mappedstatement

具体点来理解就是我们定义的sql映射语句，例如我们xml定义的：

<select id="selectcountbypath" parametertype="java.lang.string" resulttype="java.lang.long">
 select count(1) from config
 where path = #{path}
</select>

paramter

这个就是传递给sql映射的参数，用于生成和填充动态sql语句

rowbound

限定一次查询数据量，类很简单，看代码就明白，不多说

public class rowbounds {
 public static final int no_row_offset = 0;
 public static final int no_row_limit = integer.max_value;
 public static final rowbounds default = new rowbounds();
 private int offset;
 private int limit;
 public rowbounds() {
 this.offset = no_row_offset;
 this.limit = no_row_limit;
 }
 public rowbounds(int offset, int limit) {
 this.offset = offset;
 this.limit = limit;
 }
}

resulthandler

这个和本地缓存有关，用于保存一个查询语句的缓存对象，下次有相同的查询语句的时候就会先尝试从本地缓存中获取。 注意：

，mybatis有2级缓存，第一级是cachingexecutor，第二级缓存就是mybatis的本地缓存，也就是和resulthandler

缓存失效策略是和一级缓存一样，任何增删改都会清空本地缓存

cachekey

一个查询语句的在本地缓存中的key，根据sql语句，参数等等组成

boundsql

这个对象就是本次实际需要执行的sql语句有关的信息，

public class boundsql {
 private string sql;
 private list<parametermapping> parametermappings;
 private object parameterobject;
 private map<string, object> additionalparameters;
 private metaobject metaparameters;
 ...

如果说parameter参数是实际传入的参数，那么boundsql就是根据传入参数进行相关解析后的结果。他的创建在mappedstatement中，根据parameter和当前执行mappedstatement生成

public boundsql getboundsql(object parameterobject) {
 boundsql boundsql = sqlsource.getboundsql(parameterobject);
 list<parametermapping> parametermappings = boundsql.getparametermappings();
 if (parametermappings == null || parametermappings.isempty()) {
  boundsql = new boundsql(configuration, boundsql.getsql(), parametermap.getparametermappings(), parameterobject);
 }
 // check for nested result maps in parameter mappings (issue #30)
 for (parametermapping pm : boundsql.getparametermappings()) {
  string rmid = pm.getresultmapid();
  if (rmid != null) {
  resultmap rm = configuration.getresultmap(rmid);
  if (rm != null) {
   hasnestedresultmaps |= rm.hasnestedresultmaps();
  }
  }
 }
 return boundsql;
}

interceptor

mybatis提供了interceptor用于在执行executor之前进行一些操作，mybatis是怎么使用interceptor。其实就是在创建executor时候，会

public executor newexecutor(transaction transaction, executortype executortype) {
 executortype = executortype == null ? defaultexecutortype : executortype;
 executortype = executortype == null ? executortype.simple : executortype;
 executor executor;
 if (executortype.batch == executortype) {
  executor = new batchexecutor(this, transaction);
 } else if (executortype.reuse == executortype) {
  executor = new reuseexecutor(this, transaction);
 } else {
  executor = new simpleexecutor(this, transaction);
 }
 if (cacheenabled) {
  executor = new cachingexecutor(executor);
 }
 //看这里！！！
 executor = (executor) interceptorchain.pluginall(executor);
 return executor;
 }

这里主要是通过jdk动态代理实现的

public class plugin implements invocationhandler {
 ...
 public static object wrap(object target, interceptor interceptor) {
 map<class<?>, set<method>> signaturemap = getsignaturemap(interceptor);
 class<?> type = target.getclass();
 class<?>[] interfaces = getallinterfaces(type, signaturemap);
 if (interfaces.length > 0) {
  return proxy.newproxyinstance(
   type.getclassloader(),
   interfaces,
   new plugin(target, interceptor, signaturemap));
 }
 return target;
 }

 ...
 @override
 public object invoke(object proxy, method method, object[] args) throws throwable {
 try {
  set<method> methods = signaturemap.get(method.getdeclaringclass());
  if (methods != null && methods.contains(method)) {
  return interceptor.intercept(new invocation(target, method, args));
  }
  return method.invoke(target, args);
 } catch (exception e) {
  throw exceptionutil.unwrapthrowable(e);
 }
 }

这样在调用executor的时候就会先判断是否满足interceptor的执行条件，满足则会先执行intercepter#intercept()方法

最底层的handler

要说直接和jdbc打交道的就是各种handler类，例如

• statementhandler: 处理java.sql.statement
• parameterhandler: 向preparedstatement中设置参数
• resultsethandler：处理sql执行结果，并转换成指定的类对象 上面的这些其实都不复杂，所以代码还是比较好理解的

transaction

每个executor生成的时候都会把transaction传入，在baseexecutor中transaction是其成员变量，那transaction的作用是什么呢？

public interface transaction {
 connection getconnection() throws sqlexception;
 void commit() throws sqlexception;
 void rollback() throws sqlexception;
 void close() throws sqlexception;
 integer gettimeout() throws sqlexception;
}

其实之前一直都没提到过connect谁来管理，这里可以看出来，transaction负责了connection的获取，以及对这次connect的提交和回滚等操作。这个类也是比较好理解的。executor的commit或者rollback最后都是调用transaction的

总结

可以看出，mybatis的源码是比较容易阅读的（相对于spring等）。上面介绍了框架中的一些核心类，但是很多细节的地方值得我们去深挖。这个就需要我们能沉下来好好阅读代码。

原文链接：http://www.cnblogs.com/lizo/p/7281441.html