《手写Mybatis渐进式源码实践》实践笔记(第七章 SQL执行器的创建和利用) ...

---

  

---

第七章 SQL执行器的界说和实现

背景

技能背景

模板模式

模板模式（Template Method Pattern）是活动型计划模式之一，它在父类中界说了一个算法的框架，允许子类在不改变算法布局的情况下重写算法的某些特定步骤。这种模式紧张用来办理代码复用的问题，它通过把一些相同步骤提取到父类中，而将不同的步骤耽误到子类中实现，从而避免代码重复。
特点

• 算法框架：在父类中界说算法的骨架，这些算法通常包罗一系列的步骤。
  
• 扩展性：子类可以重新界说算法的某些步骤，而不影响算法的布局。
  
• 代码复用：通过提取公共代码到父类，减少代码重复。
  
• 控制反转：父类控制算法的流程，子类提供具体的实现。
  

布局

模板模式通常包罗以下脚色：

• 抽象类（Abstract Class）：界说模板方法和算法框架，其中模板方法是一个调用一系列抽象操作的方法。
  
• 具体类（Concrete Class）：实现抽象类中的抽象方法，这些方法可以是具体的方法，也可以是其他抽象方法。
  
• 钩子方法（Hook Method）：在抽象类中界说，可以被子类重写，但不带有抽象方法的声明。
  

示例代码（Java）

1. // 抽象类
2. abstract class Game {
3.     // 模板方法
4.     final void play() {
5.         initialize();
6.         startPlay();
7.         endPlay();
8.     }
10.     // 抽象方法，由子类实现
11.     abstract void initialize();
12.     abstract void startPlay();
13.     abstract void endPlay();
14. }
16. // 具体类
17. class Cricket extends Game {
18.     @Override
19.     void initialize() {
20.         System.out.println("Cricket game initialized.");
21.     }
23.     @Override
24.     void startPlay() {
25.         System.out.println("Cricket game started.");
26.     }
28.     @Override
29.     void endPlay() {
30.         System.out.println("Cricket game finished.");
31.     }
32. }
34. // 具体类
35. class Football extends Game {
36.     @Override
37.     void initialize() {
38.         System.out.println("Football game initialized.");
39.     }
41.     @Override
42.     void startPlay() {
43.         System.out.println("Football game started.");
44.     }
46.     @Override
47.     void endPlay() {
48.         System.out.println("Football game finished.");
49.     }
50. }
52. // 客户端代码
53. public class TemplatePatternDemo {
54.     public static void main(String[] args) {
55.         Game game = new Cricket();
56.         game.play();
58.         game = new Football();
59.         game.play();
60.     }
61. }

复制代码

在这个例子中，Game 类界说了游戏的算法框架，而 Cricket 和 Football 类分别实现了具体的游戏初始化、开始和竣事的方法。如许，不同的游戏可以共享相同的游戏流程，同时保持各自的特性。
业务背景

在第6章节我们实现了毗连池/非毗连池的数据源，可以在调用执行SQL的时间，通过我们实现的池化技能完成数据库的操作。
那么关于池化数据源的调用、执行和效果封装，现在只是在 DefaultSqlSession 中进行发起 ，代码层面写死了流程，这种方式不适用于后续扩展利用，因为SqlSession 中新增界说的方法都要处理对池化数据源的调用逻辑。

1. @Override
2.     public <T> T selectOne(String statement, Object parameter) {
3.         try {
4.             // 映射语句
5.             MappedStatement mappedStatement = configuration.getMappedStatement(statement);
6.             // 环境
7.             Environment environment = configuration.getEnvironment();
9.             // 连接
10.             Connection connection = environment.getDataSource().getConnection();
12.             BoundSql boundSql = mappedStatement.getBoundSql();
13.             PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSql());
14.             preparedStatement.setLong(1, Long.parseLong(((Object[]) parameter)[0].toString()));
15.             // 执行查询
16.             ResultSet resultSet = preparedStatement.executeQuery();
18.             // 结果封装
19.             List<T> objectList = resultSet2Obj(resultSet, Class.forName(boundSql.getResultType()));
20.             return objectList.get(0);
22.         } catch (Exception e) {
23.             e.printStackTrace();
24.             return null;
25.         }
26.     }

