Mybatis之工作原理

1.Mybatis的架构

1.1 Mybatis的框架分层

1.2 MyBatis的实现原理

mybatis底层还是采用原生jdbc来对数据库进行操作的，只是通过 SqlSessionFactory ，SqlSession Executor , StatementHandler ，ParameterHandler , ResultHandler 和TypeHandler等几个处理器封装了这些过程 执行器：Executor (update, query, flushStatements, commit, rollback , getTransaction, close, isClosed)

参数处理器： ParameterHandler (getParameterObject, setParameters)

结构处理器 ResultSetHandler (handleResultSets, handleOutputParameters)

sql查询处理器：StatementHandler (prepare, parameterize, batch, update, query)

其中StatementHandler用通过ParameterHandler与ResultHandler分别进行参数预编译 与结果处理。而ParameterHandler与ResultHandler都使用TypeHandler进行映射。如下图：

2.Mybatis工作过程

通过读mybatis的源码进行分析mybatis的执行操作的整个过程，我们通过debug调试就可以知道Mybatis每一步做了什么事，我先把debug每一步结果 截图，然后在分析这个流程。

第一步:读取配置文件，形成InputStream

2.1 创建SqlSessionFacotry的过程

从debug调试看出 返回的 sqlSessionFactory 是DefaultSesssionFactory类型的，但是configuration此时已经被初始化了。查看源码后画如下创建DefaultSessionFactory的时序图：

2.2 创建SqlSession的过程

从debug调试 看出SqlSessinoFactory.openSession() 返回的sqlSession是 DefaultSession类型的，此SqlSession里包含一个Configuration的对象，和一个Executor对象。查看源码后画如下创建DefaultSession的时序图：

2.3 创建Mapper的过程

从debug调试可以看出，mapper是一个Mapper代理对象，而且初始化了Configuration对象，Executor的对象。查看源码后画如下创建Mapper的时序图：

2.4 执行CRUD过程

2.4.1 以select为例查看各步执行的源码

1.mapper.selectEmployeeList()其实是MapperProxy执行invoke方法，此方法显示是判断Method的方法是不是Object的toString等方法如果不是就执行MapperMethod

public Object invoke(Object proxy, Method method, 
Object[] args) throws Throwable {
 // 判断Method的方法是不是Object的toString等方法 
 if(Object.class.equals(method.getDeclaringClass())) {
 try {
 return method.invoke(this, args);
 } catch (Throwable var5) {
 throw ExceptionUtil.unwrapThrowable(var5);
 }
 } else {
 //判断private final Map<Method, MapperMethod>
 methodCache;这个map里面有没有这个方法的一级缓存，
如果没 MapperMethod mapperMethod =
 this.cachedMapperMethod(method);
 return mapperMethod.execute(this.sqlSession, args);
 }
 }
 //查询一级缓存和设置一级缓存
 private MapperMethod cachedMapperMethod
(Method method) { MapperMethod mapperMethod 
= (MapperMethod)this.
methodCache.get(method);
 if(mapperMethod == null) {
 mapperMethod = new MapperMethod(this.mapperInterface,
 method, 
this.sqlSession.getConfiguration());
 this.methodCache.put(method, mapperMethod);
 }
 return mapperMethod;
 }

经过上面的调用后进入MapperMethod里面执行

