手敲Mybatis(十)-完善ORM框架支持增删改查

我们把基本的功能都完成了，解析xml、构建映射代理、执行sql，解析处理结果，目前这些只支持查询，我们还差添加下增删改的功能，本章节就来完善下增删改，其实本章节比较简单，因为之前的每个章节都已设计好，所以这个章节主要在其基础上进行扩展以及少部分的修改即可。

要修改的有以下几点

1.在解析XML的时候，我们只解析了SELECT的资源，我们要加入也可以解析INSERT、UPDATE、DELETE、等的资源。

 2.SqlSession里也要加入insert、delete、update、的方法，供调用使用。

 3.再就是代理方法执行标签选择的时候，要执行哪个方法，也要加上增删改

 4.Sql执行器也要更改添加，唯一不同的是执行器只增加update即可，由于jdbc对于Sql的增删改操作都是修改，所以增删改的操作指用调用update就可以

 还有一些小细节都改动，咱们代码里细细说来。

1.代码实现

XMLMapperBuilder类里configurationElement方法里添加解析UPDATE、INSERT、DELETE、标签，buildStatementFromContext可接收多个参数，并添加for循环解析多个标签问题。

public class XMLMapperBuilder extends BaseBuilder {
// 省略其他方法

 private void configurationElement(Element element) {
        // 配置namespace
        String namespace = element.attributeValue("namespace");
        if (namespace.equals("")) {
            throw new RuntimeException("Mapper's namespace cannot be empty");
        }
        builderAssistant.setCurrentNamespace(namespace);
        // select，新增解析update、delete、insert
        buildStatementFromContext(element.elements("select"),
                element.elements("update"),
                element.elements("insert"),
                element.elements("delete"));
    }

private void buildStatementFromContext(List<Element>... lists) {
        for(List<Element> list:lists){
            for (Element element : list) {
                // 解析语句
                final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, element);
                statementParser.parseStatementNode();
            }
        }
    }
}

SqlSession类：除了添加更新、新增、删除还有查询集合数据方法以及提交事务方法的定义

public interface SqlSession {
    /**
     * Execute an update statement. The number of rows affected will be returned.
     * 更新记录
     *
     * @param statement Unique identifier matching the statement to execute.
     * @param parameter A parameter object to pass to the statement.
     * @return int The number of rows affected by the update. 返回的是受影响的行数
     */
    int update(String statement, Object parameter);

    /**
     * Execute an insert statement with the given parameter object. Any generated
     * autoincrement values or selectKey entries will modify the given parameter
     * object properties. Only the number of rows affected will be returned.
     * 插入记录，容许传入参数。
     *
     * @param statement Unique identifier matching the statement to execute.
     * @param parameter A parameter object to pass to the statement.
     * @return int The number of rows affected by the insert. 注意返回的是受影响的行数
     */
    int insert(String statement, Object parameter);

    /**
     * Execute a delete statement. The number of rows affected will be returned.
     * 删除记录
     *
     * @param statement Unique identifier matching the statement to execute.
     * @param parameter A parameter object to pass to the statement.
     * @return int The number of rows affected by the delete. 返回的是受影响的行数
     */
    Object delete(String statement, Object parameter);
   
    <E> List<E> selectList(String statement, Object parameter);

    /**
     * 以下是事务控制方法 commit,rollback
     * Flushes batch statements and commits database connection.
     * Note that database connection will not be committed if no updates/deletes/inserts 
       were called.
     */
    void commit();

