转载

带你一步一步手写一个简单的 Mybatis

在前两篇文章中我向你介绍了 Mybatis 的构建和执行流程，这篇文章中我会带领你一步一步手写一个简单的 Mybatis 框架。

本文主要涉及代码实现，很多要点会在代码注释中说明，请仔细阅读。

所有代码已经在 github 上托管，感兴趣的同学可以自行 fork 。看完记得点赞哦(#^.^#)

仿写框架的文章，我会尽量将源代码贴出来(很多思路已经写在了源码注释中)，如果。。。。

如果还没看过我前两篇文章的请戳这里

带你一步一步手撕 Mybatis 源码加手绘流程图——构建部分
带你一步一步手撕 Mybatis 源码加手绘流程图——执行部分

提炼构建部分核心类

既然是仿写一个简单的，那么我们就不可能面面俱到，和分析源码一样，我们需要一步一步跟着主线走。所以我们首先要提炼出整个框架构建流程所涉及到的核心类，然后再去仿写。

在第一篇的构建文章中我画了一张简单的流程图，这里我直接拿来用，以便提炼我们的核心类。

在第一篇文章中我已经通过源码向大家解释了这张图的由来，这里我不再赘述。直接动手开干吧！

构建部分仿写

SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder

在第二篇文章中我画了关于 SqlSessionFactory 的 工厂模式UML 图

我们可以通过这张图构建一个简单的 SqlSession 和 SqlSessionFactory 。

public interface SqlSession {
   // 目前什么都没有 不用管 具体内容应该在执行部分
}
复制代码

public interface SqlSessionFactory {
    // 创建 SqlSession
    SqlSession openSqlSession();
}
复制代码

你肯定不禁感叹，这 tnd 也太简单了。

其实就是这么简单。

当然，有了 SqlSession 和 SqlSessionFactory 之后还需要使用一个 SqlSessionFactoryBuilder 来构建 SqlSessionFactory 。这里使用到了 构建者模式 。

public class SqlSessionFactoryBuilder {
    // 通过输入流去创建 XMLConfigBuilder
    public SqlSessionFactory build(InputStream inputStream) {
        XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder(inputStream);
        // 通过 Configuration 去构建默认SqlSession工厂
        return new DefaultSqlSessionFactory(xmlConfigBuilder.parse());
    }
}
复制代码

在上面的代码中就出现了我们上面流程图的东西了，这个方法会传入一个 InputStream 输入流，然后我们通过这个输入流去创建一个 XmlConfigBuidler (这是一个 Configuration 的构建者)，然后我们通过 XmlConfigBuilder 中的 parse() 方法构建一个 Configuration 对象，最终配置对象传入 SqlSessionFactory ，Sql会话工厂就创建成功了。

此时我们肯定有一些疑问

InputStream 怎么来的？
XmlConfigBuilder 如何构建 Configuration 的？

首先我来解答一下第一个问题，这其实非常简单。因为我们构建这个 配置对象 是基于配置文件的，所以输入流肯定是从 配置文件中转换过来的 。

public class Resource {
    // 通过文件路径获取输入流
    public static InputStream getResourceAsStream(String resource) {
        if (resource == null || "".equals(resource)) {
            return null;
        }
        return Resource.class.getClassLoader().getResourceAsStream(resource);
    }
}
复制代码

XmlConfigBuilder、XMLMapperBuilder

第一个问题解决了，那第二个呢？我们先来写一个简单的 XmlConfigBuilder (后面会补充)

public class XmlConfigBuilder {
    // 输入流
    private InputStream inputStream;
    // 构建的 configuration
    private Configuration configuration;

    public XmlConfigBuilder(InputStream inputStream) {
        this.inputStream = inputStream;
        this.configuration = new Configuration();
    }
    // 解析然后返回 Configuration
    public Configuration parse() {
        // 通过 Dom4j 解析xml
        Document document = DocumentReader.getDocument(this.inputStream);
        // 这里就是解析根标签
        parseConfiguration(document.getRootElement());
        return configuration;
    }
    // 从根标签开始解析
    private void parseConfiguration(Element rootElement) {
        // 解析 environments 子标签
        parseEnvironmentsElement(rootElement.element("environments"));
        // 解析 mappers 子标签
        parseMappersElement(rootElement.element("mappers"));
    }

    @SuppressWarnings("unchecked")
    private void parseMappersElement(Element mappers) {
        // 这里就是解析 mappers子标签的 具体流程了
        // 主要是遍历 mappers 的 mapper 子标签 
        // 然后再通过 XMLMapperBuilder 去解析对应的 mapper 映射文件
    }

    @SuppressWarnings("unchecked")
    private void parseEnvironmentsElement(Element element) {
        System.out.println(element == null);
        // 获取默认环境
        String defaultEnvironment = element.attributeValue("default");
        // 获取environment标签
        List<Element> environmentList = element.elements();
        for (Element environment : environmentList) {
            String environmentId = environment.attributeValue("id");
            if (defaultEnvironment.equals(environmentId)) {
                // 创建数据源
                createDataSource(environment);
            }
        }
    }

    @SuppressWarnings("unchecked")
    private void createDataSource(Element element) {
        Element dataSource = element.element("dataSource");
        // 获取数据源类型
        String dataSourceType = dataSource.attributeValue("type");
        List<Element> propertyElements = dataSource.elements();
        Properties properties = new Properties();
        for (Element property : propertyElements) {
            String name = property.attributeValue("name");
            String value = property.attributeValue("value");
            properties.setProperty(name, value);
        }
        DruidDataSource datasource = null;
        if ("Druid".equals(dataSourceType)) {
            datasource = new DruidDataSource();
            // 获取驱动
            datasource.setDriverClassName(properties.getProperty("driver"));
            // 数据库连接的 url
            datasource.setUrl(properties.getProperty("url"));
            // 数据库用户名
            datasource.setUsername(properties.getProperty("username"));
            // 数据库密码
            datasource.setPassword(properties.getProperty("password"));
        }
        // 设置配置对象中的数据源字段
        configuration.setDataSource(datasource);
    }
}
复制代码

这里对于 mappers 标签的解析只做了简单的中文注释，等会会再次介绍。

其实 XmlConfigBuilder 做的事很简单， 根据配置文件创建配置对象 ，这里我只做了对于 <environments> 和 <mappers> 标签的解析，因为 <environments> 标签涉及到对于数据源的配置，而 <mappers> 则是对于映射文件的配置，二者都是最重要的，如果仅仅需要实现一个最简单的 Mybatis，这两个也是必须的。

我们可以结合着简单配置文件的内容理解上面的代码。

<configuration>
	<!-- mybatis 数据源环境配置 -->
	<environments default="dev">
		<environment id="dev">
			<!-- 配置数据源信息 -->
			<dataSource type="Druid">
				<property name="driver" value="com.mysql.jdbc.Driver"></property>
				<property name="url"
					value="jdbc:mysql://localhost:3306/custom_mybatis"></property>
				<property name="username" value="root"></property>
				<property name="password" value="xxxxxx"></property>
			</dataSource>
		</environment>
	</environments>

	<!-- 映射文件加载 -->
	<mappers>
		<!-- resource指定映射文件的类路径 -->
		<mapper resource="mapper/UserMapper.xml"></mapper>
	</mappers>
</configuration>
复制代码

在上面我使用到了 dom4j 和 Druid 数据源以及 mysql 连接驱动，你也需要在 pom.xml 文件中配置相应的 jar 包。

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.20</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.6</version>
</dependency>
<!-- 这里我使用了 lombok 简化代码 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
    <scope>provided</scope>
</dependency>
复制代码

理解了上面的代码，我们就可以来补充在我们自定义的 XmlConfigBuilder 类中对于 <mappers> 标签的解析。其实就是我们上面流程图的右边部分。

// 上面解析的代码
private void parseMappersElement(Element mappers) {
    // 遍历 mappers 子标签
    List<Element> mapperElements = mappers.elements();
    for (Element element : mapperElements) {
        // 获取文件路径
        String resource = element.attributeValue("resource");
        // 通过路径获取流
        InputStream inputStream = Resource.getResourceAsStream(resource);
        // 创建一个 XMLMapperBuilder 去构建 关于 mapper文件的 配置对象
        XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(inputStream, configuration);
        xmlMapperBuilder.parse();
    }
}
复制代码

其实你会发现，这里的 XMLMapperBuilder 和上面 XmlConfigBuilder 的流程基本一模一样。

这个时候我们来看一下关于 XmlMapperBuilder 到底长什么样。

@Data
@AllArgsConstructor
public class XmlMapperBuilder {
    // 和 XmlConfigBuilder 差不多呀。。
    private InputStream inputStream;
    private Configuration configuration;
    // 解析
    public void parse() {
        Document document = DocumentReader.getDocument(this.inputStream);
        parseMapperElement(document.getRootElement());
    }
    @SuppressWarnings("unchecked")
    private void parseMapperElement(Element rootElement) {
        // 首先查看 namespace 
        // 在 mybatis 中在注册 MappedStatement 会先给它的id 加上 namespace 命名空间
        // 这里上面都没做 只是做个判断 如果没有则抛出异常
        String namespace = rootElement.attributeValue("namespace");
        try {
            if (namespace == null || "".equals(namespace)) {
                throw new Exception("namespace is null");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 直接解析 select 标签
        // 在 mybatis 中对应的是这个
        // buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        // 这里只解析了 select 标签 而且没有用到 xpath 语法
        parseStatementElements(rootElement.elements("select"));
    }
    // 解析所有的 select 标签
    private void parseStatementElements(List<Element> select) {
        for (Element element: select) {
            parseStatementElement(element);
        }
    }
    // 这里就是解析 select 标签的具体流程
    private void parseStatementElement(Element element) {
        /**
        * <select id="findUserById" parameterType="java.lang.Integer" resultType="test.domain.User">
	* SELECT * FROM user WHERE id = #{id} 
	* </select>
	*/
        // 获取 select 的id 这里会作为key 存储到 MappedStatement 的集合中
        String id = element.attributeValue("id");
        // 获取参数类型并解析
        String parameterType = element.attributeValue("parameterType");
        Class<?> parameterTypeClass = resolveClass(parameterType);
        // 获取结果类型并解析
        String resultType = element.attributeValue("resultType");
        Class<?> resultTypeClass = resolveClass(resultType);
        // 获取 Statement 类型
        // 这里其实对应着 JDBC 中的 Statement 类型
        // 我默认使用了 PreparedStatement 预编译类型
        String statementTypeString = element.attributeValue("statementType") == null ? "prepared"
                : element.attributeValue("statementType");

        StatementType statementType = "prepared".equals(statementTypeString) ? StatementType.PREPARED : StatementType.STATEMENT;
        // 创建 sqlSource 这里存储了 sql文本 已经整个 crud 标签的信息
        SqlSource sqlSource = createSqlSource(element);
        // 生成 MappedStatement 对象 很重要
        MappedStatement mappedStatement = new MappedStatement(configuration, id, statementType, sqlSource,
                parameterTypeClass, resultTypeClass);
        // 加入配置 其实就是加入里面的 map 中
        configuration.addMapStatement(mappedStatement);
    }

    private SqlSource createSqlSource(Element element) {
        String text = element.getTextTrim();
        return new SqlSource(text);
    }
    // 转换为 class
    private Class<?> resolveClass(String parameterType) {
        try {
            return Class.forName(parameterType);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
复制代码

MappedStatement

在上面我们已经将 XmlConfigBuilder 和 XmlMapperBuilder 打通了，也就是 XmlMapperBuilder 是 XmlConfigBuilder 中的很重要的一个子构建过程 。所以 XmlMapperBuilder 其实也是 Configuartion 对象的构建者，而在其中它主要构建了 MappedStatement 对象。这样 Configuration 和 XmlMapperBuilder 就也打通了。

所以接下来的重头戏就是 MappedStatement 了。

@Data
@AllArgsConstructor
public class MappedStatement {
    private Configuration configuration;
    private String id;
    private StatementType statementType;
    private SqlSource sqlSource;
    private Class<?> parameterTypeClass;
    private Class<?> resultTypeClass;
}
复制代码

public enum StatementType {
    // 几种处理器类型 对应着 Statement 的类型
    STATEMENT,
    PREPARED,
    CALLABLE
}
复制代码

其实很简单。。就是将上面解析玩的东西加入到 MappedStatement 对象中。

所以整个 构建流程 就基本完成了，请你再回顾一下上面的流程图。

提炼执行部分核心类

在提炼几个重要的核心类之前，我首先将我们后面所需要写的测试代码贴上来，以便你可以串联两个知识点。

public void execute() throws Exception {
    // 指定全局配置文件的类路径
    String resource = "mybatis-config.xml";
    // 获取输入流
    InputStream inputStream = Resource.getResourceAsStream(resource);
    // 创建 Sql 会话工厂
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    // 通过工厂创建 Sql 会话
    SqlSession sqlSession = sqlSessionFactory.openSqlSession();
    // 通过 Sql 会话执行指定 id 语句并返回相应对象
    User user = sqlSession.selectOne("findUserById", 1);
    // 打印结果
    System.out.println(user);
}
复制代码

SqlSession

相比上面我们所写的，对于 SqlSession 的部分我们就可以补充了。

public interface SqlSession {
    // 选取一个 最终还是调用的 选取列表操作
    <T> T selectOne(String statementId, Object args);
    // 选取列表
    <T> List<T> select(String statementId, Object args);
}
复制代码

为了最大地简化框架，这里我只 简单定义了两个选取方法满足业务需求 。因为这里需要 SqlSession 和 SqlSessionFactory 的实现类，所以我直接贴出代码，你可以结合者上面 工厂模式 的 UML 图来理解。

@Data
@AllArgsConstructor
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration configuration;
    public SqlSession openSqlSession() {
        return new DefaultSqlSession(configuration);
    }
}
@AllArgsConstructor
public class DefaultSqlSession implements SqlSession{
    private Configuration configuration;
    // 最终还是调用的 select
    public <T> T selectOne(String statementId, Object args) {
        List<T> list = this.select(statementId, args);
        if (list != null && list.size() > 0) {
            return list.get(0);
        } else {
            return null;
        }
    }
    public <T> List<T> select(String statementId, Object args) {
        // 首先在 configuration 对象中获取对应的 MappedStatement
        MappedStatement mappedStatement = this.configuration.getMappedStatement(statementId);
        if (mappedStatement == null) {
            return null;
        }
        // 构造一个执行器
        Executor executor = new SimpleExecutor();
        // 执行获取到的 mappedStatement
        return executor.execute(mappedStatement, configuration, args);
    }
}
复制代码

其实这里就是我在第二篇文章中画的图，只不过这里没有使用到 装饰者模式 来做缓存处理。

Executor

public interface Executor {
    // 这里就定义了一个执行方法
    <T> List<T> query(MappedStatement mappedStatement, Configuration configuration, Object args);
}

public class SimpleExecutor implements Executor  {
    // 查询
    public <T> List<T> query(MappedStatement mappedStatement, Configuration configuration, Object args) {
        List<T> list = new ArrayList<T>();
        // 获取 SqlSource
        SqlSource sqlSource = mappedStatement.getSqlSource();
        // 获取boundSql 这里面很重要
        // 做了对 配置文件中 sql文本的解析
        // 并将参数加入到了 BoundSql 中的 parameterMappingList 中
        BoundSql boundSql = sqlSource.getBoundSql(mappedStatement, configuration, args);
        // 获取 statement 类型
        StatementType statementType = mappedStatement.getStatementType();
        StatementHandler statementHandler = null;
        // 这里面只有默认的 preparedStatement
        if (statementType == StatementType.PREPARED) {
            statementHandler = new PreparedStatementHandler(configuration, args);
            PreparedStatement preparedStatement =
                    (PreparedStatement) statementHandler.getStatement(boundSql.getSql());
            // 这里面很重要 根据上面解析出来的 boundSql 中的 参数列表
            // 然后调用 jdbc 设置参数
            statementHandler.setParameter(preparedStatement, boundSql);
            // 这里调用 jdbc 的执行方法
            ResultSet resultSet = statementHandler.doExecute(preparedStatement);
            // 这里很重要 主要是做类型转换 将resultSet转换为数组
            list = handleResult(resultSet, mappedStatement);
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    private <T> List<T> handleResult(ResultSet resultSet, MappedStatement mappedStatement) {
       // 这里做类型转换。。。
    }
}
复制代码

在这里逻辑就变得非常复杂了，我先不贴如何做 结果类型转换 的代码，我们先来研究一下 Mybatis 如何将 MappedStatement 中的对象提取出来并且使用 JDBC 来与数据库交互的。

写过 JDBC 代码的同学大概都知道 JDBC 的代码长这样

Class.forName("com.mysql.jdbc.Driver");
connection = DriverManager.getConnection( "jdbc:mysql://localhost:3306/xxxx","xxxx", "xxx");
// 定义 Sql 执行语句
String sql = "select * from xxxtable where xxx = ?";
// 预处理
preparedStatement = connection.prepareStatement(sql);
// 设置第一个参数
preparedStatement.setString(1, "xxx");
// 获取结果集
rs = preparedStatement.executeQuery();
while (resultSet.next()) {
  // 取出结果
}
复制代码

而我们在 Mybatis 中配置的是这样的。

<select id="findUserById" parameterType="java.lang.Integer"
	resultType="test.domain.User">
	SELECT * FROM user WHERE id = #{id} 
</select>
复制代码

在上一篇文章中，我们得出一个结论就是 Mybatis 的执行过程其实主要就是对 JDBC 代码的封装 ，底层是调用的 JDBC 的。所以上面的 Executor 类中的查询方法做的就是这些，我罗列出有主要的三点。

将我们在配置文件中配置的 sql 动态语句转换为 JDBC 能看懂的语句。
- 比如 SELECT * FROM user WHERE id = #{id} 到 select * from user where id = ? 的转换。
转换的同时将我们在配置文件中配置的 parameterType 封装到一个有序集合中，然后通过处理器去调用 JDBC 的 setString , setInt 这类的代码。
通过我们在配置文件中配置的结果类型，调用 JDBC 代码获取 ResultSet 之后通过相应的处理器来将结果集做类型转换。

首先我们来实现一下第一个和第二个执行流程。答案在上面的 getBoundSql() 方法中。

@AllArgsConstructor
@Data
public class SqlSource {
    // 在配置文件中原本的 sql 文本
    private String text;
    // 很重要 执行了上面我所说的两个步骤
    public BoundSql getBoundSql(MappedStatement mappedStatement,
                                Object parameterObject) {
        // 通过我们配置的 参数类型 来构建一个 参数映射处理器
        // 里面存储了一个 参数类型 和 一个 ParameterMapping(参数映射)集合
        // 其中参数类型最终都会转入 参数映射 的集合中
        ParameterMappingHandler handler = new ParameterMappingHandler(mappedStatement.getParameterTypeClass());
        // 创建一个GenericTokenParse去解析原本的 sql 文本
        GenericTokenParse genericTokenParse = new GenericTokenParse("#{", "}", handler);
        // 解析的同时会将参数映射列表填充完整
        String sql = genericTokenParse.parse(text);
        // 构建完成
        return new BoundSql(sql, handler.getParameterMappings(), parameterObject);
    }
}

@Data
public class ParameterMappingHandler implements TokenHandler {
    // 持有了 参数映射集合
    private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
    // 持有了参数类型
    private Class<?> parameterTypeClass;
    // 构造
    public ParameterMappingHandler(Class<?> parameterTypeClass) {
        this.parameterTypeClass = parameterTypeClass;
    }
    // 在 GenericTokenParse 中会调用，会将指定文本转换为 ？
    // 比如将 #{id} 转换为 ?
    public String handleToken(String content) {
        // 这里还构建了 parameterMapping 集合
        parameterMappings.add(buildParameterMapping(content));
        return "?";
    }
    // parameterTypeClass 最终还是会变成 参数映射集合
    private ParameterMapping buildParameterMapping(String content) {
        return new ParameterMapping(content, parameterTypeClass);
    }
}
复制代码

@AllArgsConstructor
public class GenericTokenParse {
    private String openToken;
    private String closeToken;
    // 这里持有了 TokenHandler
    private TokenHandler handler;
    // 这里就是解析流程 具体逻辑不用管
    // 你只要知道是将 与 openToken 和 closeToken 匹配的字符串转变为
    // 传入参数 text 的
    public String parse(String text) {
        if (text == null || text.length() == 0) {
            return "";
        }
        // search open token
        int start = text.indexOf(openToken, 0);
        if (start == -1) {
            return text;
        }
        char[] src = text.toCharArray();
        int offset = 0;
        final StringBuilder builder = new StringBuilder();
        StringBuilder expression = null;
        while (start > -1) {
            if (start > 0 && src[start - 1] == '//') {
                // this open token is escaped. remove the backslash and continue.
                builder.append(src, offset, start - offset - 1).append(openToken);
                offset = start + openToken.length();
            } else {
                // found open token. let's search close token.
                if (expression == null) {
                    expression = new StringBuilder();
                } else {
                    expression.setLength(0);
                }
                builder.append(src, offset, start - offset);
                offset = start + openToken.length();
                int end = text.indexOf(closeToken, offset);
                while (end > -1) {
                    if (end > offset && src[end - 1] == '//') {
                        // this close token is escaped. remove the backslash and continue.
                        expression.append(src, offset, end - offset - 1).append(closeToken);
                        offset = end + closeToken.length();
                        end = text.indexOf(closeToken, offset);
                    } else {
                        expression.append(src, offset, end - offset);
                        offset = end + closeToken.length();
                        break;
                    }
                }
                if (end == -1) {
                    // close token was not found.
                    builder.append(src, start, src.length - start);
                    offset = src.length;
                } else {
                  // 这里调用了 handleToken 方法 这里面做了转换
                  // 回过去看 ParameterMappingHandler 中的方法
                  builder.append(handler.handleToken(expression.toString()));
                    offset = end + closeToken.length();
                }
            }
            start = text.indexOf(openToken, offset);
        }
        if (offset < src.length) {
            builder.append(src, offset, src.length - offset);
        }
        return builder.toString();
    }
}

复制代码

整个流程如下图

StatementHandler

其实你也发现了，第二步到这里并没有完成，这里仅仅是完成了前面一半(将配置的 parameterType 封装到集合中)，到现在为止还是没有调用 JDBC 的设置参数代码。

我们再回去看一下 SimpleExecutor 中的查询方法，在获取到 BoundSql 之后有一个构建 StatementHandler 的过程。

这个 StatementHandler 又是何方神圣呢？这是一个非常非常重要的类，可以这么说，它主管了 Mybatis 调用 JDBC 的大部分流程。比如说获取 Statement 和参数化等等。

这里我们给它定义以下三个方法

public interface StatementHandler {
    // 获取 JDBC 中的 statement
    Statement getStatement(String sql);
    // 调用 JDBC 执行
    ResultSet doExecute(Statement statement);
    // 设置参数
    void setParameter(Statement statement, BoundSql boundSql);
}
复制代码

并且我们实现了一个我们业务中需要的 PreparedStatementHandler ，它主要用于 Mybatis 调用 JDBC 的 PreparedStatement 预处理。

@AllArgsConstructor
// 很多JDBC 封装都在这里进行了
public class PreparedStatementHandler implements StatementHandler {

    private Configuration configuration;
    private Object parameterObject;
    // 这里调用了 JDBC的执行并获取 结果集
    public ResultSet doExecute(Statement statement) {
        ResultSet resultSet = null;
        try {
            resultSet = ((PreparedStatement)statement).executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return resultSet;
    }
    // 调用 JDBC 获取 Statement
    public Statement getStatement(String sql) {
        PreparedStatement preparedStatement = null;
        DataSource dataSource = configuration.getDataSource();
        try {
            Connection connection = dataSource.getConnection();
            preparedStatement = connection.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return preparedStatement;
    }
    // 设置参数
    public void setParameter(Statement statement, BoundSql boundSql) {
        PreparedStatement preparedStatement = (PreparedStatement) statement;
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        // 首先获取 bounSql中的 参数映射集合然后遍历
        for (int i = 0; i < parameterMappings.size(); i++) {
            Class<?> parameterTypeClass = parameterMappings.get(i).getParameterTypeClass();
            // 获取参数集合中的参数类型 并通过参数类型去获取
            // 对应的类型处理器 调用相应的参数设置方法
            TypeHandler typeHandler = getTypeHandler(parameterTypeClass);
            if (typeHandler != null) {
                typeHandler.setParameter(i + 1, preparedStatement, parameterObject);
            }
        }
    }
    // 这里仅仅简单写了个 Integer 参数类型处理器
    private TypeHandler getTypeHandler(Class<?> parameterTypeClass) {
        if (parameterTypeClass.isAssignableFrom(Integer.class)) {
            return new IntegerTypeHandler();
        } else {
            System.out.println("暂不支持该类型");
            return null;
        }
    }
}
复制代码

TypeHandler

这里是 TypeHandler 和 IntegerTypeHandler 的实现

public interface TypeHandler {
    // 设置参数
    void setParameter(int index, PreparedStatement preparedStatement, Object parameterObject);
}

public class IntegerTypeHandler implements TypeHandler {
    public void setParameter(int index, PreparedStatement preparedStatement, Object parameterObject) {
        try {
            // 调用setInt
            preparedStatement.setInt(index, (Integer) parameterObject);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
复制代码

写到这里我们就已经将构建部分的核心代码写完一大半了，接下来就是 Myabtis 对 JDBC 结果集转换的封装了。我们回过去看 SimpleExecutor 可以发现我们需要实现我们再查询方法中写的

list = handleResult(resultSet, mappedStatement);
复制代码

这里我讲处理结果的代码补充完整。

public class SimpleExecutor implements Executor  {

    // 查询
    public <T> List<T> query(MappedStatement mappedStatement, Configuration configuration, Object args) {
        List<T> list = new ArrayList<T>();
        // 获取 SqlSource
        SqlSource sqlSource = mappedStatement.getSqlSource();
        // 获取boundSql 这里面很重要
        // 做了对 配置文件中 sql文本的解析
        // 并将参数加入到了 BoundSql 中的 parameterMappingList 中
        BoundSql boundSql = sqlSource.getBoundSql(mappedStatement, configuration, args);
        // 获取 statement 类型
        StatementType statementType = mappedStatement.getStatementType();
        StatementHandler statementHandler = null;
        // 这里面只有默认的 preparedStatement
        if (statementType == StatementType.PREPARED) {
            statementHandler = new PreparedStatementHandler(configuration, args);
            PreparedStatement preparedStatement =
                    (PreparedStatement) statementHandler.getStatement(boundSql.getSql());
            // 这里面很重要 根据上面解析出来的 boundSql 中的 参数列表
            // 然后调用 jdbc 设置参数
            statementHandler.setParameter(preparedStatement, boundSql);
            // 这里调用 jdbc 的执行方法
            ResultSet resultSet = statementHandler.doExecute(preparedStatement);
            // 这里很重要 主要是做类型转换 将resultSet转换为数组
            list = handleResult(resultSet, mappedStatement);
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    private <T> List<T> handleResult(ResultSet resultSet, MappedStatement mappedStatement) {
        List<T> results = new ArrayList<T>();
        // 我们获取到 MappedStatement 中的 ResultType
        Class<?> resultTypeClass = mappedStatement.getResultTypeClass();
        try {
            while (resultSet.next()) {
                // 遍历结果集 并通过反射去创建对象。
                Object resultObject = resultTypeClass.newInstance();
                ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
                int columnCount = resultSetMetaData.getColumnCount();
                for (int i = 1; i <= columnCount; i++) {
                    Field field = resultTypeClass.getDeclaredField(resultSetMetaData.getColumnLabel(i));
                    field.setAccessible(true);
                    field.set(resultObject, resultSet.getObject(i));
                }
                results.add((T)resultObject);
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        return results;
    }
}
复制代码

到这里我们所有的逻辑就写完了，当然在 Mybatis 中的处理比这个要复杂的多得多，如果对源码感兴趣的同学可以自己 github 上下载源码调试。

测试运行结果

我们来测试一下我的测试代码

public void execute() throws Exception {
    // 指定全局配置文件的类路径
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resource.getResourceAsStream(resource);

    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    SqlSession sqlSession = sqlSessionFactory.openSqlSession();

    User user = sqlSession.selectOne("findUserById", 1);

    System.out.println(user);
}
复制代码

执行结果