Mybatis源码详解之接口方法被执行流程源码解析

时间:2022-01-19 17:17:14

        与上一篇Mybatis源码解析的博客已经隔了好长一段时间,最近发生了一些乱七八糟糟心的事情,甚至每天加班,没来得及写点什么,最近一个月的学习是乱的一塌糊涂。

        接着上一篇的分析,上一篇完成了所有配置文件的解析,将各个配置文件都解析到一个叫Configuration的类里,这些就是接口方法可以被执行的元数据,任何一个方法的执行必然依赖于此。接口方法执行流程就是怎样使用这些元数据呢?

        还是以最开始的实例工程引入方法执行,相信已经走到这里了,也肯定知道接口方法的执行就是对接口的一个动态代理。

        还记得上一篇博客中addMapper函数,最终把接口注册到一个Map缓存中,即knownMappers。

        下面开始今天的分析:

(1)对接口实现动态代理

          IPlayDao play = sqlSession.getMapper(IPlayDao.class);
主要就是这句,经过getMapper方法以后,返回的已经不是接口了,而是一个经过动态代理的代理类了。

public <T> T getMapper(Class<T> type) {
return configuration.<T>getMapper(type, this);
}
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
//没有什么值得分析的,前面两个类就是带着传入的接口层层传递
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
//这里就是上一篇一个mapper.xml文件中,namespace接口注册的一个缓存,从这个缓存中用接口提取出代理工厂
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
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);
}
}

     带着接口步步深入,看到了proxy工厂,没有什么难易理解的部分,主要就是那个缓存中取代理工厂,这是初始化中非常关键的一个点。还有就是sqlSession的传递,也算是个关键,这块儿应该也算一种命令模式,因为未来不知道要调用接口的什么方法,所有要执行该方法的流程最终需要借助于sqlSession的分配,所以此处带着它层层传递,sqlSession是规划执行接口方法的总管。接着看代理工厂是怎么对所有的接口统一处理的。

public T newInstance(SqlSession sqlSession) {
//sqlsession,接口都传入到了MapperProxy里,这个类就是实现InvocationHandler的类,methodCache这里传入一个空的参数
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}

@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
//看到了动态代理的实例化部分,相当于接口被实例化了,这就是getMapper最终返回的一个接口代理
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
显然,所有的接口子这个工厂类里被代理了,下一次调用接口中的方法的时候,直接进入了MapperProxy类的invoke方法中了,MapperProxy类里也包含了所有用到的属性,知道是属于哪个接口的代理,还有sqlSession属性,该属性中包含有Configuration,Executor。下面接着分析这个MapperProxy类。

(2)动态代理的统一处理,invoke方法

Ball ball = play.selectBall("1");
调用接口的方法,直接跳转到MapperProxy类的invoke方法,具体看一下:

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;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//首先判断该方法所属的类是否是一个对象,如果是直接反射调用该方法,显然,这里传递进来的是接口,不会进入if分支
if (Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
//这里将传入的方法包装成为一个MapperMethod
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
//包装每个被调用的方法
private MapperMethod cachedMapperMethod(Method method) {
//这就是当时代理工厂传进来的空的methodCache参数,就是一个简单的Map缓存,提高效率,只要被调用过一次就不会重新包装,直接从缓存中取
MapperMethod mapperMethod = methodCache.get(method);
if (mapperMethod == null) {
//方法包装
mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
methodCache.put(method, mapperMethod);
}
return mapperMethod;
}

}
这里就是动态代理的最关键类了,看起来是不是其实也很简单,下面看一下方法的包装里做了些什么。

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
//传入的三大参数构造出两个内部类,类似于初始化,封装资源的一个过程,后面分析一下这两个内部类
//这个是提取以前初始化时候注册的MappedStatement
this.command = new SqlCommand(config, mapperInterface, method);
//这个是对被调用方法的一个封装提取
this.method = new MethodSignature(config, method);
}
//SqlCommand构造函数
public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
//还记得在构建MappedStatement的过程中,有这么一句注册configuration.addMappedStatement(statement);
//这里就是在构造提取MappedStatement的Map中的key
String statementName = mapperInterface.getName() + "." + method.getName();
MappedStatement ms = null;
if (configuration.hasStatement(statementName)) {
ms = configuration.getMappedStatement(statementName);
} else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // issue #35
String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
if (configuration.hasStatement(parentStatementName)) {
ms = configuration.getMappedStatement(parentStatementName);
}
}
if (ms == null) {
throw new BindingException("Invalid bound statement (not found): " + statementName);
}
//提取出ms,初始化了些参数
name = ms.getId();//其实这个就是mapper.xml中每个sql节点的id,也就是方法名
type = ms.getSqlCommandType(); //这个是该条sql语句的标签,是insert|select|delete|update
if (type == SqlCommandType.UNKNOWN) {
throw new BindingException("Unknown execution method for: " + name);
}
}
//MethodSignature的构造函数,就是对调用方法的一个解剖封装,提取各项参数
public MethodSignature(Configuration configuration, Method method) throws BindingException {
this.returnType = method.getReturnType();
this.returnsVoid = void.class.equals(this.returnType);
this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
this.mapKey = getMapKey(method);
this.returnsMap = (this.mapKey != null);
this.hasNamedParameters = hasNamedParams(method);
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
}
这里其实也可以看作是一个初始化的过程,在执行方法之前,提取资源库中的各种该方法应用的资源