//判断sql命令类型
 public Object execute(SqlSession sqlSession, Object[] 
 args) { Object param; Object result;
 if(SqlCommandType.INSERT == this.command.getType()) {
 param = this.method.convertArgsToSqlCommandParam(args);
 result = this.rowCountResult(sqlSession.insert
(this.command. getName(), param));} else if(SqlCommandType.
UPDATE == this.command.getType()) {
 param = this.method.convertArgsToSqlCommandParam(args);
 result = this.rowCountResult(sqlSession.update
 (this.command.getName(), param));
 } else if(SqlCommandType.DELETE == this.command.
getType()) {
 param = this.method.convertArgsToSqlCommandParam(args);
 resultthis.rowCountResult(sqlSession.delete(this.
command.getName(), param));
 } else if(SqlCommandType.SELECT == this.command.
getType()) {
 //我们测试的是select类型，则再判断这个方法的返回类型
 if(this.method.returnsVoid() && this.method.hasResult
 Handler()) {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 {
 param = this.method.convertArgsToSqlCommandParam(args);
 result = sqlSession.selectOne(this.command.getName(), 
 param);
 }
 } else {
 if(SqlCommandType.FLUSH != this.command.getType()) {
 throw new BindingException("Unknown execution method 
for: " + this.command.getName());
 }
 result = sqlSession.flushStatements();
 }
 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;
 }
 }
 private <E> Object executeForMany(SqlSession sqlSession, 
Object[] args) {
 //将param做处理 自动处理为param1,param2..
 Object param = this.method.convertArgsToSqlCommandParam
(args); List result;
 if(this.method.hasRowBounds()) {
 RowBounds rowBounds = this.method.extractRowBounds(args);
 //调用该对象的DefaultSqlSession的selectList方法
 result = sqlSession.selectList(this.command.getName(), 
 param, rowBounds);
 } else {
 result = sqlSession.selectList(this.command.getName(), 
 param); }
 return !this.method.getReturnType().isAssignableFrom
(result.getClass())
?(this.method.getReturnType().isArray()?this.
convertToArray(result)
:this.convertToDeclaredCollection(sqlSession.getConfi
guration(), result)):result;
 }
 //处理参数方法
 public Object convertArgsToSqlCommandParam(Object[]
 args) {int paramCount = this.params.size();
 if(args != null && paramCount != 0) {
 if(!this.hasNamedParameters && paramCount == 1) {
 return args[((Integer)this.params.keySet().iterator
 ().next()).intValue()];} else {
 Map<String, Object> param = new MapperMethod.ParamMap();
 int i = 0;
 for(Iterator i$ = this.params.entrySet().iterator(); 
 i$.hasNext(); ++i) {
 Entry<Integer, String> entry = (Entry)i$.next();
 param.put(entry.getValue(), args[((Integer)entry.getKey()).intValue()]);
 String genericParamName = "param" + String.valueOf
(i + 1); if(!param.containsKey(genericParamName)) {
 param.put(genericParamName, args[((Integer)entry.getKey()).intValue()]);
 }
 }
 return param;
 }
 } else {
 return null;
 }
 }

调用DefaultSqlSession的selectList的方法

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
 List var5;
 try {
 //获取MappedStatement对象
 MappedStatement ms = this.configuration.getMappedStatement(statement);
 //调用cachingExecutor执行器的方法
 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;
 }
 //CachingExector的query方法
 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
 //
 BoundSql boundSql = ms.getBoundSql(parameterObject);
 CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);
 //调用下2代码
 return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
 }
 //2代码
 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 Cache cache = ms.getCache();
 if(cache != null) {
 this.flushCacheIfRequired(ms);
 if(ms.isUseCache() && resultHandler == null) {
 this.ensureNoOutParams(ms, parameterObject, boundSql);
 List<E> list = (List)this.tcm.getObject(cache, key);
 if(list == null) {
 //这里是调用Executor里的query方法 如果开启了缓存这掉CachingExecutor的 如果没有则是调用BaseExecutor的
 list = this.delegate.query(ms, parameterObject,
 rowBounds, resultHandler, key, boundSql);
 this.tcm.putObject(cache, key, list);
 }
 return list;
 }
 }
 return this.delegate.query(ms, parameterObject,
 rowBounds, resultHandler, key, boundSql);
 }

BaseExecutor的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 {
 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 {
 //如果缓存中没有就从数据库中查询
 list = this.queryFromDatabase(ms, parameter, rowBounds,
 resultHandler, key, boundSql);
 }
 } finally {
 --this.queryStack;
 }
 if(this.queryStack == 0) {
 Iterator i$ = this.deferredLoads.iterator();
 while(i$.hasNext()) {
 BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)i$.next();
 deferredLoad.load();
 }
 this.deferredLoads.clear();
 if(this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
 this.clearLocalCache();
 }
 }
 return list;
 }
 }
 //从数据库中查询
 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的方法，ExecutorType默认是使用的
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方法

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处理器
 StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, 