复制代码

• 解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和效果封装，提供新的功能模块替换这部门硬编码的逻辑处理。
  
• 只有提供了单独的执行方法入口，我们才能更好的扩展和应对这部门内容里的需求变化，包罗了各类入参、效果封装、执行器范例、批处理等，来满足不同样式的用户需求，也就是配置到 Mapper.xml 中的具体信息。
  

目标

基于当前框架实现，解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和效果封装，提供SQL执行器功能模块替换这部门硬编码的逻辑处理。
计划

ORM 框架渐进式的开辟过程上，渐渐实现的执举措作：解析配置、代理对象、映射方法等，直至我们前面章节对数据源的包装和利用，只不过我们把数据源的操作硬编码到了 DefaultSqlSession 的执行方法上了。
为了解耦这块的功能处理，必要引入SQL执行器的服务功能，将SQL执行器随着 DefaultSqlSession 创建时传入，之后具体的方法调用就可以通过执行器来处理。
团体计划如图 ：

• 提取执行器的接口，界说执行方法、事件获取和相应提交、回滚、关闭的方法界说；
  
• 执行器是一种标准的执行过程，由抽象类进行实现，可以对过程内容进行模板模式的过程包装。在包装过程中界说抽象类，由具体的子类来实现。这一部门在下文的代码中会体现到 SimpleExecutor 简单执行器实现中;
  
• 对 SQL 的处理，利用 JDBC 执行 SQL 的时间，分为了简单处理和预处理，预处理中包罗准备语句、参数化通报、执行查询，以及最后的效果封装和返回。以是我们这里也必要把 JDBC 这部门的步骤，分为布局化的类过程来实现，便于功能的拓展。具体代码紧张体如今语句处理器 StatementHandler 的接口实现中。
  

实现

工程代码

类图

• Executor 接口界说为执行器入口，确定事件操作和 SQL 执行的同一标准。用BaseExecutor抽象类处理同一共用的事件和执行SQL的标准流程，并界说执行 SQL 的抽象接口#doQuery()，后续由子类实现。
  
• SimpleExecutor 简单SQL 执行器实现类中，处理 doQuery 方法的具体操作过程。这个过程中则会引入 SQL 语句处理器的创建，创建过程仍由 configuration 配置项提供。你会发现许多如许的生成处理，都来自于配置项
  
• 执行器开辟完成后，由DefaultSqlSessionFactory 开启 openSession 的时间，随着构造函数参数通报给 DefaultSqlSession 中，如许在执行 DefaultSqlSession#selectOne 的时间就可以调用执行器进行处理了。也就由此完成解耦操作了。
  

实现步骤

1.执行器的界说和实现

执行器分为接口、抽象类、简单执行器实现类三部门，通常在框架的源码中对于一些标准流程的处理，都会有抽象类的存在。它负责提供共性功能逻辑，以及对接口方法的执行过程进行界说和处理，并提供抽象接口交由子类实现。这种计划模式也被界说为模板模式。
1-1. Executor界说执行器接口

• 在执行器中界说的接口包罗事件相关的处理方法和执行SQL查询的操作，随着后续功能的迭代还会继承补充其他的方法。
  

1. public interface Executor {
2.    
3.     ResultHandler NO_RESULT_HANDLER = null;
5.     <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);
7.     Transaction getTransaction();
9.     void commit(boolean required) throws Exception;
11.     void rollback(boolean required) throws Exception;
13.     void close(boolean forceRollback);
14.    
16. }

复制代码

1-2.BaseExecutor执行器抽象基类

• 封装了执行器的全部接口，如许具体的子类继承抽象类后，就可以直接利用这些共性的方法。在 query 查询方法中，封装一些必要的流程处理，如果检测关闭等，在 Mybatis 源码中另有一些缓存的操作，这里暂时剔撤除，以核心流程为主。读者伙伴在学习的过程中可以与源码进行对照学习。
  