(3)开始方法调用的执行

在mapperProxy的invoke方法最后一句,即调用封装后的MapperMethod的execute方法,从这里展开了接口方法的具体执行

//传入sqlSession和待执行方法的参数(也就是sql语句中需要的参数(PrepareStatement的参数))
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
//首先根据封装该方法时候所封装的type判断是什么类型的sql语句, 选择不同的方法处理
//insert
if (SqlCommandType.INSERT == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
//update
} else if (SqlCommandType.UPDATE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
//delete
} else if (SqlCommandType.DELETE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
//select 讲解以select为例子,各中sql语句的流程基本一样
} else if (SqlCommandType.SELECT == command.getType()) {
//判断是select语句以后,还有不同的情况,就是封装方法时候的另一个类,methodsigature中的字段再次判断判断
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 {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
} else {
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带在方法的参数里往下一级传递。

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
List<E> result;
//作了一个简单处理,如果有多个参数,将其封装在一个Map里
Object param = method.convertArgsToSqlCommandParam(args);
//如果method有分页信息,进if分支,大多数情况不会用系统自带分页,都是自己写分页拦截器实现分页
if (method.hasRowBounds()) {
RowBounds rowBounds = method.extractRowBounds(args);
result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
} else {
//sqlSession开启了真正的运筹帷幄的时候了(也就是命令模式应用的时候了,封装了各种功能,可以统一处理增删改查)
result = sqlSession.<E>selectList(command.getName(), param);
}
// issue #510 Collections & arrays support
if (!method.getReturnType().isAssignableFrom(result.getClass())) {
if (method.getReturnType().isArray()) {
return convertToArray(result);
} else {
return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
}
}
return result;
}
终于到了sqlSession调用它方法的时候了。即将运筹它下面的四大对象来完成调用流程。

//第一个参数statement,忘记了没有,封装方法的时候(SqlCommand类中),就是接口名.方法名;
//第二个参数就是sql语句中缺的参数
public <E> List<E> selectList(String statement, Object parameter) {
return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
//用这个statement从资源类中取出MappedStatement,这个类包含了mapper.xml文件中一个sql节点的所有信息
MappedStatement ms = configuration.getMappedStatement(statement);
//executor是什么,执行器,他来调度其他三个StatementHandler,ParameterHandler,ResultHandler来执行sql语句,
//他是怎么来的呢,在初始化出来sqlSession的时候就newExecutor过了,如果不传入特殊的Executor,会有一个默认的执行器
List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
return result;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
解析来到了Executor中,执行BaseExecutor中的qurey方法

//前两个参数,一个是sql节点,一个是传入的参数,后两个为null
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
//进来首先获取BoundSql,这个BoundSql是什么呢,他就是建立sql和参数的地方,调用ms的方法获取,下面具体看怎么获取
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

public BoundSql getBoundSql(Object parameterObject) {
//ms中没干什么,直接将其转入下一层,sqlSource中获取,还记得初始化收构建SqlSource吗,这里确实是一个难点,下面再进入到SqlSource类
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings == null || parameterMappings.size() <= 0) {
boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
}

// check for nested result maps in parameter mappings (issue #30)
for (ParameterMapping pm : boundSql.getParameterMappings()) {
String rmId = pm.getResultMapId();
if (rmId != null) {
ResultMap rm = configuration.getResultMap(rmId);
if (rm != null) {
hasNestedResultMaps |= rm.hasNestedResultMaps();
}
}
}

return boundSql;
}
//这里是一个DynamicSqlSource的getBoundSql方法(mybatis中大多数的sql都是带有where,if等各种条件的也就是动态的)
public BoundSql getBoundSql(Object parameterObject) {
DynamicContext context = new DynamicContext(configuration, parameterObject);
rootSqlNode.apply(context);
SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
}
return boundSql;
}
这里的逻辑有一点没一步步分析清楚,总之最后将各个条件合并,封装出一个BoundSql,其里面已经包含了sql语句执行的所有的完整内容,等后面会继续对这部分完善,逐步分析到底是怎么一步步将sql语句拼接,封装的。

    拿到boundSql以后调到另一个query方法中

