前言
本文主要说明Mybatis的查询机制或者工作原理。基于Mybatis独立运行模式，不集成Spring。
Mybatis源码版本为3.5.9。
总体流程图
先看一下Mybatis的执行流程图：
案例代码
下文的执行流程基于如下测试代码：
public class MybatisTest {
SqlSessionFactory sqlSessionFactory = null;
@Before
public void init() throws Exception{
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 根据全局配置文件创建出SqlSessionFactory（负责创建SqlSession对象的工厂）
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void test01() {
// 获取数据库的会话,创建出数据库连接的会话对象（事务工厂，事务对象，执行器，如果有插件的话会进行插件的解析）
SqlSession sqlSession = sqlSessionFactory.openSession();
Emp empByEmpno = null;
try {
// 获取要调用的接口类,创建出对应的mapper的动态代理对象（mapperRegistry.knownMapper）
EmpDao mapper = sqlSession.getMapper(EmpDao.class);
// 调用方法开始执行
empByEmpno = mapper.findEmpByEmpno(7369);
} catch (Exception e) {
e.printStackTrace();
} finally {
sqlSession.close();
}
System.out.println(empByEmpno);
}
}
解析配置文件
当Mybatis启动的时候，会加载2种配置文件，一种是全局配置文件（mybatis-config.xml），另一种是映射配置文件。全局配置文件决定Mybatis的整体行为模式。映射配置文件一般用于存储SQL。这些配置文件解析完成之后会将配置文件信息封装成Configuration对象。
// 解析配置文件，封装成Configuration对象
public Configuration parse() {
// 根据parsed变量的值判断是否已经完成了对mybatis-config.xml配置文件的解析
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
// 在mybatis-config.xml配置文件中查找<configuration>节点，并开始解析
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
// 解析配置文件根节点
private void parseConfiguration(XNode root) {
try {
// issue #117 read properties first
// 解析properties
propertiesElement(root.evalNode("properties"));
// 解析settings
Properties settings = settingsAsProperties(root.evalNode("settings"));
// 设置vfsImpl字段
loadCustomVfs(settings);
loadCustomLogImpl(settings);
// 解析类型别名（可以在这里给类定义别名，以便在配置文件中直接使用，也可以通过注解@Alias("xxx")）
typeAliasesElement(root.evalNode("typeAliases"));
// 解析插件(例如：分页插件
pluginElement(root.evalNode("plugins"));
// 对象工厂
objectFactoryElement(root.evalNode("objectFactory"));
// 对象包装工厂
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
// 反射工厂
reflectorFactoryElement(root.evalNode("reflectorFactory"));
//设置具体的属性到configuration对象
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
// 环境
environmentsElement(root.evalNode("environments"));
// databaseIdProvider
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
// 类型处理器
typeHandlerElement(root.evalNode("typeHandlers"));
// 映射器
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
创建SqlSessionFactory
SqlSessionFactoryBuilder对象使用之前的Configuration配置文件对象，构建出SqlSessionFactory对象，然后由它负责创建SqlSession对象。这一步骤相对简单。
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}
创建SqlSession
SqlSessionFactory根据之前解析到的环境信息创建TransactionFactory和Transaction。
根据执行器类型，创建Executor。然后创建SqlSession对象。
public SqlSession openSession() {
// 获取默认的执行器类型
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
// 获取mybatis-config.xml配置文件中配置的Environment对象，
final Environment environment = configuration.getEnvironment();
// 获取TransactionFactory对象
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
// 创建Transaction对象
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
// 根据配置创建Executor对象
final Executor executor = configuration.newExecutor(tx, execType);
//然后产生一个DefaultSqlSession
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();
}
}
创建Executor
创建执行器时，会根据如下规则创建对应的执行器。
执行类型BATCH，对应BatchExecutor，批处理执行器
执行类型REUSE，对应ReuseExecutor，执行器会重用预处理语句（PreparedStatements）
其他情况就是，SimpleExecutor，普通执行器。
还会读取缓存配置。如果开启了二级缓存，会用CachingExecutor装饰器类装饰上面的执行器。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType : executorType; // ?
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Executor 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 = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
MapperProxy代理对象
创建Mapper接口的代理对象时序图如下：最终是通过JDK动态代理创建了MapperProxy的代理对象。
源码如下，在找MapperProxyFactory时，会根据mapper接口的类型，从MapperRegistry对象中的knownMappers属性中获取到对应的代理工厂类，这个属性是在解析mybatis-config.xml的时候初始化的。
@Override
public <T> T getMapper(Class<T> type) {
//调用configuration的getMapper()方法
return configuration.getMapper(type, this);
}
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
//configuration调用mapperRegistry的getMapper()方法
return mapperRegistry.getMapper(type, sqlSession);
}
// 返回代理类
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// 查找指定type对应MapperProxyFactory对象,knownMappers在加载mybatis-config.xml的时候存储进去的
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
// 如果mapperProxyFactory为空，则抛出异常
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
// 创建实现了type接口的代理对象
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
然后创建MapperProxy对象，使用Jdk动态代理创建MapperProxy的对象。
public T newInstance(SqlSession sqlSession) {
// 创建MapperProxy对象，每次调用都会创建新的mapperProxy对象
final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
protected T newInstance(MapperProxy<T> mapperProxy) {
// 创建实现了mapperInterface接口的代理对象
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
执行SQL
这一步骤主要就是通过代理对象调用执行器去执行SQL。调用过程见下面的时序图：
源码分析
-
首先根据JDK动态代理机制，调用被代理对象的方法之后实际上执行的就是代理对象的invoke方法。
-
根据被调用接口方法的method对象，从缓存中获取MapperMethodInvoker对象，如果没有则创建一个并放入缓存，然后调用invoke方法
-
构造MapperMethod对象并且调用他的execute方法。这个方法内部会根据不同的SQL语句类型做不同的处理。我们此时分析的是查询方法，他还会根据返回值类型进行区分处理。
-
源码参考
-
@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 { // 根据被调用接口方法的method对象，从缓存中获取MapperMethodInvoker对象，如果没有则创建一个并放入缓存，然后调用invoke return cachedInvoker(method).invoke(proxy, method, args, sqlSession); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } } // 获取缓存中MapperMethodInvoker,如果没有则创建一个，而MapperMethodInvoker内部封装这一个MethodHandler private MapperMethodInvoker cachedInvoker(Method method) throws Throwable { try { return MapUtil.computeIfAbsent(methodCache, method, m -> { if (m.isDefault()) { // 如果调用接口的是默认方法 try { if (privateLookupInMethod == null) { return new DefaultMethodInvoker(getMethodHandleJava8(method)); } else { return new DefaultMethodInvoker(getMethodHandleJava9(method)); } } catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) { throw new RuntimeException(e); } } else { // 如果调用的普通方法，则创建一个PlainMethodInvoker并放入缓存，其中MapperMethod保存对应接口方法的SQL以及入参和出参的数据类型等信息 return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration())); } }); } catch (RuntimeException re) { Throwable cause = re.getCause(); throw cause == null ? re : cause; } } public Object execute(SqlSession sqlSession, Object[] args) { Object result; // 根据SQL语句的类型调用SqlSession对应的方法 switch (command.getType()) { case INSERT: { // 使用ParamNameResolver处理args数组，将用户传入的实参与指定参数名称关联起来 Object param = method.convertArgsToSqlCommandParam(args); // 调用sqlSession.insert方法，rowCountResult方法会根据method字段中记录的方法的返回值类型对结果进行转换 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: // 处理返回值为void是ResultSet通过ResultHandler处理的方法 if (method.returnsVoid() && method.hasResultHandler()) { // 如果有结果处理器 executeWithResultHandler(sqlSession, args); result = null; // 处理返回值为集合和数组的方法 } else if (method.returnsMany()) { // 如果结果有多条记录 result = executeForMany(sqlSession, args); // 处理返回值为map的方法 } else if (method.returnsMap()) { // 如果结果是map result = executeForMap(sqlSession, args); // 处理返回值为cursor的方法 } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { // 处理返回值为单一对象的方法 Object param = method.convertArgsToSqlCommandParam(args); 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; }
-
-
调用DefaultSqlSession的查询方法进行查询。SqlSession会并继续调用内部执行器的查询方法。调用时还需要MappedStatement, RowBounds , ResultHandler这几个入参。
-
源码参考：
-
//sqlSession private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) { try { //根据statement id找到对应的MappedStatement MappedStatement ms = configuration.getMappedStatement(statement); //转而用执行器来查询结果,注意这里传入的ResultHandler是null return executor.query(ms, wrapCollection(parameter), rowBounds, handler); } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } } //执行器查询方法 @Override public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { // 获取BoundSql对象 BoundSql boundSql = ms.getBoundSql(parameter); // 创建CacheKey对象 CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql); // 查询 return query(ms, parameter, rowBounds, resultHandler, key, boundSql); }
-
-
查询时会优先根据CacheKey去查询缓存，没有命中缓存才会去查询数据库
-
BaseExecutor查询方法，如果开启了二级缓存则是CachingExecutor
-
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()); // 检测当前Executor是否已经关闭 if (closed) { throw new ExecutorException("Executor was closed."); } if (queryStack == 0 && ms.isFlushCacheRequired()) { // 非嵌套查询，并且select节点配置的flushCache属性为true时，才会清空一级缓存，flushCache配置项是影响一级缓存中结果对象存活时长的第一个方面 clearLocalCache(); } List<E> list; try { // 增加查询层数 queryStack++; // 查询一级缓存 list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { // 针对存储过程调用的处理，在一级缓存命中时，获取缓存中保存的输出类型参数，并设置到用户传入的实参对象中 handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { // 调用doQuery方法完成数据库查询，并得到映射后的结果对象 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { // 当前查询完成，查询层数减少 queryStack--; } if (queryStack == 0) { // 在最外层的查询结束时，所有嵌套查询也已经完成，相关缓存项也已经完全记载，所以在此处触发DeferredLoad加载一级缓存中记录的嵌套查询的结果对象 for (DeferredLoad deferredLoad : deferredLoads) { deferredLoad.load(); } // issue #601 // 加载完成后，清空deferredLoads集合 deferredLoads.clear(); if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { // issue #482 // 根据LocalCacheScope配置决定是否清空一级缓存 clearLocalCache(); } } return list; }
-
-
数据库查询方法，这里的doQuery使用了模版方法模式，交由子类完成
-
// 从数据库查 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; }
-
-
子类ReuseExecutor的doQuery查询方法。源码中一般看到do开头的就是真正要开始做事情的方法了。
-
此处创建了StatementHandler对SQL语句做了处理。还创建了JDBC的Statement对象
-
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Configuration configuration = ms.getConfiguration(); StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); Statement stmt = prepareStatement(handler, ms.getStatementLog()); return handler.query(stmt, resultHandler); }
-
-
通过StatementHandler去数据库执行查询。
-
PreparedStatementHandler源码。还有其他的实现类：SimpleStatementHandler，CallableStatementHandler（用于处理存储过程）
-
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; ps.execute(); return resultSetHandler.handleResultSets(ps); } -
从数据库返回的方法，将交由ResultHandler处理
-
-
ResultHandler
这一步骤主要是将数据库返回的对象根据mybatis配置文件的要求，封装结果集。
可以封装成多种类型，可以是基本数据类型，也可以是Map、List、POJO类型复杂数据类型。有两个常用的属性resultType和resultMap。这里面的逻辑相对来说还是挺复杂的，因为要考虑到非常多的情况，这里我们就不深入详细解析了。
带大家看一下重要代码
public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
// 该集合用于保存映射结果得到的结果对象
final List<Object> multipleResults = new ArrayList<>();
int resultSetCount = 0;
// 获取第一个ResultSet对象
ResultSetWrapper rsw = getFirstResultSet(stmt);
// 获取MappedStatement.resultMaps集合
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
// 如果集合集不为空，则resultMaps集合不能为空，否则抛出异常
validateResultMapsCount(rsw, resultMapCount);
// 遍历resultMaps集合
while (rsw != null && resultMapCount > resultSetCount) {
// 获取该结果集对应的ResultMap对象
ResultMap resultMap = resultMaps.get(resultSetCount);
// 根据ResultMap中定义的映射规则对ResultSet进行映射，并将映射的结果对象添加到multipleResult集合中保存
handleResultSet(rsw, resultMap, multipleResults, null);
// 获取下一个结果集
rsw = getNextResultSet(stmt);
// 清空nestedResultObjects集合
cleanUpAfterHandlingResultSet();
// 递增resultSetCount
resultSetCount++;
}
// 获取MappedStatement.resultSets属性，该属性对多结果集的情况使用，该属性将列出语句执行后返回的结果集，并给每个结果集一个名称，名称是逗号分隔的，
String[] resultSets = mappedStatement.getResultSets();
if (resultSets != null) {
while (rsw != null && resultSetCount < resultSets.length) {
// 根据resultSet的名称，获取未处理的ResultMapping
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
// 根据ResultMap对象映射结果集
handleResultSet(rsw, resultMap, null, parentMapping);
}
// 获取下一个结果集
rsw = getNextResultSet(stmt);
// 清空nestedResultObjects集合
cleanUpAfterHandlingResultSet();
// 递增resultSetCount
resultSetCount++;
}
}
return collapseSingleResultList(multipleResults);
}
扫一扫
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