1. public abstract class BaseExecutor implements Executor {
3.     Logger logger = LoggerFactory.getLogger(BaseExecutor.class);
5.     protected Configuration configuration;
7.     protected Transaction transaction;
9.     protected Executor wrapper;
11.     private boolean closed;
13.     protected BaseExecutor(Configuration configuration, Transaction transaction) {
14.         this.configuration = configuration;
15.         this.transaction = transaction;
16.         this.wrapper = this;
17.     }
19.     // 连接关闭处理统一逻辑
20.     @Override
21.     public <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
22.         if (closed) {
23.             throw new RuntimeException("Executor was closed.");
24.         }
25.         return doQuery(ms, parameter, resultHandler, boundSql);
26.     }
28.     protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);
30.     @Override
31.     public Transaction getTransaction() {
32.         if (closed) {
33.             throw new RuntimeException("Executor was closed.");
34.         }
35.         return transaction;
36.     }
38.     @Override
39.     public void commit(boolean required) throws Exception {
40.         if (closed) {
41.             throw new RuntimeException("Cannot commit, transaction is already closed");
42.         }
43.         if (required) {
44.             transaction.commit();
45.         }
46.     }
48.     @Override
49.     public void rollback(boolean required) throws SQLException {
50.         if (closed) {
51.             throw new RuntimeException("Cannot rollback, transaction is already closed");
52.         }
53.         if (required) {
54.             transaction.rollback();
55.         }
56.     }
58.     @Override
59.     public void close(boolean forceRollback) {
60.         try {
61.             try {
62.                 rollback(forceRollback);
63.             } finally {
64.                 transaction.close();
65.             }
66.         } catch (SQLException e) {
67.             logger.warn("Unexpected exception on closing transaction.  Cause: " + e);
68.         } finally {
69.             transaction = null;
70.             closed = true;
71.         }
72.     }
73. }

复制代码

1-3. SimpleExecutor 简单执行器实现

• 简单执行器 SimpleExecutor 继承抽象基类，实现抽象方法 doQuery，在这个方法中包装数据源的获取、语句处理器的创建，以及对 Statement 的实例化和相关参数设置。最后执行 SQL 的处理和效果的返回操作。
  

1. public class SimpleExecutor extends BaseExecutor {
4.     public SimpleExecutor(Configuration configuration, Transaction transaction) {
5.         super(configuration, transaction);
6.     }
8.     @Override
9.     protected <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
10.         //处理查询逻辑.
11.         try {
12.             //获取配置信息
13.             Configuration configuration = ms.getConfiguration();
14.             //获取StatementHandler
15.             StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, resultHandler, boundSql);
16.             //获取连接
17.             Connection connection = transaction.getConnection();
18.             Statement stmt = handler.prepare(connection);
19.             handler.parameterize(stmt);
20.             return handler.query(stmt, resultHandler);
21.         } catch (SQLException e) {
22.             e.printStackTrace();
23.             return null;
24.         }
25.     }
26. }

复制代码

2.语句处理器

语句处理器是 SQL 执行器中依靠的部门，SQL 执行器封装事件、毗连和检测情况等，而语句处理器则是准备语句、参数化通报、执行SQL、封装效果的处理。
2-1.StatementHandler界说语句处理接口

• 语句处理器的核心: 准备语句、参数化通报参数、执行查询的操作，这里对应的 Mybatis 源码中还包罗了 update、批处理、获取参数处理器等。
  

1. public interface StatementHandler {
3.     /**
4.      * 准备语句
5.      */
6.     Statement prepare(Connection connection) throws SQLException;
8.     /**
9.      * 参数化
10.      */
11.     void parameterize(Statement statement) throws SQLException;
13.     /**
14.      * 执行查询
15.      */
16.     <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException;
17. }

复制代码

2-2. BaseStatementHandler 语句处理器抽象基类