//看这个方法,其实什么也没做,只是些逻辑判断或者安全处理,关键的一步就是又转到了另一个函数queryFromDatabase
@SuppressWarnings("unchecked")
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 (closed) throw new ExecutorException("Executor was closed.");
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
deferredLoads.clear(); // issue #601
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
clearLocalCache(); // issue #482
}
}
return list;
}
//这个方法也是些逻辑判断等简单处理,就不细纠了,咱们只是跟踪执行流程,下面看到doQuery方法, 这个就是Executor中真正做事的方法了
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;
}
上面一些流程没有什么实质性的内容,下面主要分析doQuery方法,这个方法是执行器中的真正方法了, 在baseExecutor中是个抽象方法,根据自己配置的Executor,执行不同的查询方法,大多数时候只需要使用默认执行器即可,即SimpleExecutor

/**
*
* @param ms 被执行方法对应的sql节点全部信息
* @param parameter sql参数
* @param rowBounds null
* @param resultHandler null
* @param boundSql sql语句
* @return
* @throws SQLException
*/
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();
//这句创建出执行sql的关键类,整个流程会创建出ParameterHandler,ResultHandler,下面看详细流程
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
//各个参数于上面一样
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//RoutingStatementHandler不是我们真实服务的对象,它是用适配器模式找到对应的StatementHandler来执行,RoutingStatementHandler继承自StatementHandler,
//有一个StatementHandler属性,一种特殊的适配器模式,具体选择哪种还是靠简单工厂来选择
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
//Mybatis插件,前面博客专门讲解过
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//简单工厂模式选择合适的StatementHandler,与三种执行器相对应,这里StatementHandler对应这jdbc的Statement,PrepareStatement.
switch (ms.getStatementType()) {
case STATEMENT:
delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case PREPARED:
delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case CALLABLE:
delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}

}
//对应JDBC的prepareStatement
public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
}
//构造函数
protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

this.configuration = mappedStatement.getConfiguration();
this.executor = executor;
this.mappedStatement = mappedStatement;
this.rowBounds = rowBounds;

this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
this.objectFactory = configuration.getObjectFactory();

if (boundSql == null) { // issue #435, get the key before calculating the statement
generateKeys(parameterObject);
boundSql = mappedStatement.getBoundSql(parameterObject);
}

this.boundSql = boundSql;
//其他两大对象,参数和结果集处理器,创建的过程就不看了, 比较简单,Mybatis都有ParameterHandler和ResultSetHandler的default实现
this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
}
newStatementHadler的过程将sql语句执行的前置条件都准备好了,到这里四大对象已经都初始化完成,下面就是利用四大对象来完成执行的时候了。下面看doQuery的后两句内容。

stmt = prepareStatement(handler, ms.getStatementLog());
其实执行sql语句,最终还是用jdk的jdbc来处理,前面只是为了便利对他的各种封装,下面又即将要看到他的庐山真面目了,其实所说的基础知识最重要,也就重要在这种地方,最终的本质肯定是万变不离其宗,扎实的基础会对理解框架的核心部分事半功倍。

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
//这个就是jdbc的statement,这里就看到了熟悉的味道
Statement stmt;
//connection,从我们配置文件初始化中初始化的dataSource取得连接,具体和jdbc的处理一样
Connection connection = getConnection(statementLog);
//用connection创建statement
stmt = handler.prepare(connection);
handler.parameterize(stmt);
return stmt;
}
//BaseStatementHandler
public Statement prepare(Connection connection) throws SQLException {
ErrorContext.instance().sql(boundSql.getSql());
Statement statement = null;
try {
//创建statement,Statement和PrepareStatement的创建略有不同,后者在创建的时候
//需要将sql语句模板传进去,也就是两者使用sql的时机不同,这个方法是个抽象方法,根据不同的StatementHandler
//选择不同的处理方式,下面具体看
statement = instantiateStatement(connection);
setStatementTimeout(statement);
setFetchSize(statement);
return statement;
} catch (SQLException e) {
closeStatement(statement);
throw e;
} catch (Exception e) {
closeStatement(statement);
throw new ExecutorException("Error preparing statement. Cause: " + e, e);
}
}
创建Statement,下面看下instantiateStatement方法

