终于来到最后的重头戏了，执行方法返回结果，首先在执行之前，mybatis需要构建执行环境，包括执行器，数据源工厂，事务工厂等对象，执行器负责执行数据库的增删改查，数据源工厂负责获取与关闭数据库连接，事务负责SQL语句的提交与回滚。

Executor

/*** @author Mr.Wang* @Description: 执行器类型枚举类* @date 2019/10/10 18:13*/
public enum MyExecutorType {SIMPLE, REUSE, BATCH
}

执行器类型：1.简单执行器；2.重用执行器；3.批量执行器。

先看看它们的接口类Executor：

/*** @author Mr.Wang* @Description: 执行器* @date 2019/5/11 20:08*/
public interface MyExecutor {/*** 查询操作** @param mapperStatement* @param parameters* @param <E>* @return* @throws SQLException*/<E> List<E> query(MyMappedStatement mapperStatement, Object[] parameters) throws SQLException;/*** 查询操作（带CacheKey）** @param mapperStatement* @param parameters* @param key* @param <E>* @return* @throws SQLException*/<E> List<E> query(MyMappedStatement mapperStatement, Object[] parameters, MyCacheKey key) throws SQLException;/*** 更新操作** @param mapperStatement* @param parameters* @return* @throws SQLException*/int update(MyMappedStatement mapperStatement, Object[] parameters) throws SQLException;/*** 提交事务** @param required* @throws SQLException*/void commit(boolean required) throws SQLException;/*** 事务回滚** @param required* @throws SQLException*/void rollback(boolean required) throws SQLException;/*** 获取事务对象** @return*/MyTransaction getTransaction();/*** 创建CacheKey** @param ms* @param parameters* @return*/MyCacheKey createCacheKey(MyMappedStatement ms, Object[] parameters);/*** 是否缓存** @param ms* @param key* @return*/boolean isCached(MyMappedStatement ms, MyCacheKey key);/*** 清空缓存*/void clearLocalCache();/*** 关闭Executor对象** @param forceRollback*/void close(boolean forceRollback);/*** 检测Executor对象是否关闭** @return*/boolean isClosed();void setExecutorWrapper(MyExecutor executor);
}

DataSourceFactory

数据源工厂有三种类型：1.托管型；2.非池型；3.池型。
先看看它们的接口类DataSourceFactory：

/*** @author Mr.Wang* @Description: 数据源工厂* @date 2019/10/11 22:38*/
public interface MyDataSourceFactory {void setProperties(Properties props);DataSource getDataSource();
}

TransactionFactory

事务工厂有两种类型：1.JDBC；2.MANAGED。
先看看它们的接口类TransactionFactory：

/*** @author Mr.Wang* @Description: 事务工厂接口类* @date 2019/10/10 15:11*/
public interface MyTransactionFactory {default void setProperties(Properties props) {}MyTransaction newTransaction(Connection conn);MyTransaction newTransaction(DataSource dataSource, MyTransactionIsolationLevel level, boolean autoCommit);
}

由于数据源和事务这块相对简单，我们将着重介绍执行器的内容。首先是实现Executor接口的抽象类BaseExecutor：

