关键词：
本章着重介绍MyBatis执行Sql的流程，关于在执行过程中缓存、动态SQl生成等细节不在本章中体现
还是以之前的查询作为例子：
public class App
public static void main(String[] args)
String resource = "mybatis-config.xml";
Reader reader;
try
//将XML配置文件构建为Configuration配置类
reader = Resources.getResourceAsReader(resource);
// 通过加载配置文件流构建一个SqlSessionFactory DefaultSqlSessionFactory
SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
// 数据源 执行器 DefaultSqlSession
SqlSession session = sqlMapper.openSession();
try
// 执行查询 底层执行jdbc
//User user = (User)session.selectOne("com.tuling.mapper.selectById", 1);
UserMapper mapper = session.getMapper(UserMapper.class);
System.out.println(mapper.getClass());
User user = mapper.selectById(1L);
System.out.println(user.getUserName());
catch (Exception e)
e.printStackTrace();
finally
session.close();
catch (IOException e)
e.printStackTrace();
之前提到拿到sqlSession之后就能进行各种CRUD操作了，所以我们就从sqlSession.getMapper这个方法开始分析，看下整个Sql的执行流程是怎么样的。
openSession的过程:
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit)
Transaction tx = null;
try
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//获取执行器，这边获得的执行器已经代理拦截器的功能（见下面代码）
final Executor executor = configuration.newExecutor(tx, execType);
//根据获取的执行器创建SqlSession
return new DefaultSqlSession(configuration, executor, autoCommit);
catch (Exception e)
closeTransaction(tx); // may have fetched a connection so lets call close()
throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
finally
ErrorContext.instance().reset();
Copy
//interceptorChain生成代理类，具体参见Plugin这个类的方法
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;
Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。
普通Executor又分为三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。
- SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
- ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。
- BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。
作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。
CacheExecutor其实是封装了普通的Executor，和普通的区别是在查询前先会查询缓存中是否存在结果，如果存在就使用缓存中的结果，如果不存在还是使用普通的Executor进行查询，再将查询出来的结果存入缓存。
到此为止，我们已经获得了SqlSession，拿到SqlSession就可以执行各种CRUD方法了。
简单总结
- 拿到SqlSessionFactory对象后，会调用SqlSessionFactory的openSesison方法，这个方法会创建一个Sql执行器（Executor），这个Sql执行器会代理你配置的拦截器方法。
- 获得上面的Sql执行器后，会创建一个SqlSession（默认使用DefaultSqlSession）,这个SqlSession中也包含了Configration对象，所以通过SqlSession也能拿到全局配置；
- 获得SqlSession对象后就能执行各种CRUD方法了。
SQL的具体执行流程见后续博客。
一些重要类总结：
- SqlSessionFactory
- SqlSessionFactoryBuilder
- SqlSession（默认使用DefaultSqlSession）
- Executor接口
- Plugin、InterceptorChain的pluginAll方法
获取Mapper的流程
进入sqlSession.getMapper方法，会发现调的是Configration对象的getMapper方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession)
//mapperRegistry实质上是一个Map，里面注册了启动过程中解析的各种Mapper.xml
//mapperRegistry的key是接口的Class类型
//mapperRegistry的Value是MapperProxyFactory,用于生成对应的MapperProxy（动态代理类）
return mapperRegistry.getMapper(type, sqlSession);
进入getMapper方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession)
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
//如果配置文件中没有配置相关Mapper,直接抛异常
if (mapperProxyFactory == null)
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
try
//关键方法
return mapperProxyFactory.newInstance(sqlSession);
catch (Exception e)
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
进入MapperProxyFactory的newInstance方法：
public class MapperProxyFactory<T>
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
public MapperProxyFactory(Class<T> mapperInterface)
this.mapperInterface = mapperInterface;
public Class<T> getMapperInterface()
return mapperInterface;
public Map<Method, MapperMethod> getMethodCache()
return methodCache;
//生成Mapper接口的动态代理类MapperProxy，MapperProxy实现了InvocationHandler 接口
@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy)
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] mapperInterface , mapperProxy);
public T newInstance(SqlSession sqlSession)
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
获取Mapper的流程总结如下：
Mapper方法的执行流程
下面是动态代理类MapperProxy，调用Mapper接口的所有方法都会先调用到这个代理类的invoke方法（注意由于Mybatis中的Mapper接口没有实现类，所以MapperProxy这个代理对象中没有委托类，也就是说MapperProxy干了代理类和委托类的事情）。好了下面重点看下invoke方法。
//MapperProxy代理类
public class MapperProxy<T> implements InvocationHandler, Serializable
private static final long serialVersionUID = -6424540398559729838L;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache;
public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache)
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
try
if (Object.class.equals(method.getDeclaringClass()))
return method.invoke(this, args);
else if (isDefaultMethod(method))
return invokeDefaultMethod(proxy, method, args);
catch (Throwable t)
throw ExceptionUtil.unwrapThrowable(t);
//获取MapperMethod，并调用MapperMethod
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
MapperProxy的invoke方法非常简单，主要干的工作就是创建MapperMethod对象或者是从缓存中获取MapperMethod对象。获取到这个对象后执行execute方法。
所以这边需要进入MapperMethod的execute方法：这个方法判断你当前执行的方式是增删改查哪一种，并通过SqlSession执行相应的操作。（这边以sqlSession.selectOne这种方式进行分析~）
public Object execute(SqlSession sqlSession, Object[] args)
Object result;
//判断是CRUD那种方法
switch (command.getType())
case INSERT:
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
case UPDATE:
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
case DELETE:
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
case SELECT:
if (method.returnsVoid() && method.hasResultHandler())
executeWithResultHandler(sqlSession, args);
result = null;
else if (method.returnsMany())
result = executeForMany(sqlSession, args);
else if (method.returnsMap())
result = executeForMap(sqlSession, args);
else if (method.returnsCursor())
result = executeForCursor(sqlSession, args);
else
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid())
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
return result;
详细流程图
https://www.processon.com/view/link/5efc23966376891e81f2a37e
sqlSession.selectOne方法会会调到DefaultSqlSession的selectList方法。这个方法获取了获取了MappedStatement对象，并最终调用了Executor的query方法。
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();
然后，通过一层一层的调用（这边省略了缓存操作的环节，会在后面的文章中介绍），最终会来到doQuery方法， 这儿咱们就随便找个Excutor看看doQuery方法的实现吧，我这儿选择了SimpleExecutor:
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException
Statement stmt = null;
try
Configuration configuration = ms.getConfiguration();
//内部封装了ParameterHandler和ResultSetHandler
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
//StatementHandler封装了Statement, 让 StatementHandler 去处理
return handler.<E>query(stmt, resultHandler);
finally
closeStatement(stmt);
接下来，咱们看看StatementHandler 的一个实现类 PreparedStatementHandler（这也是我们最常用的，封装的是PreparedStatement）, 看看它使怎么去处理的：
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException
//到此，原形毕露， PreparedStatement, 这个大家都已经滚瓜烂熟了吧
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
//结果交给了ResultSetHandler 去处理,处理完之后返回给客户端
return resultSetHandler.<E> handleResultSets(ps);
到此，整个调用流程结束。
简单总结
这边结合获取SqlSession的流程，做下简单的总结：
- SqlSessionFactoryBuilder解析配置文件，包括属性配置、别名配置、拦截器配置、环境（数据源和事务管理器）、Mapper配置等；解析完这些配置后会生成一个Configration对象，这个对象中包含了MyBatis需要的所有配置，然后会用这个Configration对象创建一个SqlSessionFactory对象，这个对象中包含了Configration对象；
- 拿到SqlSessionFactory对象后，会调用SqlSessionFactory的openSesison方法，这个方法会创建一个Sql执行器（Executor组件中包含了Transaction对象），这个Sql执行器会代理你配置的拦截器方法。
- 获得上面的Sql执行器后，会创建一个SqlSession（默认使用DefaultSqlSession）,这个SqlSession中也包含了Configration对象和上面创建的Executor对象，所以通过SqlSession也能拿到全局配置；
- 获得SqlSession对象后就能执行各种CRUD方法了。
以上是获得SqlSession的流程，下面总结下本博客中介绍的Sql的执行流程：
- 调用SqlSession的getMapper方法，获得Mapper接口的动态代理对象MapperProxy，调用Mapper接口的所有方法都会调用到MapperProxy的invoke方法（动态代理机制）；
- MapperProxy的invoke方法中唯一做的就是创建一个MapperMethod对象，然后调用这个对象的execute方法，sqlSession会作为execute方法的入参；
- 往下，层层调下来会进入Executor组件（如果配置插件会对Executor进行动态代理）的query方法，这个方法中会创建一个StatementHandler对象，这个对象中同时会封装ParameterHandler和ResultSetHandler对象。调用StatementHandler预编译参数以及设置参数值，使用ParameterHandler来给sql设置参数。
- Executor组件有两个直接实现类，分别是BaseExecutor和CachingExecutor。CachingExecutor静态代理了BaseExecutor。Executor组件封装了Transction组件，Transction组件中又分装了Datasource组件。
- 调用StatementHandler的增删改查方法获得结果，ResultSetHandler对结果进行封装转换，请求结束。
Executor、StatementHandler 、ParameterHandler、ResultSetHandler，Mybatis的插件会对上面的四个组件进行动态代理。
mybatis源码解析9---执行器executor解析(代码片段)
...ate去执行的。本文就分析下sql的执行器-----ExecutorExecutor是mybatis的sql执行器，SqlSession是面向程序的，而Executor则就是面向数据库的，先看下Executor接口的方法有 查看详情
mybatis3源码解析
Mybatis是支持定制化SQL、存储过程和高级映射的持久层框架。主要完成两件事：封装JDBC的操作利用反射完成Java类和SQL之间的转换mybatis的主要目的就是管理执行SQL是参数的输入和输出，编写SQL和结果集的映射是mybatis的主要优点myba... 查看详情
《mybatis3源码深度解析》图书简介
一、图书封面二、书籍目录前言4第1篇Mybatis3源码7第1章搭建Mybatis源码环境71.1Mybatis3简介71.2环境准备71.3获取Mybatis源码81.4导入Mybatis源码到IDE101.5HSQLDB数据库简介131.6本章小结16第2章JDBC规范详解172.1JDBCAPI简介172.1.1建立数据源连接182... 查看详情
《mybatis3源码深度解析》图书简介
一、图书封面二、书籍目录前言4第1篇Mybatis3源码7第1章搭建Mybatis源码环境71.1Mybatis3简介71.2环境准备71.3获取Mybatis源码81.4导入Mybatis源码到IDE101.5HSQLDB数据库简介131.6本章小结16第2章JDBC规范详解172.1JDBCAPI简介172.1.1建立数据源连接182... 查看详情
《mybatis3源码深度解析》图书简介
一、图书封面二、书籍目录前言4第1篇Mybatis3源码7第1章搭建Mybatis源码环境71.1Mybatis3简介71.2环境准备71.3获取Mybatis源码81.4导入Mybatis源码到IDE101.5HSQLDB数据库简介131.6本章小结16第2章JDBC规范详解172.1JDBCAPI简介172.1.1建立数据源连接182... 查看详情
《mybatis3源码深度解析》图书简介
一、图书封面二、书籍目录前言4第1篇Mybatis3源码7第1章搭建Mybatis源码环境71.1Mybatis3简介71.2环境准备71.3获取Mybatis源码81.4导入Mybatis源码到IDE101.5HSQLDB数据库简介131.6本章小结16第2章JDBC规范详解172.1JDBCAPI简介172.1.1建立数据源连接182... 查看详情
mybatis拦截器源码深度解析
...调用解析1.对请求对象进行拦截器包装2.执行调用三.小结Mybatis拦截器可以帮助我们在执行sql语句过程中增加插件以实现一些通用的逻辑，比如对查询sql分页、数据权限处理等。允许使用插件拦截的方法调用包括：-Executor(update,quer... 查看详情
mybatis的缓存机制源码分析之一级缓存解析(代码片段)
文章目录引言正文引言本篇源码解析基于mybatis3.5.8版本。MyBatis中的缓存指的是MyBatis在执行一次SQL查询时，在满足一定的条件下，会把这个sql和对应的查询结果缓存起来。当再次执行相同SQL语句的时候，就会直接从缓... 查看详情
mybatis的缓存机制源码分析之二级缓存解析(代码片段)
引言本篇源码解析基于mybatis3.5.8版本。MyBatis中的缓存指的是MyBatis在执行一次SQL查询时，在满足一定的条件下，会把这个sql和对应的查询结果缓存起来。当再次执行相同SQL语句的时候，就会直接从缓存中进行提取，... 查看详情
mybatis——源码解析mybatis框架底层的执行原理(代码片段)
文章目录：1.前言2.案例项目源码3.MyBatis源码解析底层执行原理3.1读取mybatis配置文件创建出SqlSeesionFactory对象3.2通过SqlSeesionFactory对象进而创建出SqlSession对象3.3通过SqlSession的getMapper获取到接口代理对象3.4通过mapper接口的代理... 查看详情
mybatis——源码解析mybatis框架底层的执行原理(代码片段)
文章目录：1.前言2.案例项目源码3.MyBatis源码解析底层执行原理3.1读取mybatis配置文件创建出SqlSeesionFactory对象3.2通过SqlSeesionFactory对象进而创建出SqlSession对象3.3通过SqlSession的getMapper获取到接口代理对象3.4通过mapper接口的代理... 查看详情
mybatis源码阅读之--整体执行流程
Mybatis执行流程分析Mybatis执行SQL语句可以使用两种方式：使用SqlSession执行update/delete/insert/select操作使用SqlSession获得对应的Mapper，然后调用mapper的相应方法执行语句其中第二种方式获取Mapper的流程在前面已经解析过，请查看文章My... 查看详情
mybatis源码：mybatis配置解析(代码片段)
Mybatis有两个核心配置，全局配置会影响Mybatis的执行；Mapper配置定义了查询的SQL，下面我们来看看Mybatis是如何加载配置文件的。 本文基于Mybatis源码(一)：源码编译准备中案例进行分析，主要示例代码如下：publicstaticvoidma... 查看详情
mybatis3源码解析-执行sql流程
参考技术A其实我们有在XML配置文件中配置标签来加载我们的mapper文件。官网文档给了答案：总共有四种方式()。前文了解了XML配置解析器XMLConfigBuilder的parse()方法便是加载配置文件生成一个Configuration对象的入口方法；上篇了解了... 查看详情
mybatis源码解析mybatis解析全局配置文件(代码片段)
MyBatis介绍MyBatis是一个持久层的ORM框架，使用简单，学习成本较低。可以执行自己手写的SQL语句，比较灵活。但是MyBatis的自动化程度不高，移植性也不高，有时从一个数据库迁移到另外一个数据库的时候需要... 查看详情
mybatis源码解析之如何调用jdbc的预处理器statement完成交互
一、JDBC执行过程 1.1预编译的三种执行器简单执行器(Statement)存在sql注入问题，发送一条一条静态sql语句(包含参数)，传输体量比较大。预处理执行器(PreparedStatement)可以防止sql注入问题，发送一条sql语句包含若干组参数，... 查看详情
mybatis源码解析5---statementhandler解析
StatementHandler解析接口的作用是statement处理器，位于mybatis包的org.apache.ibatis.executor.statement目录下，源码如下：1packageorg.apache.ibatis.executor.statement;23importjava.sql.Connection;4importjava.sql.SQLException;5impo 查看详情
精尽mybatis源码分析-sql执行过程之statementhandler
该系列文档是本人在学习Mybatis的源码过程中总结下来的，可能对读者不太友好，请结合我的源码注释（Mybatis源码分析GitHub地址、Mybatis-Spring源码分析GitHub地址、Spring-Boot-Starter源码分析GitHub地址）进行阅读MyBatis版本：3.5.2MyBatis-Sp... 查看详情