parameter, rowBounds, resultHandler, boundSql);
 //调用下3的方法
 stmt = this.prepareStatement(handler, ms.getStatementLog());
 //调用no4的方法
 var9 = handler.query(stmt, resultHandler);
 } finally {
 this.closeStatement(stmt);
 }
 return var9;
 }
 //下3方法
 private Statement prepareStatement(StatementHandler 
 handler, Log statementLog) throws SQLException {
 Connection connection = this.getConnection(statementLog);
 Statement stmt = handler.prepare(connection);
 //SatementHanlder 采用PreparedStatementHandler
来实现此方法，而PreparedStatementHandler调用的是父接口ParameterHandler的方法
 handler.parameterize(stmt);
 return stmt;
 }

ParameterHandler参数处理器的方法

public interface ParameterHandler {
 Object getParameterObject();
 //此方法是用DefaultParameterHandler实现的
 void setParameters(PreparedStatement var1) throws SQLException;
 }

DefaultParameterHandler默认参数处理器的方法

public void setParameters(PreparedStatement ps) {
 ErrorContext.instance().activity("setting parameters").object(this.mappedStatement.
 getParameterMap().getId());
 List<ParameterMapping> parameterMappings = this.boundSql.getParameterMappings();
 if(parameterMappings != null) {
 for(int i = 0; i < parameterMappings.size(); ++i) {
 ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);
 if(parameterMapping.getMode() != ParameterMode.OUT) 
{ String propertyName = parameterMapping.getProperty();
 Object value;
 if(this.boundSql.hasAdditionalParameter(propertyName)) 
 { value = this.boundSql.getAdditionalParameter
(propertyName);
 } else if(this.parameterObject == null) {
 value = null;
 } else if(this.typeHandlerRegistry.hasTypeHandler
(this.parameterObject.getClass())) {
 value = this.parameterObject;
 } else {
 MetaObject metaObject = this.configuration.newMetaObject(this.parameterObject);
 value = metaObject.getValue(propertyName);
 }
 //这里用调用 TypeHandler类型映射处理器来映射
 TypeHandler typeHandler = parameterMapping.getType
Handler(); JdbcType jdbcType = parameterMapping.
getJdbcType();
 if(value == null && jdbcType == null) {
 jdbcType = this.configuration.getJdbcTypeForNull();
 }
 try {
 //类型处理器设置参数映射
 typeHandler.setParameter(ps, i + 1, value, jdbcType);
 } catch (TypeException var10) {
 throw new TypeException("Could not set parameters 
 for mapping: " + parameterMapping + ". Cause: " + 
var10, var10);
 } catch (SQLException var11) {
 throw new TypeException("Could not set parameters
 for mapping: " + parameterMapping + ". Cause: " 
+ var11, var11);
 }
 }
 }
 }
 }

no4的方法

 public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
 //此处调用原生sql的处理器
 PreparedStatement ps = (PreparedStatement)statement;
 //发出原生sql命令
 ps.execute();
 //采用ResultHandler结果处理器对结果集封装
 return this.resultSetHandler.handleResultSets(ps);
 }

ResultHandler代码

public interface ResultSetHandler {
 //此处调用的是DefaultResultSetHandler的方法
 <E> List<E> handleResultSets(Statement var1) throws SQLException;
 void handleOutputParameters(CallableStatement var1) throws SQLException;
 }

DefaultResultSetHandler的方法