• 语句处理器基类中，封装参数信息、效果信息。不过这里我们暂时还不会做过多的参数处理，比如jdbc的字段范例转换等。这部门内容随着我们整个执行器的布局创建完毕后，再进行迭代开辟。
  
• 对 BaseStatementHandler#prepare 方法的处理，包罗界说实例化抽象方法，这个方法交由各个具体的实现子类进行处理。
  

1. public abstract class BaseStatementHandler implements StatementHandler {
4.     protected final Configuration configuration;
6.     protected final Executor executor;
8.     protected final MappedStatement mapperStatement;
10.     protected final Object parameter;
12.     protected final ResultSetHandler resultSetHandler;
14.     protected BoundSql boundSql;
16.     protected BaseStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
17.                                    ResultHandler resultHandler,
18.                                    BoundSql boundSql) {
19.         this.executor = executor;
20.         this.configuration = mapperStatement.getConfiguration();
21.         this.mapperStatement = mapperStatement;
22.         this.parameter = parameter;
23.         this.boundSql = boundSql;
24.         this.resultSetHandler = configuration.newResultSetHandler(executor, mapperStatement, boundSql);
25.     }
28.     @Override
29.     public Statement prepare(Connection connection) throws SQLException {
30.         Statement statement = null;
31.         try {
32.             statement = instantiateStatement(connection);
33.             statement.setQueryTimeout(350);
34.             statement.setFetchSize(10000);
35.             return statement;
36.         } catch (Exception e) {
37.             throw new RuntimeException("Error preparing statement.  Cause: " + e, e);
38.         }
39.     }
42.     protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
44. }

复制代码

2-3. SimpleStatementHandler 简单语句处理器类

• SimpleStatementHandler 简单语句处理器,只是对 SQL 的最基本执行，没有参数的设置.
  

1. public class SimpleStatementHandler extends BaseStatementHandler {
4.     public SimpleStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
5.                                   ResultHandler resultHandler,
6.                                   BoundSql boundSql) {
7.         super(executor, mapperStatement, parameter, resultHandler, boundSql);
8.     }
10.     @Override
11.     protected Statement instantiateStatement(Connection connection) throws SQLException {
12.         return connection.createStatement();
13.     }
15.     @Override
16.     public void parameterize(Statement statement) throws SQLException {
17.         // N/A
18.     }
20.     @Override
21.     public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
22.         String sql = boundSql.getSql();
23.         statement.execute(sql);
24.         return resultSetHandler.handleResultSets(statement);
25.     }
26. }

复制代码

2-4. PrepareStatementHandler 预处理语句处理器类

• 预处理语句处理器中包罗 instantiateStatement 预处理 SQL、parameterize 设置参数，以及 query 查询的执行的操作。
  
• 这里必要注意，当前 parameterize 设置参数中还是写死的，后续这部门再进行完善。
  
• query 方法则是执行查询和对效果的封装，效果的封装现在也是比较简单的处理，只是把我们前面章节中对象的内容摘取出来进行封装，这部门暂时没有改变。都放在后续进行完善处理。
  

1. public class PreparedStatementHandler extends BaseStatementHandler {
2.     public PreparedStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
3.                                     ResultHandler resultHandler,
4.                                     BoundSql boundSql) {
5.         super(executor, mapperStatement, parameter, resultHandler, boundSql);
6.     }
8.     @Override
9.     protected Statement instantiateStatement(Connection connection) throws SQLException {
10.         String sql = boundSql.getSql();
11.         return connection.prepareStatement(sql);
12.     }
14.     @Override
15.     public void parameterize(Statement statement) throws SQLException {
16.         PreparedStatement ps = (PreparedStatement) statement;
17.         ps.setLong(1, Long.parseLong(((Object[]) parameter)[0].toString()));
18.     }
20.     @Override
21.     public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
22.         PreparedStatement ps = (PreparedStatement) statement;
23.         ps.execute();
24.         return resultSetHandler.<E>handleResultSets(ps);
25.     }
26. }

复制代码

3.执行器创建和利用

