前言
目前这个框架中所提供的 SQL 处理仅有一个 select 查询操作，还没有其他我们日常常用的 insert、update、delete，以及 select 查询返回的集合类型数据。
其实这一部分新增处理 SQL 的内容，也就是在 SqlSession 需要定义新的接口，通知让这些接口被映射器类方法 MapperMethod 进行调用处理。
那么这里显而易见，我们需要首先解决的是对 XML 的解析，由于之前在 ORM 框架的开发中，仅是处理了 select 的 SQL 信息，现在则需要把 insert/update/delete 的语句也按照解析 select 的方式进行处理。
扩展解析元素
需要先解决新增 SQL 类型的 XML 语句，把 insert、update、delete，几种类型的 SQL 解析完成后，存放到 Configuration 配置项的映射器语句中。
public class XMLMapperBuilder extends BaseBuilder {
// 省略部分未改变代码，可参考对应的源码学习...
// 配置mapper元素
// <mapper namespace="org.mybatis.example.BlogMapper">
// <select id="selectBlog" parameterType="int" resultType="Blog">
// select * from Blog where id = #{id}
// </select>
// </mapper>
private void configurationElement(Element element) {
// 1.配置namespace
String namespace = element.attributeValue("namespace");
if (namespace.equals("")) {
throw new RuntimeException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
// 2.配置select|insert|update|delete
buildStatementFromContext(element.elements("select"),
element.elements("insert"),
element.elements("update"),
element.elements("delete")
);
}
// 配置select|insert|update|delete
@SafeVarargs
private final void buildStatementFromContext(List<Element>... lists) {
for (List<Element> list : lists) {
for (Element element : list) {
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, element);
statementParser.parseStatementNode();
}
}
}
}
这里改造 buildStatementFromContext 方法的入参类型为 list 的集合，也就是处理所传递到方法中的所有语句的集合。
之后在 XMLMapperBuilder#configurationElement 调用层，传递 element.elements(“select”)、element.elements(“insert”)、element.elements(“update”)、element.elements(“delete”) 四个类型的方法，就可以把配置到 Mapper XML 中的不同 SQL 解析存放起来了。
新增执行方法
在 Mybatis 的 ORM 框架中，DefaultSqlSession 中最终的 SQL 执行都会调用到 Executor 执行器的，所以这里我们先来看下关于执行器中新增方法的变化。
update接口定义
public interface Executor {
ResultHandler NO_RESULT_HANDLER = null;
int update(MappedStatement ms, Object parameter) throws SQLException;
<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
// ...省略部分代码
}
update 是 Executor 执行接口新增的方法，在这次功能扩展中，Executor 执行器也就只增加了这么一个 update 方法。因为其他两个方法 insert、delete 的调用，也都是调用 update 就够了，所以这里 Mybatis 并没有在执行器中定义新的方法。
update接口实现
public class SimpleExecutor extends BaseExecutor {
public SimpleExecutor(Configuration configuration, Transaction transaction) {
super(configuration, transaction);
}
@Override
protected int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
// 新建一个 StatementHandler
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
// 准备语句
stmt = prepareStatement(handler);
// StatementHandler.update
return handler.update(stmt);
} finally {
closeStatement(stmt);
}
}
@Override
protected <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
// 新建一个 StatementHandler
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);
// 准备语句
stmt = prepareStatement(handler);
// 返回结果
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
}
SimpleExecutor#doUpdate 方法是 BaseExecutor 抽象类实现 Executor#update 接口后，定义的抽象方法。
这个抽象方法中，和 doQuery 方法几乎类似，都是创建一个新的 StatementHandler 语句处理器，之后准备语句，执行处理。
语句处理器实现
public abstract class BaseStatementHandler implements StatementHandler {
// ... 省略部分代码
protected BoundSql boundSql;
public BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
// 新增判断，因为 update 不会传入 boundSql 参数，所以这里要做初始化处理
if (boundSql == null) {
boundSql = mappedStatement.getBoundSql(parameterObject);
}
}
}
因为只有获取了 BoundSql 的参数，才能方便的执行后续对 SQL 处理的操作。所以在执行 update 方法，没有传入 BoundSql 的时候，则需要这里进行判断以及自己获取的处理操作。接下来是对抽象类的实现，具体的处理 update 方法。
public class PreparedStatementHandler extends BaseStatementHandler{
@Override
public int update(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return ps.getUpdateCount();
}
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
// ... 省略部分代码
}
SqlSession 定义和实现CRUD接口
在 SqlSession 中需要新增出处理数据库的接口，包括：selectList、insert、update、delete，这里我们来看下 DefaultSqlSession 对 SqlSession 接口方法的具体实现。
public class DefaultSqlSession implements SqlSession {
private Logger logger = LoggerFactory.getLogger(DefaultSqlSession.class);
private Configuration configuration;
private Executor executor;
public DefaultSqlSession(Configuration configuration, Executor executor) {
this.configuration = configuration;
this.executor = executor;
}
@Override
public <T> T selectOne(String statement) {
return this.selectOne(statement, null);
}
@Override
public <T> T selectOne(String statement, Object parameter) {
List<T> list = this.<T>selectList(statement, parameter);
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
throw new RuntimeException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
}
@Override
public <E> List<E> selectList(String statement, Object parameter) {
logger.info("执行查询 statement：{} parameter：{}", statement, JSON.toJSONString(parameter));
MappedStatement ms = configuration.getMappedStatement(statement);
try {
return executor.query(ms, parameter, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER, ms.getSqlSource().getBoundSql(parameter));
} catch (SQLException e) {
throw new RuntimeException("Error querying database. Cause: " + e);
}
}
@Override
public int insert(String statement, Object parameter) {
// 在 Mybatis 中 insert 调用的是 update
return update(statement, parameter);
}
@Override
public int update(String statement, Object parameter) {
MappedStatement ms = configuration.getMappedStatement(statement);
try {
return executor.update(ms, parameter);
} catch (SQLException e) {
throw new RuntimeException("Error updating database. Cause: " + e);
}
}
@Override
public Object delete(String statement, Object parameter) {
return update(statement, parameter);
}
// ... 省略部分代码
}
在 DefaultSqlSession 的具体实现中可以看到，update 方法调用了具体的执行器封装成方法以后，insert、delete 都是调用的这个 update 方法进行操作的。接口定义的是单一执行，接口实现是做了适配封装
另外这里单独提供了 selectList 方法，所以把之前在 selectOne 关于 executor.query 的执行处理，都迁移到 selectList 方法中。之后在 selectOne 中调用 selectList 方法，并给出相应的判断处理.
映射器命令执行调度
public class MapperMethod {
private final SqlCommand command;
private final MethodSignature method;
public MapperMethod(Class<?> mapperInterface, Method method, Configuration configuration) {
this.command = new SqlCommand(configuration, mapperInterface, method);
this.method = new MethodSignature(configuration, method);
}
public Object execute(SqlSession sqlSession, Object[] args) {
Object result = null;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.insert(command.getName(), param);
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.delete(command.getName(), param);
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.update(command.getName(), param);
break;
}
case SELECT: {
Object param = method.convertArgsToSqlCommandParam(args);
if (method.returnsMany) {
result = sqlSession.selectList(command.getName(), param);
} else {
result = sqlSession.selectOne(command.getName(), param);
}
break;
}
default:
throw new RuntimeException("Unknown execution method for: " + command.getName());
}
return result;
}
// 省略 SQL指令和方法前面代码块，可以参考源码
}
测试
配置数据源
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
配置Mapper
<select id="queryUserInfoById" parameterType="java.lang.Long" resultType="cn.bugstack.mybatis.test.po.User">
SELECT id, userId, userName, userHead
FROM user
where id = #{id}
</select>
<select id="queryUserInfo" parameterType="cn.bugstack.mybatis.test.po.User" resultType="cn.bugstack.mybatis.test.po.User">
SELECT id, userId, userName, userHead
FROM user
where id = #{id} and userId = #{userId}
</select>
<select id="queryUserInfoList" resultType="cn.bugstack.mybatis.test.po.User">
SELECT id, userId, userName, userHead
FROM user
</select>
<update id="updateUserInfo" parameterType="cn.bugstack.mybatis.test.po.User">
UPDATE user
SET userName = #{userName}
WHERE id = #{id}
</update>
<insert id="insertUserInfo" parameterType="cn.bugstack.mybatis.test.po.User">
INSERT INTO user
(userId, userName, userHead, createTime, updateTime)
VALUES (#{userId}, #{userName}, #{userHead}, now(), now())
</insert>
<delete id="deleteUserInfoByUserId" parameterType="java.lang.String">
DELETE FROM user WHERE userId = #{userId}
</delete>
单元测试
public interface IUserDao {
User queryUserInfoById(Long id);
User queryUserInfo(User req);
List<User> queryUserInfoList();
int updateUserInfo(User req);
void insertUserInfo(User req);
int deleteUserInfoByUserId(String userId);
}
测试
@Test
public void test_insertUserInfo() {
// 1. 获取映射器对象
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
// 2. 测试验证
User user = new User();
user.setUserId("10002");
user.setUserName("小白");
user.setUserHead("1_05");
userDao.insertUserInfo(user);
logger.info("测试结果：{}", "Insert OK");
// 3. 提交事务
sqlSession.commit();
}
查询测试(多条数据)
@Test
public void test_queryUserInfoList() {
// 1. 获取映射器对象
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
// 2. 测试验证：对象参数
List<User> users = userDao.queryUserInfoList();
logger.info("测试结果：{}", JSON.toJSONString(users));
}
总结
Mybatis 的全部主干流程串联实现完成了，可以执行对数据库的增删改查操作，读者伙伴也可以发现，
关于 Mybatis 的框架中，还有一些额外扩展的知识点，比如：插入时返回当前ID、Map 类型映射、一级二级缓存、插件模块等，后续的章节中我们会找一些有代表性的内容，进行扩展开发学习。
好了到这里就结束了手写mybatis之完善ORM框架，增删改查操作的学习，大家一定要跟着动手操作起来。需要源码的 可si我获取；