//SimpleStatementHandler中的是实现,这个没什么逻辑直接创建Statement
protected Statement instantiateStatement(Connection connection) throws SQLException {
if (mappedStatement.getResultSetType() != null) {
return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
} else {
return connection.createStatement();
}
}
//PreparedStatementHandler中的实现,这个创建PrepareStatement提前需要sql
protected Statement instantiateStatement(Connection connection) throws SQLException {
//从boundSql中取得sql
String sql = boundSql.getSql();
if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
String[] keyColumnNames = mappedStatement.getKeyColumns();
if (keyColumnNames == null) {
return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
} else {
return connection.prepareStatement(sql, keyColumnNames);
}
} else if (mappedStatement.getResultSetType() != null) {
return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
} else {
return connection.prepareStatement(sql);
}
}
逻辑也比较简单,只要对JDBC的逻辑过程比较熟悉,这里都是一样的,经过这个方法以后就从Connection中取到了Statement或者PreparedStatement

接着就是像jdbc一样设置sql模板的参数值,当然如果是Statement的话就不需要设置了,看下Mybatis是怎么处理的。

handler.parameterize(stmt);

这里就是为sql设置参数,下面看下不同的参数Handler是怎么处理的    

//SimpleStatementHandler中不需要设置,空函数
public void parameterize(Statement statement) throws SQLException {
// N/A
}
//PreparedStatementHandler
public void parameterize(Statement statement) throws SQLException {
parameterHandler.setParameters((PreparedStatement) statement);
}
//newParameterHandler的时候初始化了DefaultParameterHnadler,这里用初始化时候的参数组装sql中的参数之
public void setParameters(PreparedStatement ps) throws SQLException {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
//取得sql语句和类对应的数据类型
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
//使用这个映射关系转化两种不同的系统中的数据类型
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull();
typeHandler.setParameter(ps, i + 1, value, jdbcType);
}
}
}
}
下面就剩下最后一步,执行sql语句了,不论是prepareStatement还是Statement都统一处理完了sql语句,剩下执行了

handler.<E>query(stmt, resultHandler);
大家发现没有,之前的所有逻辑是在Executor中处理,后来所有的这些组装过程都是在StatementHandler中处理的,有种感觉就是Executor包含者StatementHandler,将逻辑转到StatementHandler以后,感觉StatementHandler中包含着ParameterHandler和ResultSetHandler.

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
throws SQLException {
String sql = boundSql.getSql();
statement.execute(sql);
return resultSetHandler.<E>handleResultSets(statement);
}
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
比较简单,就不分析了,直接调用jdbc的函数,执行sql语句,对sql语句的执行结果Mybatis又进行了封装,也就是ResultSetHandler的工作开始了
public List<Object> handleResultSets(Statement stmt) throws SQLException {
final List<Object> multipleResults = new ArrayList<Object>();

int resultSetCount = 0;
ResultSetWrapper rsw = getFirstResultSet(stmt);

List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount);
while (rsw != null && resultMapCount > resultSetCount) {
ResultMap resultMap = resultMaps.get(resultSetCount);
handleResultSet(rsw, resultMap, multipleResults, null);
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}

String[] resultSets = mappedStatement.getResulSets();
if (resultSets != null) {
while (rsw != null && resultSetCount < resultSets.length) {
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
handleResultSet(rsw, resultMap, null, parentMapping);
}
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
}

return collapseSingleResultList(multipleResults);
}
       最终封装为一个list返回了,到这里整个方法的执行就结束了,其实看起来整个逻辑也没这么复杂,最后的关键部分都是对jcbc的封装,确实基础很关键。还有比较关键的一个部分就是sql语句的拼接部分,也就是BoundSql的产生过程,后面还值得分析理解。

      做一个对上面过程简单的总结梳理:SqlSession是通过Executor创建StatementHandler来运行的,而StatementHandler经过下面三步来执行sql

 (1)prepared预编译SQL;

 (2)parameterize设置参数;

 (3)query执行sql

     parameterize是调用parameterHandler的方法去设置的,而参数是根据类型处理器typeHandler去处理的。query方法是通过resultHandler进行结果封装的,如果是update直接返回证书,否则它通过typeHandler处理结果类型,然后用ObjectFactory提供的规则组装对象,返回给调用者。

最后QQ交流群(341252823),新建的,目前没有人,期望你的加入,可以一起讨论一些问题

下一篇文章准备写一下Mybatis和Spring的连接部分。