执行器开辟完成以后，则必要在串联到 DefaultSqlSession 中进行利用。串联过程：在 创建 DefaultSqlSession 的时间，构建出执行器，并作为参数通报到defaultSqlSession。这块涉及到 DefaultSqlSessionFactory#openSession 的处理。
3-1. 开启执行器

• openSession 中开启事件tx, 用于执行器的创建，具体实现可以看 configuration.newExecutor 代码，这部门没有太多复杂的逻辑。读者可以参考源码进行学习。
  
• 在执行器创建完毕后，以参数方式通报给 DefaultSqlSession，如许就把整个过程串联起来了。
  

1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
3.     private final Configuration configuration;
5.     public DefaultSqlSessionFactory(Configuration configuration) {
6.         this.configuration = configuration;
7.     }
9.     @Override
10.     public SqlSession openSession() {
11.         Transaction tx = null;
12.         try {
13.             final Environment environment = configuration.getEnvironment();
14.             TransactionFactory transactionFactory = environment.getTransactionFactory();
15.             tx = transactionFactory.newTransaction(configuration.getEnvironment().getDataSource(),
16.                     TransactionIsolationLevel.READ_COMMITTED,
17.                     false);
18.             // 创建执行器
19.             final Executor executor = configuration.newExecutor(tx);
20.             // 创建DefaultSqlSession
21.             return new DefaultSqlSession(configuration, executor);
22.         } catch (Exception e) {
23.             try {
24.                 assert tx != null;
25.                 tx.close();
26.             } catch (SQLException ignore) {
27.             }
28.             throw new RuntimeException("Error opening session.  Cause: " + e);
29.         }
30.     }
31. }

复制代码

3-2. 利用执行器

• 完成上面执行器的全部实现后，就可以调用执行器进行功能解耦了。在 DefaultSqlSession#selectOne 中获取 MappedStatement 映射语句类后，则通报给执行器进行处理，那么如今这个类经过计划思想的解耦后，就变得更加干净整洁了，更易于维护和扩展了。
  

1. public class DefaultSqlSession implements SqlSession {
3.     /**
4.      * 配置项.
5.      */
6.     private Configuration configuration;
8.     private Executor executor;
10.     public DefaultSqlSession(Configuration configuration, Executor executor) {
11.         this.configuration = configuration;
12.         this.executor = executor;
13.     }
15.     public Configuration getConfiguration() {
16.         return configuration;
17.     }
20.     /**
21.      * 根据给定的执行SQL获取一条记录的封装对象.
22.      *
23.      * @param statement
24.      * @param <T>
25.      * @return
26.      */
28.     @Override
29.     public <T> T selectOne(String statement) {
30.         return this.selectOne(statement, null);
31.     }
33.     @Override
34.     public <T> T selectOne(String statement, Object parameter) {
35.         //映射语句
36.         MappedStatement mappedStatement = configuration.getMappedStatement(statement);
37.         //使用执行器.
38.         List<T> list = executor.query(mappedStatement, parameter, Executor.NO_RESULT_HANDLER, mappedStatement.getBoundSql());
39.         return list.get(0);
40.     }
41.    
43.     @Override
44.     public <T> T getMapper(Class<T> type) {
45.         return configuration.getMapper(type, this);
46.     }
49. }

复制代码

测试

事先准备

创建库表