    // 省略其他
}

 SqlSession的实现类，增删改都调用了update的方法，而update的方法最终也调用了Sql执行器的更新操作，除此之外添加了查询集合的方法(selectList)，这样selectOne就可以直接调用selectList方法得到数据，并在自己的方法获取第一个数据返回即可。

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;
    private Executor executor;

    //private MapperRegistry mapperRegistry;
    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this.configuration = configuration;
        this.executor = executor;
    }

    @Override
    public int update(String statement, Object parameter) {
        // 查询要处理哪个mapper语句
        MappedStatement ms = configuration.getMappedStatement(statement);
        try {
            return executor.update(ms, parameter);
        } catch (SQLException e) {
            throw new RuntimeException("Error updating database.  Cause: " + e);
        }
    }

    @Override
    public int insert(String statement, Object parameter) {
        return update(statement, parameter);
    }

    @Override
    public Object delete(String statement, Object parameter) {
        return update(statement, parameter);
    }

    @Override
    public <T> T selectOne(String statement) {
        return this.selectOne(statement, null);
    }

    // 更改调用selectList最后返回第一个数据
    @Override
    public <T> T selectOne(String statement, Object parameter) {
        List<T> list = this.<T>selectList(statement, parameter);
        try {
            if (list.size() == 0) {
                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;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public <E> List<E> selectList(String statement, Object parameter) {
        System.out.println("执行查询 statement：" + statement + "parameter：" + 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 void commit() {
        try {
            executor.commit(true);
        } catch (SQLException e) {
            throw new RuntimeException("Error committing transaction.  Cause: " + e);
        }
    }
 // 省略其他
}

MapperMethod类的更改，想必都知道了，根据标签来调用具体的SqlSession的增删改查，没有这步的话也没办法执行Sql语句了，哈哈哈

public class MapperMethod {
   
    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.returnMany) {
                    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;
    }

    // 省略其他方法
}

Executor：执行器更改点需添加update方法支持用户对数据的更改（增删改）操作

public interface Executor {
    // 省略其他
    int update(MappedStatement ms, Object parameter)throws SQLException;
}

 BaseExecutor 实现了Executor类的update方法，并抽象出doUpdate方法，供不同的类执行逻辑

public abstract class BaseExecutor implements Executor {
 
    // 省略其他

    @Override
    public int update(MappedStatement ms, Object parameter)throws SQLException{
         return doUpdate(ms,parameter);
    }

    protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;

}

SimpleExecutor类：此类实现doUpdate的方法，处理实例化语句处理器、获取连接、语句准备、参数设置、更新Sql等流程，其实也算是个模板模式思路。

public class SimpleExecutor extends BaseExecutor {

    @Override
    protected int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        Statement stmt = null;
        try {
            Configuration configuration = ms.getConfiguration();
            // 调用创建语句处理器-PreparedStatementHandler
            StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
            Connection connection = transaction.getConnection();
            // 调用语句处理器-准备操作，如初始化参数
            stmt = handler.prepare(connection);
            // 设置参数
            handler.parameterize(stmt);
            // 调用语句处理器的更新方法
            return handler.update(stmt);

        } finally {
            closeStatement(stmt);
        }
    }
}

StatementHandler类：SimpleExecutor中是通过语句处理器执行Sql的，所以我们需要在语句处理器中定义update方法

public interface StatementHandler {
    // 省略其他...

    int update(Statement statement) throws SQLException;
}

BaseStatementHandler类：此类主要是SqlSession调用update方法时不传绑定的Sql，所以我们在构造参数里需要获取下BoundSql即可，不绑定执行会报错哦，毕竟没用Sql怎么执行呢！

 public BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        // 省略....

        // 新增判断，update不传参数
        if (boundSql == null) {
            boundSql = mappedStatement.getBoundSql(parameterObject);
        }
        this.boundSql = boundSql;
    }

SimpleStatementHandler：简单语句处理器，没有参数情况下的一种处理器，可直接调用JDBC的statement执行update方法。

public class SimpleStatementHandler extends BaseStatementHandler {

    // 省略其他...

    @Override
    public int update(Statement statement) throws SQLException {
        String sql = boundSql.getSql();
        return statement.executeUpdate(sql);
    }
}

PreparedStatementHandler类：预处理语句处理器，支持带参数的sql执行，可直接通过JDBC与预处理语句调用execute()方法来增删改查操作

public class PreparedStatementHandler extends BaseStatementHandler {


    // 省略其他....

    @Override
    public int update(Statement statement) throws SQLException {
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();
        return ps.getUpdateCount();
    }
}

其实看到这里发现基本没有什么修改，而扩展居多，而在对于设计方面来说了最基本的原则也是对修改关闭，对扩展开放，我们在设计好的代码里面修改，思路就会很清晰，一点也不会乱，这就是我们需要学习和借鉴的代码设计能力。

2.单元测试

mapper.xml更改，添加标签INSERT，UPDATE，DELETE等sql语句

<mapper namespace="df.middleware.mybatis.dao.IUserDao">

    <!--<select id="queryUserInfoById" parameterType="java.lang.Long" resultType="df.middleware.mybatis.po.User">
        SELECT id, userId, userHead,userName
        FROM user
        where id = #{id}
    </select>-->
    <update  id="updateById" parameterType="java.lang.Long">
        update user set userName='df_lucky_forever' where id = #{id}
    </update>

    <update  id="insert" parameterType="df.middleware.mybatis.po.User" >
        INSERT INTO user
        (userId, userName, userHead, createTime, updateTime)
        VALUES (#{userId}, #{userName}, #{userHead}, now(), now())
    </update>

    <delete id="deleteUserInfoByUserId" parameterType="java.lang.String">
        DELETE FROM user WHERE userId = #{userId}
    </delete>

    <select id="queryUserInfoList" resultType="df.middleware.mybatis.po.User">
        SELECT id, userId, userName, userHead
        FROM user
    </select>
<!--   <select id="queryUserInfo" parameterType="df.middleware.mybatis.po.User" resultType="df.middleware.mybatis.po.User">-->
<!--        SELECT id, userId, userName, userHead-->
<!--        FROM user-->
<!--        where id = #{id} and userId = #{userId}-->
<!--    </select>-->
</mapper>

单元测试类，添加了增加、修改、删除、查询列表的测试，你们可以将增删改查都试下，

public class TestApi {
    private SqlSession sqlSession;

    @Before
    public void init() throws IOException {
        // 1. 从SqlSessionFactory中获取SqlSession
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config-datasource.xml"));
        sqlSession = sqlSessionFactory.openSession();
    }


    @org.junit.Test
    public void test_queryUserInfoById() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证：基本参数
        User user = userDao.queryUserInfoById(1L);
        System.out.println("测试结果：" + user.getUserName());
    }

    @org.junit.Test
    public void test_queryUserInfo() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证：对象参数
        User user = userDao.queryUserInfo(new User(1L, "10001"));
        System.out.println(user);
        System.out.println(user.getUserName());
    }


    @org.junit.Test
    public void test_updateById() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证：基本参数
        userDao.updateById(1L);


        sqlSession.commit();
        //System.out.println("测试结果：" + user.getUserName());
    }

    @Test
    public void test_insertUserInfo() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证
        User user = new User();
        user.setUserId("10003");
        user.setUserName("价钱");
        user.setUserHead("1_06");
        userDao.insert(user);
        System.out.println("测试结果：" + "Insert OK");

        // 3. 提交事务
        sqlSession.commit();
    }

    @Test
    public void test_deleteUserInfoByUserId() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证
        int count = userDao.deleteUserInfoByUserId("10003");
        System.out.println("测试结果："+count);

        // 3. 提交事务
        sqlSession.commit();
    }


    @Test
    public void test_queryUserInfoList() {
        // 1. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 2. 测试验证：对象参数
        List<User> users = userDao.queryUserInfoList();
        System.out.println(users.get(0).getUserName());
        System.out.println(users.get(1).getUserName());
        System.out.println(users.get(2).getUserName());
    }

}

执行成功，大家可以试下，不熟悉断点调试下 ，END...