MyBatis执行Sql的流程分析
目录
举例
openSession的过程
Executor
简单总结
获取Mapper的流程
Mapper方法的执行流程
doQuery方法
简单总结
举例
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的过程
@Override
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}openSessionFromDataSource方法
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);
/**
* 创建一个sql执行器对象
* 一般情况下 若我们的mybaits的全局配置文件的cacheEnabled默认为true就返回
* 一个cacheExecutor,若关闭的话返回的就是一个SimpleExecutor
*/
final Executor executor = configuration.newExecutor(tx, execType);
/**
* 创建返回一个DeaultSqlSessoin对象返回
*/
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();
}
}创建一个sql语句执行器对象
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 {
//简单的sql执行器对象
executor = new SimpleExecutor(this, transaction);
}
//判断mybatis的全局配置文件是否开启缓存
if (cacheEnabled) {
//把当前的简单的执行器包装成一个CachingExecutor
executor = new CachingExecutor(executor);
}
/**
* TODO:调用所有的拦截器对象plugin方法
*/
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}Executor
分类
Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。
普通Executor又分为三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。
- 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批处理相同。
作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。
CacheExecutor其实是封装了普通的Executor，（能看到源码里面包装了一层）和普通的区别是在查询前先会查询缓存中是否存在结果，如果存在就使用缓存中的结果，如果不存在还是使用普通的Executor进行查询，再将查询出来的结果存入缓存。
到此为止，我们已经获得了SqlSession，拿到SqlSession就可以执行各种CRUD方法了。
简单总结
- 拿到SqlSessionFactory对象后，会调用SqlSessionFactory的openSesison方法，这个方法会创建一个Sql执行器（Executor），这个Sql执行器会代理你配置的拦截器方法。
- 获得上面的Sql执行器后，会创建一个SqlSession（默认使用DefaultSqlSession）,这个SqlSession中也包含了Configration对象，所以通过SqlSession也能拿到全局配置；
- 获得SqlSession对象后就能执行各种CRUD方法了
获取Mapper的流程
进入sqlSession.getMapper方法，会发现调的是Configration对象的getMapper方法：
UserMapper mapper = session.getMapper(UserMapper.class);@Override
public T getMapper(Class type) {
// 这个sqlsession就是调用的对象
return configuration.getMapper(type, this);
} public T getMapper(Class type, SqlSession sqlSession) {
//mapperRegistry实质上是一个Map，里面注册了启动过程中解析的各种Mapper.xml
//mapperRegistry的key是接口的Class类型
//mapperRegistry的Value是MapperProxyFactory,用于生成对应的MapperProxy（动态代理类）
return mapperRegistry.getMapper(type, sqlSession);
} 进入getMapper方法：
public T getMapper(Class type, SqlSession sqlSession) {
/**
* 直接去缓存knownMappers中通过Mapper的class类型去找我们的mapperProxyFactory
*/
final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
/**
* 缓存中没有获取到 直接抛出异常
*/
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
/**
* 通过MapperProxyFactory来创建我们的实例
*/
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
} knownMappers里面信息
你再去看就会发现，初始化configuration这个类的时候，就把所有的mapper类放到mapperRegistry里面去了，里面也有knownMappers这个属性
public void addMappers(String packageName, Class superType) {
mapperRegistry.addMappers(packageName, superType);
}
进入MapperProxyFactory的newInstance方法：
public T newInstance(SqlSession sqlSession) {
/**
* 创建我们的代理对象
*/
final MapperProxy mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
/**
* 创建我们的Mapper代理对象返回
*/
return newInstance(mapperProxy);
} newInstance(mapperProxy)
真正的动态代理实现
第一个参数就是你写的mapper接口需要的类加载器，接口的类数组
protected T newInstance(MapperProxy mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
} mapperProxy
public class MapperProxy implements InvocationHandler, Serializable { 实现invocationHandler主要就是要调用invoke方法
你会看到这个mapperProxy初始化的时候有很多参数
public MapperProxy(SqlSession sqlSession, Class mapperInterface, Map methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
} 因为mapperInterface表示接口的类，肯定要用，另外两个一个是执行sql的，一个是缓存使用的
获取Mapper的流程总结如下：
Mapper方法的执行流程
下面是动态代理类MapperProxy，调用Mapper接口的所有方法都会先调用到这个代理类的invoke方法（注意由于Mybatis中的Mapper接口没有实现类，所以MapperProxy这个代理对象中没有委托类，也就是说MapperProxy干了代理类和委托类的事情）。好了下面重点看下invoke方法。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
/**
* 判断我们的方法是不是我们的Object类定义的方法，若是直接通过反射调用
*/
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (method.isDefault()) { //是否接口的默认方法
/**
* 调用我们的接口中的默认方法
*/
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
/**
* 真正的进行调用,做了二个事情
* 第一步:把我们的方法对象封装成一个MapperMethod对象(带有缓存作用的)
*/
final MapperMethod mapperMethod = cachedMapperMethod(method);
/**
*通过sqlSessionTemplate来调用我们的目标方法
* 那么我们就需要去研究下sqlSessionTemplate是什么初始化的
* 我们知道spring 跟mybatis整合的时候，进行了偷天换日
* 把我们mapper接口包下的所有接口类型都变为了MapperFactoryBean
* 然后我们发现实现了SqlSessionDaoSupport,我们还记得在整合的时候，
* 把我们EmployeeMapper(案例class类型属性为MapperFactoryBean)
* 的注入模型给改了，改成了by_type,所以会调用SqlSessionDaoSupport
* 的setXXX方法进行赋值,从而创建了我们的sqlSessionTemplate
* 而在实例化我们的sqlSessionTemplate对象的时候，为我们创建了sqlSessionTemplate的代理对象
* this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class }, new SqlSessionInterceptor());
*/
return mapperMethod.execute(sqlSession, args);
}cachedMapperMethod方法
private MapperMethod cachedMapperMethod(Method method) {
/**
* 相当于这句代码.jdk8的新写法
* if(methodCache.get(method)==null){
* methodCache.put(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()))
* }
*/
return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}MapperProxy的invoke方法非常简单，主要干的工作就是创建MapperMethod对象或者是从缓存中获取MapperMethod对象。获取到这个对象后执行execute方法。
所以这边需要进入MapperMethod的execute方法：这个方法判断你当前执行的方式是增删改查哪一种，并通过SqlSession执行相应的操作。（后面的就以sqlSession.selectOne这种方式进行分析~）
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
/**
* 判断我们执行sql命令的类型
*/
switch (command.getType()) {
//insert操作
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
//update操作
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
//delete操作
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
//select操作
case SELECT:
//返回值为空
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
//返回值是一个List
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
//返回值是一个map
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
//返回游标
result = executeForCursor(sqlSession, args);
} else {
//查询返回单个
/**
* 解析我们的参数
*/
Object param = method.convertArgsToSqlCommandParam(args);
/**
* 通过调用sqlSessionTemplate来执行我们的sql
* 第一步:获取我们的statmentName(com.tuling.mapper.EmployeeMapper.findOne)
* 然后我们就需要重点研究下SqlSessionTemplate是怎么来的?
* 在mybatis和spring整合的时候，我们偷天换日了我们mapper接口包下的所有的
* beandefinition改成了MapperFactoryBean类型的
* MapperFactoryBean extends SqlSessionDaoSupport的类实现了SqlSessionDaoSupport
* 那么就会调用他的setXXX方法为我们的sqlSessionTemplate赋值
*
*/
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
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;
} sqlSession.selectOne方法会调到DefaultSqlSession的selectList方法。这个方法获取了MappedStatement对象，并最终调用了Executor的query方法。
selectOne方法
@Override
public T selectOne(String statement, Object parameter) {
// Popular vote was to return null on 0 results and throw exception on too many.
/**
* 这里selectOne调用也是调用selectList方法
*/
List list = this.selectList(statement, parameter);
//若查询出来有且有一个一个对象，直接返回要给
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
/**
* 查询的有多个,那么久抛出我们熟悉的异常
* Expected one result (or null) to be returned by selectOne(), but found: " + list.size()
*/
throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
} @Override
public List selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
/**
* 第一步：通过我们的statement去我们的全局配置类中获取MappedStatement
*/
MappedStatement ms = configuration.getMappedStatement(statement);
/**
* 通过执行器去执行我们的sql对象
* 第一步:包装我们的集合类参数
* 第二步:一般情况下是executor为cacheExetory对象
*/
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:
运行时参数
doQuery方法
public List 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.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
} 接下来，咱们看看StatementHandler 的一个实现类 PreparedStatementHandler（这也是我们最常用的，封装的是PreparedStatement）, 看看它使怎么去处理的：
public List query(Statement statement, ResultHandler resultHandler) throws SQLException {
//到此，原形毕露， PreparedStatement, 这个大家都已经滚瓜烂熟了吧
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
//结果交给了ResultSetHandler 去处理,处理完之后返回给客户端
return resultSetHandler. 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的插件会对上面的四个组件进行动态代理。