1. -- 建表
2. CREATE TABLE `my_user` (
3.   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID',
4.   `user_id` varchar(9) DEFAULT NULL COMMENT '用户ID',
5.   `user_head` varchar(16) DEFAULT NULL COMMENT '用户头像',
6.   `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
7.   `update_time` timestamp NULL DEFAULT NULL COMMENT '更新时间',
8.   `user_name` varchar(64) DEFAULT NULL COMMENT '用户名',
9.   `user_password` varchar(64) DEFAULT NULL COMMENT '用户密码',
10.   PRIMARY KEY (`id`)
11. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ;
14. -- 插入数据
15. INSERT INTO my_user (user_id, user_head, create_time, update_time, user_name, user_password) VALUES('1', '头像', '2024-12-13 18:00:12', '2024-12-13 18:00:12', '小苏', 's123asd');

复制代码

界说一个数据库接口 IUserDao
IUserDao

1. public interface IUserDao {
3.     String queryUserInfoById(String uid);
5. }

复制代码

配置数据源

• 通过 mybatis-config-datasource.xml 配置数据源信息，包罗：driver、url、username、password
  
• 这里DataSource 配置的是 DRUID，因为我们实现的是这个数据源的处理方式。
  

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
5. <configuration>
8.     <environments default="development">
9.         <environment id="development">
10.             <transactionManager type="JDBC"/>
11.             <dataSource type="UNPOOLED">  #无池化时配置成这个类型值
12.             <dataSource type="POOLED">  #池化时配置城这个类型值
13.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
14.                 <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true"/>
15.                 <property name="username" value="root"/>
16.                 <property name="password" value="123456"/>
17.             </dataSource>
18.         </environment>
19.     </environments>
21.     <mappers>
22.         <mapper resource="mapper/User_Mapper.xml"/>
23.     </mappers>
24. </configuration>

复制代码

界说对应的mapper xml文件

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3. <mapper namespace="cn.suwg.mybatis.test.dao.IUserDao">
5.     <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="cn.suwg.mybatis.test.po.User">
6.         SELECT id, user_id, user_head, create_time
7.         FROM user
8.         where id = #{id}
9.     </select>
11. </mapper>

复制代码

测试用例

• 单位测试，通报一个 1L 的 long 范例参数，进行方法的调用处理。通过单位测试验证执行器的处理过程，读者在学习的过程中可以进行断点测试，学习每个过程的处理内容。
  
• mybatis-config-datasource.xml 中 dataSource 数据源范例的调整 dataSource type="DRUID/POOLED/UNPOOLED",按需配置验证.
  

单位测试

1. public class ApiTest {
3.     private Logger logger = LoggerFactory.getLogger(ApiTest.class);
6.     // 测试SqlSessionFactory
7.     @Test
8.     public void testSqlSessionFactory() throws IOException {
10.         // 1.从xml文件读取mybatis配置项, 从SqlSessionFactory获取SqlSession.
11.         Reader reader = Resources.getResourceAsReader("mybatis-config-datasource.xml");
12.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
13.         SqlSession sqlSession = sqlSessionFactory.openSession();
16.         // 2.获取映射器对象
17.         IUserDao userDao = sqlSession.getMapper(IUserDao.class);
19.         // 4.测试验证
20.         User user = userDao.queryUserInfoById(1L);
21.         logger.info("测试结果：{}", JSON.toJSONString(user));
23.     }
26. }

复制代码

测试效果

• 从输出的效果来看，我们已经顺遂完成，将DefaultSqlSession#selectOne中的调用，替换成了执行器来完成整个过程，通过解耦这部门的逻辑操作，后续我们扩展就更方便了，这块的功能测试通过后，后续就可以聚焦在新的功能扩展点开辟了。
  

总结

• 整个章节的实现都是在处明白耦这件事故，从DefaultSqlSession#selectOne 对数据源的处明白耦到执行器中进行操作。而执行器中又包罗了对 JDBC 处理的拆解，链接、准备语句、封装参数、处理效果，全部的这些过程经过解耦后的类和方法，就都可以在以后的功能迭代中非常方便的完成扩展了。
  
• 本章节也为我们后续扩展参数的处理、效果集的封装预留出了扩展点，以及对于不同的语句处理器选择的问题，都必要在后续进行完善和补充。现在我们串联出来的是最核心的骨架布局，随着后续的渐进式开辟连续迭代完善。
  
• 对于源码的学习，读者要经历看、写、思考、应用等几个步骤的过程，才能更好的吸收这里面的思想，每一次的阅读源码，都能有新的认知和领会。不要只是Ctrl+C，Ctrl+V一遍就完事了，否则也就失去了跟着学习源码的意义。
  

   参考书籍：《手写Mybatis渐进式源码实践》
  书籍源代码：https://github.com/fuzhengwei/book-small-mybatis

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。