public List<Object> handleResultSets(Statement stmt) 
throws SQLException {
 ErrorContext.instance().activity("handling results").object(this.mappedStatement.getId());
 List<Object> multipleResults = new ArrayList();
 int resultSetCount = 0;
 ResultSetWrapper rsw = this.getFirstResultSet(stmt);
 List<ResultMap> resultMaps = this.mappedStatement.
getResultMaps();
 int resultMapCount = resultMaps.size();
 this.validateResultMapsCount(rsw, resultMapCount);
 while(rsw != null && resultMapCount > resultSetCount) {
 ResultMap resultMap = (ResultMap)resultMaps.get
(resultSetCount);
 this.handleResultSet(rsw, resultMap, multipleResults, 
(ResultMapping)null);
 rsw = this.getNextResultSet(stmt);
 this.cleanUpAfterHandlingResultSet();
 ++resultSetCount;
 }
 String[] resultSets = this.mappedStatement.getResulSets();
 if(resultSets != null) {
 while(rsw != null && resultSetCount < resultSets.length) {
 ResultMapping parentMapping = (ResultMapping)this.
nextResultMaps.get(resultSets
[resultSetCount]);
 if(parentMapping != null) {
 String nestedResultMapId = parentMapping.getNestedResultMapId();
 ResultMap resultMap = this.configuration.getResultMap
(nestedResultMapId);
 this.handleResultSet(rsw, resultMap, (List)null, parentMapping);
 }
 rsw = this.getNextResultSet(stmt);
 this.cleanUpAfterHandlingResultSet();
 ++resultSetCount;
 }
 }
 return this.collapseSingleResultList(multipleResults);
 }
 //处理结果集
 private void handleResultSet(ResultSetWrapper rsw, 
ResultMap resultMap, List<Object> multipleResults, 
ResultMapping parentMapping) throws SQLException {
 try {
 if(parentMapping != null) {
 this.handleRowValues(rsw, resultMap, (ResultHandler)null, 
RowBounds.DEFAULT, parentMapping);
 } else if(this.resultHandler == null) {
 DefaultResultHandler defaultResultHandler = new DefaultResultHandler(this.objectFactory);
 this.handleRowValues(rsw, resultMap, defaultResultHandler, 
this.rowBounds, (ResultMapping)null);
 multipleResults.add(defaultResultHandler.getResultList());
 } else {
 this.handleRowValues(rsw, resultMap, this.resultHandler, 
 this.rowBounds, (ResultMapping)null);
 }
 } finally {
 this.closeResultSet(rsw.getResultSet());
 }
 }
 private void handleRowValues(ResultSetWrapper rsw, 
ResultMap resultMap, ResultHandler<?> resultHandler, 
RowBounds rowBounds, ResultMapping parentMapping) 
throws SQLException {
 if(resultMap.hasNestedResultMaps()) {
 this.ensureNoRowBounds();
 this.checkResultHandler();
 this.handleRowValuesForNestedResultMap(rsw, resultMap, 
resultHandler, rowBounds, parentMapping);
 } else {
 this.handleRowValuesForSimpleResultMap(rsw, resultMap,
 resultHandler, rowBounds, parentMapping);
 }
 }
 private void handleRowValuesForNestedResultMap