/*** @author Mr.Wang* @Description: 基础执行器* @date 2019/10/10 14:57*/
public abstract class MyBaseExecutor implements MyExecutor {protected MyTransaction transaction;protected MyConfiguration configuration;protected MyExecutor wrapper;protected MyPerpetualCache localCache;private boolean closed;protected MyBaseExecutor(MyConfiguration configuration, MyTransaction transaction) {this.transaction = transaction;this.closed = false;this.configuration = configuration;this.wrapper = this;this.localCache = new MyPerpetualCache("LocalCache");}@Overridepublic <E> List<E> query(MyMappedStatement mapperStatement, Object[] parameters) throws SQLException {//创建CacheKeyMyCacheKey key = createCacheKey(mapperStatement, parameters);return query(mapperStatement, parameters, key);}@Overridepublic <E> List<E> query(MyMappedStatement mapperStatement, Object[] parameters, MyCacheKey key) throws SQLException {if (closed) {throw new RuntimeException("Executor was closed.");}//先从缓存中获取数据结果集List<E> list = (List<E>) localCache.getObject(key);if (list == null) {//缓存未命中，则查询数据库list = queryFromDatabase(mapperStatement, parameters, key);}return list;}@Overridepublic int update(MyMappedStatement mapperStatement, Object[] parameters) throws SQLException {if (closed) {throw new RuntimeException("Executor was closed.");}//执行修改操作，清空所有缓存clearLocalCache();return doUpdate(mapperStatement, parameters);}@Overridepublic void commit(boolean required) throws SQLException {if (closed) {throw new RuntimeException("Cannot commit, transaction is already closed");}if (required) {clearLocalCache();transaction.commit();}}@Overridepublic void rollback(boolean required) throws SQLException {if (!closed) {clearLocalCache();if (required) {transaction.rollback();}}}@Overridepublic MyTransaction getTransaction() {if (closed) {throw new RuntimeException("Executor was closed.");}return transaction;}@Overridepublic MyCacheKey createCacheKey(MyMappedStatement ms, Object[] parameters) {if (closed) {throw new RuntimeException("Executor was closed.");}MyCacheKey cacheKey = new MyCacheKey();cacheKey.update(ms.getNamespace());cacheKey.update(ms.getId());cacheKey.update(ms.getSql());if (parameters != null && parameters.length > 0) {for (Object value : parameters) {cacheKey.update(value);}}if (configuration.getEnvironment() != null) {cacheKey.update(configuration.getEnvironment().getId());}return cacheKey;}@Overridepublic boolean isCached(MyMappedStatement ms, MyCacheKey key) {return localCache.getObject(key) != null;}@Overridepublic void clearLocalCache() {if (!closed) {localCache.clear();}}@Overridepublic void close(boolean forceRollback) {try {try {rollback(forceRollback);} finally {if (transaction != null) {transaction.close();}}} catch (SQLException e) {throw new RuntimeException("Unexpected exception on closing transaction.  Cause: " + e);} finally {transaction = null;localCache = null;closed = true;}}@Overridepublic boolean isClosed() {return closed;}@Overridepublic void setExecutorWrapper(MyExecutor wrapper) {this.wrapper = wrapper;}private <E> List<E> queryFromDatabase(MyMappedStatement ms, Object[] parameters, MyCacheKey key) throws SQLException {List<E> list;try {list = doQuery(ms, parameters);} finally {//删除缓存localCache.removeObject(key);}//将结果放入缓存localCache.putObject(key, list);return list;}protected abstract int doUpdate(MyMappedStatement ms, Object parameter)throws SQLException;protected abstract <E> List<E> doQuery(MyMappedStatement ms, Object[] parameters)throws SQLException;protected Connection getConnection() throws SQLException {Connection connection = transaction.getConnection();return connection;}protected void closeConnect(ResultSet resultSet, PreparedStatement preparedStatement, Connection connection) {if (resultSet != null) {try {resultSet.close();} catch (SQLException e) {e.printStackTrace();}}if (preparedStatement != null) {try {preparedStatement.close();} catch (SQLException e) {e.printStackTrace();}}if (connection != null) {try {transaction.close();} catch (SQLException e) {e.printStackTrace();}}}
}

可以看到，在BaseExecutor类中留有两个抽象方法，具体的实现需要子类去完成，再看看SimpleExecutor的代码：

/*** @author Mr.Wang* @Description: 简单执行器* @date 2019/8/26 19:59*/
public class MySimpleExecutor extends MyBaseExecutor {public MySimpleExecutor(MyConfiguration configuration, MyTransaction transaction) {super(configuration, transaction);}@Overrideprotected int doUpdate(MyMappedStatement mappedStatement, Object parameters) throws SQLException {Connection connection = null;PreparedStatement preparedStatement = null;int resultCount = 0;try {//获取数据库连接connection = getConnection();//实例化StatementHandler对象MyStatementHandler statementHandler = new MySimpleStatementHandler(mappedStatement);//通过StatementHandler和connection获取PreparedStatementpreparedStatement = statementHandler.prepare(connection);//实例化ParameterHandler，将SQL语句中？参数化MyParameterHandler parameterHandler = new MyDefaultParameterHandler(configuration, parameters);parameterHandler.setParameters(preparedStatement);//执行SQLresultCount = statementHandler.update(preparedStatement);} catch (SQLException e) {e.printStackTrace();} finally {closeConnect(null, preparedStatement, connection);}return resultCount;}@Overrideprotected <E> List<E> doQuery(MyMappedStatement mappedStatement, Object[] parameters) throws SQLException {List<E> resultList = new ArrayList<>();Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {//获取数据库连接connection = getConnection();//实例化StatementHandler对象MyStatementHandler statementHandler = new MySimpleStatementHandler(mappedStatement);//通过StatementHandler和connection获取PreparedStatementpreparedStatement = statementHandler.prepare(connection);//实例化ParameterHandler，将SQL语句中？参数化MyParameterHandler parameterHandler = new MyDefaultParameterHandler(configuration, parameters);parameterHandler.setParameters(preparedStatement);//执行SQL，得到结果集ResultSetresultSet = statementHandler.query(preparedStatement);//实例化ResultSetHandler，通过反射将ResultSet中结果设置到目标resultType对象中MyResultSetHandler resultSetHandler = new MyDefaultResultSetHandler(configuration, mappedStatement);//将结果集转换为返回类型resultList = resultSetHandler.handleResultSets(resultSet);} catch (Exception e) {e.printStackTrace();} finally {closeConnect(resultSet, preparedStatement, connection);}return resultList;}
}

可以看到，在做真正的数据库操作之前，还需要进行SQL语句的预处理，用到了接口类StatementHandler：

/*** @author Mr.Wang* @Description:* @date 2019/8/26 20:57*/
public interface MyStatementHandler {/*** SQL预处理** @param paramConnection* @return* @throws SQLException* @see*/PreparedStatement prepare(Connection paramConnection) throws SQLException;/*** 查询数据库** @param preparedStatement* @return* @throws SQLException* @see*/ResultSet query(PreparedStatement preparedStatement) throws SQLException;/*** update** @param preparedStatement* @throws SQLException*/int update(PreparedStatement preparedStatement) throws SQLException;
}

以及对参数的处理，用到了接口类ParameterHandler：

/*** @author Mr.Wang* @Description:* @date 2019/8/26 20:54*/
public interface MyParameterHandler {/*** 设置参数** @param paramPreparedStatement* @see*/void setParameters(PreparedStatement paramPreparedStatement);
}

StatementHandler的实现类SimpleStatementHandler：

/*** @author Mr.Wang* @Description:* @date 2019/8/26 20:58*/
public class MySimpleStatementHandler implements MyStatementHandler {private MyMappedStatement mappedStatement;public MySimpleStatementHandler(MyMappedStatement mappedStatement) {this.mappedStatement = mappedStatement;}@Overridepublic PreparedStatement prepare(Connection paramConnection) throws SQLException {String originalSql = mappedStatement.getSql();if (originalSql != null && !"".equals(originalSql)) {// 替换#{}，预处理，防止SQL注入return paramConnection.prepareStatement(SqlParser.parse(originalSql));} else {throw new SQLException("original sql is null.");}}@Overridepublic ResultSet query(PreparedStatement preparedStatement) throws SQLException {return preparedStatement.executeQuery();}@Overridepublic int update(PreparedStatement preparedStatement) throws SQLException {return preparedStatement.executeUpdate();}
}

ParameterHandler的实现类DefaultParameterHandler：

/*** @author Mr.Wang* @Description:* @date 2019/8/26 20:55*/
public class MyDefaultParameterHandler implements MyParameterHandler {private MyTypeHandlerRegistry typeHandlerRegistry;private Object parameterObject;public MyDefaultParameterHandler(MyConfiguration configuration, Object parameterObject) {this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();this.parameterObject = parameterObject;}/*** 将SQL参数设置到PreparedStatement中** @param paramPreparedStatement*/@Overridepublic void setParameters(PreparedStatement paramPreparedStatement) {if (parameterObject != null) {if (parameterObject.getClass().isArray()) {Object[] params = (Object[]) parameterObject;Class<?> javaType = null;MyJdbcType jdbcType = null;for (int i = 0; i < params.length; i++) {if (params[i] instanceof Integer) {javaType = Integer.class;jdbcType = MyJdbcType.INTEGER;} else if (params[i] instanceof String) {javaType = String.class;jdbcType = MyJdbcType.VARCHAR;} else {javaType = Object.class;jdbcType = MyJdbcType.OTHER;}//根据JavaType获取对应的类型转换器MyTypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(javaType);try {typeHandler.setParameter(paramPreparedStatement, i + 1, params[i], jdbcType);} catch (SQLException e) {throw new RuntimeException("Could not set parameters for mapping: " + parameterObject + ". Cause: " + e, e);}}}}}
}

在数据库操作完成之后，针对查询方法返回的结果需要用到结果集转换器进行处理，ResultSetHandler接口类：

/*** @author Mr.Wang* @Description: 结果集转换器* @date 2019/8/26 20:45*/
public interface MyResultSetHandler {/*** 处理查询结果** @param resultSet* @return* @see*/<E> List<E> handleResultSets(ResultSet resultSet);
}

DefaultResultSetHandler类是ResultSetHandler类的默认实现：

/*** @author Mr.Wang* @Description:* @date 2019/8/26 20:46*/
public class MyDefaultResultSetHandler implements MyResultSetHandler {private final MyMappedStatement mappedStatement;private MyTypeHandlerRegistry typeHandlerRegistry;public MyDefaultResultSetHandler(MyConfiguration configuration, MyMappedStatement mappedStatement) {this.mappedStatement = mappedStatement;this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();}@Overridepublic <E> List<E> handleResultSets(ResultSet resultSet) {List<E> resultList = new ArrayList<>();if (resultSet == null) {return null;}try {Class<E> tClass = (Class<E>) Class.forName(mappedStatement.getResultType());while (resultSet.next()) {Object entity = tClass.newInstance();setProToBeanFromResult(entity, resultSet);resultList.add((E) entity);}} catch (ClassNotFoundException e) {e.printStackTrace();} catch (SQLException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}return resultList;}private void setProToBeanFromResult(Object entity, ResultSet resultSet) throws SQLException {ResultSetMetaData resultSetMetaData = resultSet.getMetaData();int count = resultSetMetaData.getColumnCount();Field[] declaredFields = entity.getClass().getDeclaredFields();Class<?> javaType = null;for (int i = 0; i < count; i++) {String columnName = resultSetMetaData.getColumnName(i + 1).replace("_", "").toUpperCase();for (int j = 0; j < declaredFields.length; j++) {String fieldName = declaredFields[j].getName().toUpperCase();if (columnName.equalsIgnoreCase(fieldName)) {javaType = null;if ("Integer".equals(declaredFields[j].getType().getSimpleName())) {javaType = Integer.class;} else if ("String".equals(declaredFields[j].getType().getSimpleName())) {javaType = String.class;} else {javaType = Object.class;}//根据JavaType获取对应的类型转换器MyTypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(javaType);Object value = typeHandler.getResult(resultSet, resultSetMetaData.getColumnName(i + 1));ReflectionUtil.setProToBean(entity, declaredFields[j].getName(), value);break;}}}}
}

使用反射原理将ResultSet转换成bean对象，到这里，mybatis的执行流程就大致介绍完了，还有些内容没有介绍到，比如类型转换器和缓存的内容，会放在最后一篇介绍。