《手写Mybatis渐进式源码实践》实践笔记(第七章 SQL执行器的创建和利用)
第七章 SQL执行器的界说和实现
https://i-blog.csdnimg.cn/img_convert/d3e3891b66fb3a4f7e4d43b1ff73de9c.jpeg
背景
技能背景
模板模式
模板模式（Template Method Pattern）是活动型计划模式之一，它在父类中界说了一个算法的框架，允许子类在不改变算法布局的情况下重写算法的某些特定步骤。这种模式紧张用来办理代码复用的问题，它通过把一些相同步骤提取到父类中，而将不同的步骤耽误到子类中实现，从而避免代码重复。
特点
[*]算法框架：在父类中界说算法的骨架，这些算法通常包罗一系列的步骤。
[*]扩展性：子类可以重新界说算法的某些步骤，而不影响算法的布局。
[*]代码复用：通过提取公共代码到父类，减少代码重复。
[*]控制反转：父类控制算法的流程，子类提供具体的实现。
布局
模板模式通常包罗以下脚色：
[*]抽象类（Abstract Class）：界说模板方法和算法框架，其中模板方法是一个调用一系列抽象操作的方法。
[*]具体类（Concrete Class）：实现抽象类中的抽象方法，这些方法可以是具体的方法，也可以是其他抽象方法。
[*]钩子方法（Hook Method）：在抽象类中界说，可以被子类重写，但不带有抽象方法的声明。
示例代码（Java）
// 抽象类
abstract class Game {
// 模板方法
final void play() {
initialize();
startPlay();
endPlay();
}
// 抽象方法，由子类实现
abstract void initialize();
abstract void startPlay();
abstract void endPlay();
}
// 具体类
class Cricket extends Game {
@Override
void initialize() {
System.out.println("Cricket game initialized.");
}
@Override
void startPlay() {
System.out.println("Cricket game started.");
}
@Override
void endPlay() {
System.out.println("Cricket game finished.");
}
}
// 具体类
class Football extends Game {
@Override
void initialize() {
System.out.println("Football game initialized.");
}
@Override
void startPlay() {
System.out.println("Football game started.");
}
@Override
void endPlay() {
System.out.println("Football game finished.");
}
}
// 客户端代码
public class TemplatePatternDemo {
public static void main(String[] args) {
Game game = new Cricket();
game.play();
game = new Football();
game.play();
}
}
在这个例子中，Game 类界说了游戏的算法框架，而 Cricket 和 Football 类分别实现了具体的游戏初始化、开始和竣事的方法。如许，不同的游戏可以共享相同的游戏流程，同时保持各自的特性。
业务背景
在第6章节我们实现了毗连池/非毗连池的数据源，可以在调用执行SQL的时间，通过我们实现的池化技能完成数据库的操作。
那么关于池化数据源的调用、执行和效果封装，现在只是在 DefaultSqlSession 中进行发起 ，代码层面写死了流程，这种方式不适用于后续扩展利用，因为SqlSession 中新增界说的方法都要处理对池化数据源的调用逻辑。
@Override
public <T> T selectOne(String statement, Object parameter) {
try {
// 映射语句
MappedStatement mappedStatement = configuration.getMappedStatement(statement);
// 环境
Environment environment = configuration.getEnvironment();
// 连接
Connection connection = environment.getDataSource().getConnection();
BoundSql boundSql = mappedStatement.getBoundSql();
PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSql());
preparedStatement.setLong(1, Long.parseLong(((Object[]) parameter).toString()));
// 执行查询
ResultSet resultSet = preparedStatement.executeQuery();
// 结果封装
List<T> objectList = resultSet2Obj(resultSet, Class.forName(boundSql.getResultType()));
return objectList.get(0);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
[*]解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和效果封装，提供新的功能模块替换这部门硬编码的逻辑处理。
[*]只有提供了单独的执行方法入口，我们才能更好的扩展和应对这部门内容里的需求变化，包罗了各类入参、效果封装、执行器范例、批处理等，来满足不同样式的用户需求，也就是配置到 Mapper.xml 中的具体信息。
目标
基于当前框架实现，解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和效果封装，提供SQL执行器功能模块替换这部门硬编码的逻辑处理。
计划
ORM 框架渐进式的开辟过程上，渐渐实现的执举措作：解析配置、代理对象、映射方法等，直至我们前面章节对数据源的包装和利用，只不过我们把数据源的操作硬编码到了 DefaultSqlSession 的执行方法上了。
为了解耦这块的功能处理，必要引入SQL执行器的服务功能，将SQL执行器随着 DefaultSqlSession 创建时传入，之后具体的方法调用就可以通过执行器来处理。
团体计划如图 ：
https://i-blog.csdnimg.cn/img_convert/8e70825a1053fc1d420ef6728ad3611e.png
[*]提取执行器的接口，界说执行方法、事件获取和相应提交、回滚、关闭的方法界说；
[*]执行器是一种标准的执行过程，由抽象类进行实现，可以对过程内容进行模板模式的过程包装。在包装过程中界说抽象类，由具体的子类来实现。这一部门在下文的代码中会体现到 SimpleExecutor 简单执行器实现中;
[*]对 SQL 的处理，利用 JDBC 执行 SQL 的时间，分为了简单处理和预处理，预处理中包罗准备语句、参数化通报、执行查询，以及最后的效果封装和返回。以是我们这里也必要把 JDBC 这部门的步骤，分为布局化的类过程来实现，便于功能的拓展。具体代码紧张体如今语句处理器 StatementHandler 的接口实现中。
实现
工程代码
https://i-blog.csdnimg.cn/img_convert/6104adc5a51f77f2b0bc98c9c9ff5268.png 类图
https://i-blog.csdnimg.cn/img_convert/c73ad39a404944820d3bf23c4da604f2.png
[*]Executor 接口界说为执行器入口，确定事件操作和 SQL 执行的同一标准。用BaseExecutor抽象类处理同一共用的事件和执行SQL的标准流程，并界说执行 SQL 的抽象接口#doQuery()，后续由子类实现。
[*]SimpleExecutor 简单SQL 执行器实现类中，处理 doQuery 方法的具体操作过程。这个过程中则会引入 SQL 语句处理器的创建，创建过程仍由 configuration 配置项提供。你会发现许多如许的生成处理，都来自于配置项
[*]执行器开辟完成后，由DefaultSqlSessionFactory 开启 openSession 的时间，随着构造函数参数通报给 DefaultSqlSession 中，如许在执行 DefaultSqlSession#selectOne 的时间就可以调用执行器进行处理了。也就由此完成解耦操作了。
实现步骤
1.执行器的界说和实现
执行器分为接口、抽象类、简单执行器实现类三部门，通常在框架的源码中对于一些标准流程的处理，都会有抽象类的存在。它负责提供共性功能逻辑，以及对接口方法的执行过程进行界说和处理，并提供抽象接口交由子类实现。这种计划模式也被界说为模板模式。
1-1. Executor界说执行器接口
[*]在执行器中界说的接口包罗事件相关的处理方法和执行SQL查询的操作，随着后续功能的迭代还会继承补充其他的方法。
public interface Executor {
ResultHandler NO_RESULT_HANDLER = null;
<E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);
Transaction getTransaction();
void commit(boolean required) throws Exception;
void rollback(boolean required) throws Exception;
void close(boolean forceRollback);
}
1-2.BaseExecutor执行器抽象基类
[*]封装了执行器的全部接口，如许具体的子类继承抽象类后，就可以直接利用这些共性的方法。在 query 查询方法中，封装一些必要的流程处理，如果检测关闭等，在 Mybatis 源码中另有一些缓存的操作，这里暂时剔撤除，以核心流程为主。读者伙伴在学习的过程中可以与源码进行对照学习。
public abstract class BaseExecutor implements Executor {
Logger logger = LoggerFactory.getLogger(BaseExecutor.class);
protected Configuration configuration;
protected Transaction transaction;
protected Executor wrapper;
private boolean closed;
protected BaseExecutor(Configuration configuration, Transaction transaction) {
this.configuration = configuration;
this.transaction = transaction;
this.wrapper = this;
}
// 连接关闭处理统一逻辑
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
if (closed) {
throw new RuntimeException("Executor was closed.");
}
return doQuery(ms, parameter, resultHandler, boundSql);
}
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);
@Override
public Transaction getTransaction() {
if (closed) {
throw new RuntimeException("Executor was closed.");
}
return transaction;
}
@Override
public void commit(boolean required) throws Exception {
if (closed) {
throw new RuntimeException("Cannot commit, transaction is already closed");
}
if (required) {
transaction.commit();
}
}
@Override
public void rollback(boolean required) throws SQLException {
if (closed) {
throw new RuntimeException("Cannot rollback, transaction is already closed");
}
if (required) {
transaction.rollback();
}
}
@Override
public void close(boolean forceRollback) {
try {
try {
rollback(forceRollback);
} finally {
transaction.close();
}
} catch (SQLException e) {
logger.warn("Unexpected exception on closing transaction.Cause: " + e);
} finally {
transaction = null;
closed = true;
}
}
}
1-3. SimpleExecutor 简单执行器实现
[*]简单执行器 SimpleExecutor 继承抽象基类，实现抽象方法 doQuery，在这个方法中包装数据源的获取、语句处理器的创建，以及对 Statement 的实例化和相关参数设置。最后执行 SQL 的处理和效果的返回操作。
public class SimpleExecutor extends BaseExecutor {
public SimpleExecutor(Configuration configuration, Transaction transaction) {
super(configuration, transaction);
}
@Override
protected <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
//处理查询逻辑.
try {
//获取配置信息
Configuration configuration = ms.getConfiguration();
//获取StatementHandler
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, resultHandler, boundSql);
//获取连接
Connection connection = transaction.getConnection();
Statement stmt = handler.prepare(connection);
handler.parameterize(stmt);
return handler.query(stmt, resultHandler);
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
}
2.语句处理器
语句处理器是 SQL 执行器中依靠的部门，SQL 执行器封装事件、毗连和检测情况等，而语句处理器则是准备语句、参数化通报、执行SQL、封装效果的处理。
2-1.StatementHandler界说语句处理接口
[*]语句处理器的核心: 准备语句、参数化通报参数、执行查询的操作，这里对应的 Mybatis 源码中还包罗了 update、批处理、获取参数处理器等。
public interface StatementHandler {
/**
* 准备语句
*/
Statement prepare(Connection connection) throws SQLException;
/**
* 参数化
*/
void parameterize(Statement statement) throws SQLException;
/**
* 执行查询
*/
<E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException;
}
2-2. BaseStatementHandler 语句处理器抽象基类
[*]语句处理器基类中，封装参数信息、效果信息。不过这里我们暂时还不会做过多的参数处理，比如jdbc的字段范例转换等。这部门内容随着我们整个执行器的布局创建完毕后，再进行迭代开辟。
[*]对 BaseStatementHandler#prepare 方法的处理，包罗界说实例化抽象方法，这个方法交由各个具体的实现子类进行处理。
public abstract class BaseStatementHandler implements StatementHandler {
protected final Configuration configuration;
protected final Executor executor;
protected final MappedStatement mapperStatement;
protected final Object parameter;
protected final ResultSetHandler resultSetHandler;
protected BoundSql boundSql;
protected BaseStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
ResultHandler resultHandler,
BoundSql boundSql) {
this.executor = executor;
this.configuration = mapperStatement.getConfiguration();
this.mapperStatement = mapperStatement;
this.parameter = parameter;
this.boundSql = boundSql;
this.resultSetHandler = configuration.newResultSetHandler(executor, mapperStatement, boundSql);
}
@Override
public Statement prepare(Connection connection) throws SQLException {
Statement statement = null;
try {
statement = instantiateStatement(connection);
statement.setQueryTimeout(350);
statement.setFetchSize(10000);
return statement;
} catch (Exception e) {
throw new RuntimeException("Error preparing statement.Cause: " + e, e);
}
}
protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
}
2-3. SimpleStatementHandler 简单语句处理器类
[*]SimpleStatementHandler 简单语句处理器,只是对 SQL 的最基本执行，没有参数的设置.
public class SimpleStatementHandler extends BaseStatementHandler {
public SimpleStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
ResultHandler resultHandler,
BoundSql boundSql) {
super(executor, mapperStatement, parameter, resultHandler, boundSql);
}
@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
return connection.createStatement();
}
@Override
public void parameterize(Statement statement) throws SQLException {
// N/A
}
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
String sql = boundSql.getSql();
statement.execute(sql);
return resultSetHandler.handleResultSets(statement);
}
}
2-4. PrepareStatementHandler 预处理语句处理器类
[*]预处理语句处理器中包罗 instantiateStatement 预处理 SQL、parameterize 设置参数，以及 query 查询的执行的操作。
[*]这里必要注意，当前 parameterize 设置参数中还是写死的，后续这部门再进行完善。
[*]query 方法则是执行查询和对效果的封装，效果的封装现在也是比较简单的处理，只是把我们前面章节中对象的内容摘取出来进行封装，这部门暂时没有改变。都放在后续进行完善处理。
public class PreparedStatementHandler extends BaseStatementHandler {
public PreparedStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
ResultHandler resultHandler,
BoundSql boundSql) {
super(executor, mapperStatement, parameter, resultHandler, boundSql);
}
@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
String sql = boundSql.getSql();
return connection.prepareStatement(sql);
}
@Override
public void parameterize(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.setLong(1, Long.parseLong(((Object[]) parameter).toString()));
}
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E>handleResultSets(ps);
}
}
3.执行器创建和利用
执行器开辟完成以后，则必要在串联到 DefaultSqlSession 中进行利用。串联过程：在 创建 DefaultSqlSession 的时间，构建出执行器，并作为参数通报到defaultSqlSession。这块涉及到 DefaultSqlSessionFactory#openSession 的处理。
3-1. 开启执行器
[*]openSession 中开启事件tx, 用于执行器的创建，具体实现可以看 configuration.newExecutor 代码，这部门没有太多复杂的逻辑。读者可以参考源码进行学习。
[*]在执行器创建完毕后，以参数方式通报给 DefaultSqlSession，如许就把整个过程串联起来了。
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private final Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration = configuration;
}
@Override
public SqlSession openSession() {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
TransactionFactory transactionFactory = environment.getTransactionFactory();
tx = transactionFactory.newTransaction(configuration.getEnvironment().getDataSource(),
TransactionIsolationLevel.READ_COMMITTED,
false);
// 创建执行器
final Executor executor = configuration.newExecutor(tx);
// 创建DefaultSqlSession
return new DefaultSqlSession(configuration, executor);
} catch (Exception e) {
try {
assert tx != null;
tx.close();
} catch (SQLException ignore) {
}
throw new RuntimeException("Error opening session.Cause: " + e);
}
}
}
3-2. 利用执行器
[*]完成上面执行器的全部实现后，就可以调用执行器进行功能解耦了。在 DefaultSqlSession#selectOne 中获取 MappedStatement 映射语句类后，则通报给执行器进行处理，那么如今这个类经过计划思想的解耦后，就变得更加干净整洁了，更易于维护和扩展了。
public class DefaultSqlSession implements SqlSession {
/**
* 配置项.
*/
private Configuration configuration;
private Executor executor;
public DefaultSqlSession(Configuration configuration, Executor executor) {
this.configuration = configuration;
this.executor = executor;
}
public Configuration getConfiguration() {
return configuration;
}
/**
* 根据给定的执行SQL获取一条记录的封装对象.
*
* @param statement
* @param <T>
* @return
*/
@Override
public <T> T selectOne(String statement) {
return this.selectOne(statement, null);
}
@Override
public <T> T selectOne(String statement, Object parameter) {
//映射语句
MappedStatement mappedStatement = configuration.getMappedStatement(statement);
//使用执行器.
List<T> list = executor.query(mappedStatement, parameter, Executor.NO_RESULT_HANDLER, mappedStatement.getBoundSql());
return list.get(0);
}
@Override
public <T> T getMapper(Class<T> type) {
return configuration.getMapper(type, this);
}
}
测试
事先准备
创建库表
-- 建表
CREATE TABLE `my_user` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID',
`user_id` varchar(9) DEFAULT NULL COMMENT '用户ID',
`user_head` varchar(16) DEFAULT NULL COMMENT '用户头像',
`create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
`update_time` timestamp NULL DEFAULT NULL COMMENT '更新时间',
`user_name` varchar(64) DEFAULT NULL COMMENT '用户名',
`user_password` varchar(64) DEFAULT NULL COMMENT '用户密码',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ;
-- 插入数据
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
public interface IUserDao {
String queryUserInfoById(String uid);
}
配置数据源
[*]通过 mybatis-config-datasource.xml 配置数据源信息，包罗：driver、url、username、password
[*]这里DataSource 配置的是 DRUID，因为我们实现的是这个数据源的处理方式。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="UNPOOLED">#无池化时配置成这个类型值
<dataSource type="POOLED">#池化时配置城这个类型值
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="mapper/User_Mapper.xml"/>
</mappers>
</configuration>
界说对应的mapper xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.suwg.mybatis.test.dao.IUserDao">
<select id="queryUserInfoById" parameterType="java.lang.Long" resultType="cn.suwg.mybatis.test.po.User">
SELECT id, user_id, user_head, create_time
FROM user
where id = #{id}
</select>
</mapper>
测试用例
[*]单位测试，通报一个 1L 的 long 范例参数，进行方法的调用处理。通过单位测试验证执行器的处理过程，读者在学习的过程中可以进行断点测试，学习每个过程的处理内容。
[*]mybatis-config-datasource.xml 中 dataSource 数据源范例的调整 dataSource type="DRUID/POOLED/UNPOOLED",按需配置验证.
单位测试
public class ApiTest {
private Logger logger = LoggerFactory.getLogger(ApiTest.class);
// 测试SqlSessionFactory
@Test
public void testSqlSessionFactory() throws IOException {
// 1.从xml文件读取mybatis配置项, 从SqlSessionFactory获取SqlSession.
Reader reader = Resources.getResourceAsReader("mybatis-config-datasource.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
SqlSession sqlSession = sqlSessionFactory.openSession();
// 2.获取映射器对象
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
// 4.测试验证
User user = userDao.queryUserInfoById(1L);
logger.info("测试结果：{}", JSON.toJSONString(user));
}
}
测试效果
https://i-blog.csdnimg.cn/img_convert/9061254bb17ecc71dc227b849e966e3c.png
https://i-blog.csdnimg.cn/img_convert/992f6a4fcf804d5ea96847b78f0f38f5.png
[*]从输出的效果来看，我们已经顺遂完成，将DefaultSqlSession#selectOne中的调用，替换成了执行器来完成整个过程，通过解耦这部门的逻辑操作，后续我们扩展就更方便了，这块的功能测试通过后，后续就可以聚焦在新的功能扩展点开辟了。
总结
[*]整个章节的实现都是在处明白耦这件事故，从DefaultSqlSession#selectOne 对数据源的处明白耦到执行器中进行操作。而执行器中又包罗了对 JDBC 处理的拆解，链接、准备语句、封装参数、处理效果，全部的这些过程经过解耦后的类和方法，就都可以在以后的功能迭代中非常方便的完成扩展了。
[*]本章节也为我们后续扩展参数的处理、效果集的封装预留出了扩展点，以及对于不同的语句处理器选择的问题，都必要在后续进行完善和补充。现在我们串联出来的是最核心的骨架布局，随着后续的渐进式开辟连续迭代完善。
[*]对于源码的学习，读者要经历看、写、思考、应用等几个步骤的过程，才能更好的吸收这里面的思想，每一次的阅读源码，都能有新的认知和领会。不要只是Ctrl+C，Ctrl+V一遍就完事了，否则也就失去了跟着学习源码的意义。
参考书籍：《手写Mybatis渐进式源码实践》
书籍源代码：https://github.com/fuzhengwei/book-small-mybatis
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]