(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler
<?> resultHandler, RowBounds rowBounds, ResultMapping
 parentMapping) throws SQLException {
 DefaultResultContext<Object> resultContext = new 
DefaultResultContext();
 this.skipRows(rsw.getResultSet(), rowBounds);
 Object rowValue = null;
 while(this.shouldProcessMoreRows(resultContext, rowBounds) 
&& rsw.getResultSet().next()) {
 ResultMap discriminatedResultMap = this.resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, 
(String)null);
 CacheKey rowKey = this.createRowKey(discriminatedResultMap, rsw,
 (String)null);
 Object partialObject = this.nestedResultObjects.get(rowKey);
 if(this.mappedStatement.isResultOrdered()) {
 if(partialObject == null && rowValue != null) {
 this.nestedResultObjects.clear();
 this.storeObject(resultHandler, resultContext, rowValue, 
parentMapping, rsw.getResultSet());
 }
 //获取行的值
 rowValue = this.getRowValue(rsw, discriminatedResultMap, 
rowKey, (String)null, partialObject);
 } else {
 rowValue = this.getRowValue(rsw, discriminatedResultMap, 
 rowKey, (String)null, partialObject);
 if(partialObject == null) {
 this.storeObject(resultHandler, resultContext, rowValue, 
parentMapping, rsw.getResultSet());
 }
 }
 }
 if(rowValue != null && this.mappedStatement.
isResultOrdered() && this.shouldProcessMoreRows
(resultContext, rowBounds)) {
 this.storeObject(resultHandler, resultContext, rowValue,
 parentMapping, rsw.getResultSet());
 }
 }
 String resultMapId = resultMap.getId();
 Object resultObject = partialObject;
 if(partialObject != null) {
 MetaObject metaObject = this.configuration.newMetaObject
(partialObject); this.putAncestor(partialObject, 
resultMapId, columnPrefix);
 this.applyNestedResultMappings(rsw, resultMap, metaObject, 
columnPrefix, combinedKey, false);
 this.ancestorObjects.remove(resultMapId);
 } else {
 ResultLoaderMap lazyLoader = new ResultLoaderMap();
 resultObject = this.createResultObject(rsw, resultMap,
 lazyLoader, columnPrefix);
 if(resultObject != null && !this.typeHandlerRegistry.
hasTypeHandler(resultMap.getType())) {
 MetaObject metaObject = this.configuration.
newMetaObject(resultObject);
 boolean foundValues = !resultMap.getConstructorResult
Mappings().isEmpty();
 if(this.shouldApplyAutomaticMappings(resultMap, true)) {
 foundValues = this.applyAutomaticMappings
(rsw, resultMap, metaObject, columnPrefix) || foundValues;
 }
 foundValues = this.applyPropertyMappings(rsw, 
resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
 this.putAncestor(resultObject, resultMapId, columnPrefix);
 foundValues = this.applyNestedResultMappings(rsw, 
 resultMap, metaObject, columnPrefix, combinedKey, true) 
|| foundValues;
 this.ancestorObjects.remove(resultMapId);
 foundValues = lazyLoader.size() > 0 || foundValues;
 resultObject = foundValues?resultObject:null;
 }
 if(combinedKey != CacheKey.NULL_CACHE_KEY) {
 this.nestedResultObjects.put(combinedKey, resultObject);
 }
 }
 return resultObject;
 }private boolean shouldApplyAutomaticMappings
(ResultMap resultMap, boolean isNested) {
 return resultMap.getAutoMapping() != null?resultMap.getAutoMapping().booleanValue():
(isNested?AutoMappingBehavior.FULL == this.configuration.
getAutoMappingBehavior():
AutoMappingBehavior.NONE != this.configuration.
getAutoMappingBehavior());
 }
 private boolean applyAutomaticMappings(ResultSet
Wrapper rsw, ResultMap resultMap, MetaObject metaObject, 
String columnPrefix) throws SQLException {
 List<DefaultResultSetHandler.UnMappedColumAutoMapping> 
 autoMapping = this.createAutomaticMappings(rsw, resultMap,
 metaObject, columnPrefix);
 boolean foundValues = false;
 if(autoMapping.size() > 0) {
 Iterator i$ = autoMapping.iterator();
 while(true) {
 //这里使用了内部类对参数和结果集进行映射
 DefaultResultSetHandler.UnMappedColumAutoMapping mapping;
 Object value;
 do {
 if(!i$.hasNext()) {
 return foundValues;
 }
 mapping = (DefaultResultSetHandler.UnMapped
ColumAutoMapping)
 i$.next();value = mapping.typeHandler.getResult
(rsw.getResultSet(), mapping.column);
 } while(value == null && !this.configuration.
isCallSettersOnNulls());
 if(value != null || !mapping.primitive) {
 metaObject.setValue(mapping.property, value);
 }
 foundValues = true;
 }
 } else {
 return foundValues;
 }
 }
 private static class UnMappedColumAutoMapping {
 private final String column;
 private final String property;
 private final TypeHandler<?> typeHandler;
 private final boolean primitive;
 //此处才类型器对结果进行映射
 public UnMappedColumAutoMapping(String column, 
String property, TypeHandler<?> typeHandler, 
 boolean primitive) {
 this.column = column;
 this.property = property;
 this.typeHandler = typeHandler;
 this.primitive = primitive;
 }
 }