转载：https://www.cnblogs.com/wuzhenzhao/p/11103017.html
先来看一下MyBatis 的编程式使用的方法：
public void testMapper() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlogById(1);
System.out.println(blog);
} finally {
session.close();
}
}
我们再来捋MyBatis 的主要工作流程：首先在MyBatis 启动的时候我们要去解析配置文件，包括全局配置文件和映射器配置文件，这里面包含了我们怎么控制MyBatis 的行为，和我们要对数据库下达的指令，也就是我们的SQL 信息。我们会把它们解析成一个Configuration 对象。接下来就是我们操作数据库的接口，它在应用程序和数据库中间，代表我们跟数据库之间的一次连接：这个就是SqlSession 对象。我们要获得一个会话， 必须有一个会话工厂SqlSessionFactory 。SqlSessionFactory 里面又必须包含我们的所有的配置信息，所以我们会通过一个Builder 来创建工厂类。
我们知道，MyBatis 是对JDBC 的封装，也就是意味着底层一定会出现JDBC 的一些核心对象，比如执行SQL 的Statement，结果集ResultSet。在Mybatis 里面，SqlSession 只是提供给应用的一个接口，还不是SQL 的真正的执行对象。我们通过查看SqlSession源码发现，SqlSession 持有了一个Executor 对象，用来封装对数据库的操作。在执行器Executor 执行query 或者update 操作的时候我们创建一系列的对象，来处理参数、执行SQL、处理结果集，这里我们把它简化成一个对象：StatementHandler，这个就是MyBatis 主要的工作流程，如图：
MyBatis 架构分层与模块划分：
在MyBatis 的主要工作流程里面，不同的功能是由很多不同的类协作完成的，它们分布在MyBatis jar 包的不同的package 里面。我们来看一下MyBatis 的jar 包（基于3.5.1）
跟Spring 一样，MyBatis 按照功能职责的不同，所有的package 可以分成不同的工作层次。我们可以把MyBatis 的工作流程类比成餐厅的服务流程。
第一个是跟客户打交道的服务员，它是用来接收程序的工作指令的，我们把它叫做接口层。
第二个是后台的厨师，他们根据客户的点菜单，把原材料加工成成品，然后传到窗口。这一层是真正去操作数据的，我们把它叫做核心层。
最后就是餐厅也需要有人做后勤（比如清洁、采购、财务），来支持厨师的工作和整个餐厅的运营。我们把它叫做基础层。
来看一下这张图，我们根据刚才的分层，和大体的执行流程，做了这么一个总结。当然，从不同的角度来描述，架构图的划分有所区别，这张图画起来也有很多形式。我们先从总体上建立一个印象。
接口层：
首先接口层是我们打交道最多的。核心对象是SqlSession，它是上层应用和MyBatis打交道的桥梁，SqlSession 上定义了非常多的对数据库的操作方法。接口层在接收到调用请求的时候，会调用核心处理层的相应模块来完成具体的数据库操作。
核心处理层：
接下来是核心处理层。既然叫核心处理层，也就是跟数据库操作相关的动作都是在这一层完成的。核心处理层主要做了这几件事：
- 把接口中传入的参数解析并且映射成JDBC 类型；
- 解析xml 文件中的SQL 语句，包括插入参数，和动态SQL 的生成；
- 执行SQL 语句；
- 处理结果集，并映射成Java 对象。
插件也属于核心层，这是由它的工作方式和拦截的对象决定的。
基础支持层：
最后一个就是基础支持层。基础支持层主要是一些抽取出来的通用的功能（实现复用），用来支持核心处理层的功能。比如数据源、缓存(请点击跳转至缓存详解)、日志、xml 解析、反射、IO、事务等等这些功能。
这个就是MyBatis 的主要工作流程和架构分层。
从以上的编程式的例子来看，mybatis的工作流程大致可以分为一下四步：
- 通过建造者模式创建一个工厂类，定位，加载，解析配置文件的就是在这一步完成的，包括mybatis-config.xml 和Mapper 适配器文件。
- 通过SqlSessionFactory 创建一个SqlSession。
- 获得Mapper 对象。
- 调用接口方法(insert,delete,update,select)。
第一步配置解析过程：
定位资源位置，加载资源，将xml加载成流这里就不分析了。
String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource);
首先我们要清楚的是配置解析的过程全部只解析了两种文件。一个是mybatis-config.xml 全局配置文件。另外就是可能有很多个的Mapper.xml 文件，也包括在Mapper 接口类上面定义的注解。我们从mybatis-config.xml 开始。在之前已经分析了核心配置了，大概明白了MyBatis 有哪些配置项，和这些配置项的大致含义。这里我们再具体看一下这里面的标签都是怎么解析的，解析的时候做了什么。
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
首先我们new 了一个SqlSessionFactoryBuilder，非常明显的建造者模式，它里面定义了很多个build 方法的重载，最终返回的是一个SqlSessionFactory 对象（单例模式）。我们点进去build 方法。这里面创建了一个XMLConfigBuilder 对象（Configuration 对象也是这个时候创建的）。
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
SqlSessionFactory var5;
try {
// 创建全局文件解析器
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
// 调用解析，解析完构建默认的SessionFactory
var5 = this.build(parser.parse());
} catch (Exception var14) {
throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
} finally {
ErrorContext.instance().reset();
try {
inputStream.close();
} catch (IOException var13) {
}
}
return var5;
}
XMLConfigBuilder 是抽象类BaseBuilder 的一个子类，专门用来解析全局配置文件，针对不同的构建目标还有其他的一些子类，比如：XMLMapperBuilder：解析Mapper 映射器，XMLStatementBuilder：解析增删改查标签。
根据我们解析的文件流，这里后面两个参数都是空的，创建了一个parser。这里有两步，第一步是调用parser 的parse()方法，它会返回一个Configuration类。也就是配置文件里面所有的信息都会放在Configuration 里面。Configuration 类里面有很多的属性，有很多是跟config 里面的标签直接对应的。
public Configuration parse() {
// 判断是否已经解析过
if (this.parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
} else {
this.parsed = true;
// 解析的开始
this.parseConfiguration(this.parser.evalNode("/configuration"));
return this.configuration;
}
}
首先会检查是不是已经解析过，也就是说在应用的生命周期里面，config 配置文件只需要解析一次，生成的Configuration 对象也会存在应用的整个生命周期中。接下来就是parseConfiguration 方法：
这下面有十几个方法，对应着config 文件里面的所有一级标签。MyBatis 全局配置文件的顺序不可以颠倒。
private void parseConfiguration(XNode root) {
try {
this.propertiesElement(root.evalNode("properties"));
Properties settings = this.settingsAsProperties(root.evalNode("settings"));
this.loadCustomVfs(settings);
this.loadCustomLogImpl(settings);
this.typeAliasesElement(root.evalNode("typeAliases"));
this.pluginElement(root.evalNode("plugins"));
this.objectFactoryElement(root.evalNode("objectFactory"));
this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
//解析settings标签
this.settingsElement(settings);
this.environmentsElement(root.evalNode("environments"));
this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
this.typeHandlerElement(root.evalNode("typeHandlers"));
this.mapperElement(root.evalNode("mappers"));
} catch (Exception var3) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
}
}
在settings标签的解析中，我们就可以看到对应官网上介绍的各种配置，及其默认值，所有的值，都会赋值到Configuration 的属性里面去。简单的来看一下：
private void settingsElement(Properties props) {
this.configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
this.configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
this.configuration.setCacheEnabled(this.booleanValueOf(props.getProperty("cacheEnabled"), true));//二级缓存
this.configuration.setProxyFactory((ProxyFactory)this.createInstance(props.getProperty("proxyFactory")));
this.configuration.setLazyLoadingEnabled(this.booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
this.configuration.setAggressiveLazyLoading(this.booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
this.configuration.setMultipleResultSetsEnabled(this.booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
this.configuration.setUseColumnLabel(this.booleanValueOf(props.getProperty("useColumnLabel"), true));
this.configuration.setUseGeneratedKeys(this.booleanValueOf(props.getProperty("useGeneratedKeys"), false));
this.configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));//默认执行器类型
this.configuration.setDefaultStatementTimeout(this.integerValueOf(props.getProperty("defaultStatementTimeout"), (Integer)null));
this.configuration.setDefaultFetchSize(this.integerValueOf(props.getProperty("defaultFetchSize"), (Integer)null));
this.configuration.setMapUnderscoreToCamelCase(this.booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
this.configuration.setSafeRowBoundsEnabled(this.booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
this.configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));//本地缓存级别
this.configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
this.configuration.setLazyLoadTriggerMethods(this.stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
this.configuration.setSafeResultHandlerEnabled(this.booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
this.configuration.setDefaultScriptingLanguage(this.resolveClass(props.getProperty("defaultScriptingLanguage")));
this.configuration.setDefaultEnumTypeHandler(this.resolveClass(props.getProperty("defaultEnumTypeHandler")));
this.configuration.setCallSettersOnNulls(this.booleanValueOf(props.getProperty("callSettersOnNulls"), false));
this.configuration.setUseActualParamName(this.booleanValueOf(props.getProperty("useActualParamName"), true));
this.configuration.setReturnInstanceForEmptyRow(this.booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
this.configuration.setLogPrefix(props.getProperty("logPrefix"));
this.configuration.setConfigurationFactory(this.resolveClass(props.getProperty("configurationFactory")));
}
最后就是<mappers>标签的解析，对应匹配如下四种方式：
<!-- 使用相对于类路径的资源引用 --> <mappers> <mapper resource="org/mybatis/builder/AuthorMapper.xml"/> <mapper resource="org/mybatis/builder/BlogMapper.xml"/> <mapper resource="org/mybatis/builder/PostMapper.xml"/> </mappers> <!-- 使用完全限定资源定位符（URL） --> <mappers> <mapper url="file:///var/mappers/AuthorMapper.xml"/> <mapper url="file:///var/mappers/BlogMapper.xml"/> <mapper url="file:///var/mappers/PostMapper.xml"/> </mappers> <!-- 将包内的映射器接口实现全部注册为映射器 --> <mappers> <package name="org.mybatis.builder"/> </mappers>
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
首先会判断是不是接口，只有接口才解析；然后判断是不是已经注册了，单个Mapper重复注册会抛出异常。如果是以资源位置及URL的配置方式，还需要创建Mapper解析器解析。
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
Iterator var2 = parent.getChildren().iterator();
while(true) {
while(var2.hasNext()) {
XNode child = (XNode)var2.next();
String resource;
//配置包的方式
if ("package".equals(child.getName())) {
resource = child.getStringAttribute("name");
//解析完加入全局配置类，填充属性
this.configuration.addMappers(resource);
} else {
resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
XMLMapperBuilder mapperParser;
InputStream inputStream;
//配置以资源的方式
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
inputStream = Resources.getResourceAsStream(resource);
mapperParser = new XMLMapperBuilder(inputStream, this.configuration, resource, this.configuration.getSqlFragments());
mapperParser.parse();
//配置以URL的方式
} else if (resource == null && url != null && mapperClass == null) {
ErrorContext.instance().resource(url);
inputStream = Resources.getUrlAsStream(url);
mapperParser = new XMLMapperBuilder(inputStream, this.configuration, url, this.configuration.getSqlFragments());
mapperParser.parse();
// 配置以class单个接口 方式
} else {//都没配置报异常
if (resource != null || url != null || mapperClass == null) {
throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
}
Class<?> mapperInterface = Resources.classForName(mapperClass);
this.configuration.addMapper(mapperInterface);
}
}
}
return;
}
}
}
XMLMapperBuilder.parse()方法，是对Mapper 映射器的解析。里面有两个方法：configurationElement()—— 解析所有的子标签， 其中 buildStatementFromContext()最终获得MappedStatement 对象。bindMapperForNamespace()——把namespace（接口类型）和工厂类绑定起来。
无论是按package 扫描，还是按接口扫描，最后都会调用到MapperRegistry 的addMapper()方法。最后，MapperRegistry 也会放到Configuration 里面去。MapperRegistry 里面维护的其实是一个Map 容器，存储接口和代理工厂的映射关系。
public <T> void addMapper(Class<T> type) {
if (type.isInterface()) {//判断是否接口
if (this.hasMapper(type)) { //是否已经注册
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
boolean loadCompleted = false;
try {//利用Map来维护mapper
this.knownMappers.put(type, new MapperProxyFactory(type));
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(this.config, type);
parser.parse();//解析
loadCompleted = true;
} finally {
if (!loadCompleted) {//注册过程出现异常，移除
this.knownMappers.remove(type);
}
}
}
}
除了映射器文件，在这里也会去解析Mapper 接口方法上的注解。在addMapper()方法里面创建了一个MapperAnnotationBuilder，我们点进去看一下parse()方法。parseCache() 和parseCacheRef() 方法其实是对@CacheNamespace 和@CacheNamespaceRef 这两个注解的处理。parseStatement()方法里面的各种getAnnotation()，都是对注解的解析，比如@Options，@SelectKey，@ResultMap 等等。最后同样会解析成MappedStatement 对象，也就是说在XML 中配置，和使用注解配置，最后起到一样的效果。
public void parse() {
String resource = this.type.toString();
if (!this.configuration.isResourceLoaded(resource)) {
this.loadXmlResource();//加载XML资源
this.configuration.addLoadedResource(resource);
this.assistant.setCurrentNamespace(this.type.getName());
this.parseCache();//解析@CacheNamespace注解
this.parseCacheRef();//解析@CacheNamespaceRef注解
Method[] methods = this.type.getMethods();
Method[] var3 = methods;
int var4 = methods.length;
for(int var5 = 0; var5 < var4; ++var5) {
Method method = var3[var5];
try {
if (!method.isBridge()) {
this.parseStatement(method);//处理各种注解
}
} catch (IncompleteElementException var8) {
this.configuration.addIncompleteMethod(new MethodResolver(this, method));
}
}
}
this.parsePendingMethods();
}
最后会将这些解析的结果填充倒Configuration中。在这一步，我们主要完成了config 配置文件、Mapper 文件、Mapper 接口上的注解的解析。我们得到了一个最重要的对象Configuration，这里面存放了全部的配置信息，它在属性里面还有各种各样的容器。最后，返回了一个DefaultSqlSessionFactory，里面持有了Configuration 的实例。如下是第一阶段的时序图：
第二步会话创建过程：
这是第二步， 我们跟数据库的每一次连接， 都需要创建一个会话， 我们用openSession()方法来创建。
SqlSession session = sqlSessionFactory.openSession();
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
DefaultSqlSession var8;
try {
//从先前所解析的配置中获取环境
Environment environment = this.configuration.getEnvironment();
//获取事务工厂类
TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
//创建事务
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//创建执行器类 默认SIMPLE
Executor executor = this.configuration.newExecutor(tx, execType);
//创建默认的SqlSession
var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
} catch (Exception var12) {
this.closeTransaction(tx);
throw ExceptionFactory.wrapException("Error opening session. Cause: " + var12, var12);
} finally {
ErrorContext.instance().reset();
}
return var8;
}
这个会话里面，需要包含一个Executor 用来执行SQL。Executor 又要指定事务类型和执行器的类型。所以我们会先从Configuration 里面拿到Enviroment，Enviroment 里面就有事务工厂。创建事务会有以下两种选择：
如果配置的是JDBC，则会使用Connection 对象的commit()、rollback()、close()管理事务。如果配置成MANAGED，会把事务交给容器来管理，比如JBOSS，Weblogic。如果是Spring + MyBatis ， 则没有必要配置， 因为我们会直接在applicationContext.xml 里面配置数据源和事务管理器，覆盖MyBatis 的配置。
我们知道，Executor 的基本类型有三种：SIMPLE、BATCH、REUSE，默认是SIMPLE（settingsElement()读取默认值），他们都继承了抽象类BaseExecutor。
- SimpleExecutor：每执行一次update 或select，就开启一个Statement 对象，用完立刻关闭Statement 对象。
- ReuseExecutor：执行update 或select，以sql 作为key 查找Statement 对象，存在就使用，不存在就创建，用完后，不关闭Statement 对象，而是放置于Map 内，供下一次使用。简言之，就是重复使用Statement 对象。
- BatchExecutor：执行update（没有select，JDBC 批处理不支持select），将所有sql 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement 对象，每个Statement 对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC 批处理相同。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
//判断使用的执行器类型，之所以判断两次是防止手贱的人把执行器配置为空
executorType = executorType == null ? this.defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Object 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 (this.cacheEnabled) {//是否启用二级缓存，启用了进行包装
executor = new CachingExecutor((Executor)executor);
}
//插件包装，转换成拦截器链interceptorChain，对于插件我下一篇博客会详细介绍
Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
return executor;
}
如果配置了cacheEnabled=ture，会用装饰器模式对executor 进行包装：newCachingExecutor(executor)。最终返回DefaultSqlSession，属性包括Configuration、Executor 对象。
总结：创建会话的过程，我们获得了一个DefaultSqlSession，里面包含了一个Executor，它是SQL 的执行者。
第三步获得Mapper 对象：
现在我们已经有一个DefaultSqlSession 了，必须找到Mapper.xml 里面定义的Statement ID，才能执行对应的SQL 语句。找到Statement ID 有两种方式：一种是直接调用session 的方法，在参数里面传入Statement ID，这种方式属于硬编码，我们没办法知道有多少处调用，修改起来也很麻烦。另一个问题是如果参数传入错误，在编译阶段也是不会报错的，不利于预先发现问题。
Blog blog = (Blog) session.selectOne("com.wuzz.mapper.BlogMapper.selectBlogById", 1);
所以在MyBatis 后期的版本提供了第二种方式，就是定义一个接口，然后再调用Mapper 接口的方法。由于我们的接口名称跟Mapper.xml 的namespace 是对应的，接口的方法跟statement ID 也都是对应的，所以根据方法就能找到对应的要执行的SQL。
BlogMapper mapper = session.getMapper(BlogMapper.class);
在这里我们主要研究一下Mapper 对象是怎么获得的，它的本质是什么。DefaultSqlSession 的getMapper()方法，调用了Configuration 的getMapper()方法。继而调到 MapperRegistry.getMapper：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return this.mapperRegistry.getMapper(type, sqlSession);
}
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
} else {
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception var5) {
throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
}
}
}
我们知道，在解析mapper 标签和Mapper.xml 的时候已经把接口类型和类型对应的MapperProxyFactory 放到了一个Map 中。获取Mapper 代理对象，实际上是从Map 中获取对应的工厂类后，最终通过代理模式返回代理对象。
那么JDK 动态代理和MyBatis 用到的JDK 动态代理有什么区别呢？JDK 动态代理代理，在实现了InvocationHandler 的代理类里面，需要传入一个被代理对象的实现类。而在mybatis里面，我们并没有实现了InvocationHandler 的代理类。不需要实现类的原因：我们只需要根据接口类型+方法的名称，就可以找到Statement ID 了，而唯一要做的一件事情也是这件，所以不需要实现类。在MapperProxy里面直接执行逻辑（也就是执行SQL）就可以。
获得Mapper 对象的过程，实质上是获取了一个MapperProxy 的代理对象。MapperProxy 中有sqlSession、mapperInterface、methodCache。
第四步执行sql：
由于所有的Mapper 都是MapperProxy 代理对象，所以任意的方法都是执行MapperProxy 的invoke()方法。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {//首先判断是否需要去执行SQL，还是直接执行方法。
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
}
//Object 本身的方法和Java 8 中接口的默认方法不需要去执行SQL。
if (this.isDefaultMethod(method)) {
return this.invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
//获取缓存 这里加入缓存是为了提升MapperMethod 的获取速度
MapperMethod mapperMethod = this.cachedMapperMethod(method);
return mapperMethod.execute(this.sqlSession, args);
}
接下来又调用了mapperMethod 的execute 方法，我们debug来看一下：
MapperMethod 里面主要有两个属性， 一个是SqlCommand (SQL命令)， 一个是MethodSignature(方法签名)，这两个都是MapperMethod 的内部类。另外定义了多个execute()方法。
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
Object param;//根据不同的type 和返回类型 调用sqlSession 的insert()、update()、delete()、selectOne ()方法
switch(this.command.getType()) {
case INSERT:
// 调用convertArgsToSqlCommandParam()将参数转换为SQL 的参数。
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
break;
case UPDATE:
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
break;
case DELETE:
param = this.method.convertArgsToSqlCommandParam(args);
result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
break;
case SELECT://查询的方法又要根据返回类型进行区分执行
if (this.method.returnsVoid() && this.method.hasResultHandler()) {
this.executeWithResultHandler(sqlSession, args);
result = null;
} else if (this.method.returnsMany()) {
result = this.executeForMany(sqlSession, args);
} else if (this.method.returnsMap()) {
result = this.executeForMap(sqlSession, args);
} else if (this.method.returnsCursor()) {
result = this.executeForCursor(sqlSession, args);
} else {
param = this.method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(this.command.getName(), param);
if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH://刷新statement
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + this.command.getName());
}
if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
} else {
return result;
}
}
我们以查询 (mapper1.selectBlogById(1002)) 为例 会走如下代码，会走到selectOne()方法。
public <T> T selectOne(String statement, Object parameter) {
List<T> list = this.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;
}
}
这里抛得异常是不是很熟悉，经常有小伙伴在开发过程中会发现sql执行报这个异常，是因为定义的sql是查询的一个结果，可是返回了多个，这里会执行selectList(statement, parameter):
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
List var5;
try {//获取初始化阶段所封装的对象先根据command name（Statement ID）从Configuration中拿到MappedStatement
MappedStatement ms = this.configuration.getMappedStatement(statement);
var5 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception var9) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + var9, var9);
} finally {
ErrorContext.instance().reset();
}
return var5;
}
这个ms 上面有我们在xml 中配置的所有属性，包括id、statementType、sqlSource、useCache、入参、出参等等。
然后执行了Executor 的query()方法。前面我们说到了Executor 有三种基本类型，SIMPLE/REUSE/BATCH，还有一种包装类型，CachingExecutor。那么在这里到底会选择哪一种执行器呢？我们要回过头去看看DefaultSqlSession 在初始化的时候是怎么赋值的，这个就是我们的会话创建过程。如果启用了二级缓存，就会先调用CachingExecutor 的query()方法，里面有缓存相关的操作，然后才是再调用基本类型的执行器，比如默认的SimpleExecutor。在没有开启二级缓存的情况下，先会走到BaseExecutor 的query()方法（否则会先走到CachingExecutor）。
BaseExecutor:
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
从Configuration 中获取MappedStatement， 然后从BoundSql 中获取SQL 信息，创建CacheKey。这个CacheKey 就是缓存的Key。然后再调用另一个query()方法。
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 (this.closed) {
throw new ExecutorException("Executor was closed.");
} else {//queryStack 用于记录查询栈，防止递归查询重复处理缓存。flushCache=true 的时候，会先清理本地缓存（一级缓存）
if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
//清除缓存
this.clearLocalCache();
}
List list;
try {
++this.queryStack;
list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
if (list != null) {//从缓存中获取数据
this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {//如果没有缓存，会从数据库查询：queryFromDatabase()
list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
--this.queryStack;
}
if (this.queryStack == 0) {
Iterator var8 = this.deferredLoads.iterator();
while(var8.hasNext()) {
BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)var8.next();
deferredLoad.load();
}
this.deferredLoads.clear();
//如果LocalCacheScope == STATEMENT，会清理本地缓存。
if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
this.clearLocalCache();
}
}
return list;
}
}
从数据库查询(queryFromDatabase)：
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
// 先在缓存用占位符占位。执行查询后，移除占位符，放入数据。
this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
List list;
try {//执行Executor 的doQuery()；默认是SimpleExecutor。
list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
this.localCache.removeObject(key);
}
this.localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
this.localOutputParameterCache.putObject(key, parameter);
}
return list;
}
SimpleExecutor.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
List var9;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = this.prepareStatement(handler, ms.getStatementLog());
var9 = handler.query(stmt, resultHandler);
} finally {
this.closeStatement(stmt);
}
return var9;
}
在configuration.newStatementHandler()中，new 一个StatementHandler，先得到RoutingStatementHandler。RoutingStatementHandler 里面没有任何的实现， 是用来创建基本的StatementHandler 的。这里会根据MappedStatement 里面的statementType 决定StatementHandler 的类型。默认是PREPARED （ STATEMENT 、PREPARED 、CALLABLE）。
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
switch(ms.getStatementType()) {
case STATEMENT:
this.delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case PREPARED:
this.delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case CALLABLE:
this.delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}
}
StatementHandler 里面包含了处理参数的ParameterHandler 和处理结果集的ResultSetHandler。这两个对象都是在上面new 的时候创建的。
this.parameterHandler = this.configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
this.resultSetHandler = this.configuration.newResultSetHandler(executor, mappedStatement, rowBounds, this.parameterHandler, resultHandler, boundSql);
这三个对象都是可以被插件拦截的四大对象之一，所以在创建之后都要用拦截器进行包装的方法。（对于详细的插件机制将在下篇博客中详细介绍）
StatementHandler statementHandler = (StatementHandler)this.interceptorChain.pluginAll(statementHandler); parameterHandler = (ParameterHandler)this.interceptorChain.pluginAll(parameterHandler); ResultSetHandler resultSetHandler = (ResultSetHandler)this.interceptorChain.pluginAll(resultSetHandler);
四大对象还有一个是谁？在什么时候创建的？（Executor）在第二步创建会话的时候创建的。用new 出来的StatementHandler 创建Statement 对象——prepareStatement()方法对语句进行预编译，处理参数。执行的StatementHandler 的query()方法，RoutingStatementHandler 的query()方法。
delegate 委派，最终执行PreparedStatementHandler 的query()方法。
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement)statement;
ps.execute();
return this.resultSetHandler.handleResultSets(ps);
}
执行PreparedStatement 的execute()方法，后面就是JDBC 包中的PreparedStatement 的执行了。
最后通过 resultSetHandler.handleResultSets(ps) 处理结果集。
最后总结一下整个源码的过程所涉及的核心类：
