手敲Mybatis(五)-SQL执行器

PromisingGirl-Du

已于 2023-03-11 19:57:13 修改

阅读量843

点赞数

分类专栏： MyBatis专栏文章标签： mybatis sql 数据库

于 2022-10-28 12:58:50 首次发布

本文链接：https://blog.csdn.net/dfBeautifulLive/article/details/127511124

版权

MyBatis专栏专栏收录该内容

18 篇文章 20 订阅

订阅专栏

上一章节的DefaultSqlSession类获取连接以及执行sql语句再转换结果等的写法不符合单一职责原则，这样日后维护这个方法会越来越长，甚至更改还会出现其他业务错误的可能，所以这一章节围绕的就是按各个职能去拆分不同的类去实现，也方便日后扩展，如执行SQL语句则使用执行器去执行，在执行的过程中需要得到SQL语句，所以需要设计语句处理器需要准备语句，参数化（预处理则将参数进行?转为数据），最后才执行查询等操作，这些类相辅相成，最终的设计则体现在可独自使用，也可按流程合在一起执行。

1.UML类图

2.代码实现

Executor类：定义执行器接口，这里定义了查询方法、获取事务、以及对事务提交关闭和回滚等方法，等待相关子类实现。

package df.middleware.mybatis.executor

public interface Executor {
    ResultHandler NO_RESULT_HANDLER = null;

    // 定义执行Sql查询操作
    <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);

    Transaction getTransaction();

    // 以下事务处理-提交、回滚、关闭
    void commit(boolean required) throws SQLException;

    void rollback(boolean required) throws SQLException;

    void close(boolean forceRollback);

}

BaseExecutor类：实现Executor接口，此类的query方法则使用了模板模式，先判断事务是否关闭，如没有执行doQuery()查询方法，这个方法就可以由子类去实现，其他的事务提交回滚以及关闭都是一样的操作，所以都写到基础BaseExecutor类。

package df.middleware.mybatis.executor;

// 基础执行器，处理事务和执行查询的定义，此类处理共性的方法
public abstract class BaseExecutor implements Executor {

    private org.slf4j.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 SQLException {
        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) {
            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;
        }
    }

}

SimpleExecutor类：简单执行器，BaseExecutor的子类，继承自BaseExecutor，实现doQuery()方法，将流程放入了这个方法中，如创建的是语句处理器，则后续用语句处理器进行初始化参数，并用语句处理器进行设置参数以及调用语句处理器的查询方法，可能语句处理器你比较模糊，sql查询有的需要参数，则参数的设置过程叫预处理，没有参数的基本查询则叫简单语句处理器，不用处理参数，这个下面会介绍这两个类。

总之此类的作用就是总(流程再此组合)-分(不同的职责不同的类)-总(最后还是回归此并返回结果)

package df.middleware.mybatis.executor;

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 {
             try {
            Configuration configuration = ms.getConfiguration();
            // 调用创建语句处理器-PreparedStatementHandler
            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;
        }
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

}

StatementHandler类：语句处理器接口，定义准备语句，参数化，执行查询

package df.middleware.mybatis.executor.statement;

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;

}

BaseStatementHandler类：语句处理器基础类，继承StatementHandler，实现准备方法，原因是此方法在简单处理器和预处理处理器都要使用，则提取出共用。并定义了instantiateStatement()由子类实现，

package df.middleware.mybatis.executor.statement;

public abstract class BaseStatementHandler implements StatementHandler {

    protected final Configuration configuration;
    protected final Executor executor;
    protected final MappedStatement mappedStatement;

    protected final Object parameterObject;
    protected final ResultSetHandler resultSetHandler;

    protected BoundSql boundSql;

    public BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, ResultHandler resultHandler, BoundSql boundSql) {
        this.configuration = mappedStatement.getConfiguration();
        this.executor = executor;
        this.mappedStatement = mappedStatement;
        this.boundSql = boundSql;

        this.parameterObject = parameterObject;
        this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, boundSql);
    }

    @Override
    public Statement prepare(Connection connection) throws SQLException {
        Statement statement = null;
        try {
            // 实例化 Statement
            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;

}

PreparedStatementHandler：预处理语句处理器，继承基础语句处理器，实现创建stament初始化，参数化以及查询操作。

由于是有参数的，所以在instantiateStatement()需要将sql语句传入，参数化时用PreparedStatement进行参数化设置。

为什么此用定义了query()，原因是由于有参数查询和无参数查询不一样，需要使用PreparedStatement.execute()，普通的则直接可以使用Statement.execute()，所以这里这样就添加了query()，前面讲的查询执行器最终会调用语句处理器的某个具体实现

package df.middleware.mybatis.executor.statement;

public class PreparedStatementHandler extends BaseStatementHandler{

    public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, ResultHandler resultHandler, BoundSql boundSql) {
        super(executor, mappedStatement, parameterObject, 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[]) parameterObject)[0].toString()));
    }

    @Override
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();
        return resultSetHandler.<E> handleResultSets(ps);
    }

}

SimpleStatementHandler类：简单语句处理器，继承基础语句处理器，创建statement方式则可以不用传入Sql语句，参数化也不用设置，执行查询时可用普通的statement执行，

package df.middleware.mybatis.executor.statement;

public class SimpleStatementHandler extends BaseStatementHandler {

    public SimpleStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, ResultHandler resultHandler, BoundSql boundSql) {
        super(executor, mappedStatement, parameterObject, 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);
    }

ResultSetHandler类：结果集处理器，接口，定义了handleResultSets()方法，在configure类里进行实例化子类。依次传递到结果查询再此调用此方法。

package cn.bugstack.mybatis.executor.resultset;

public interface ResultSetHandler {

    <E> List<E> handleResultSets(Statement stmt) throws SQLException;
}

DefaultResultSetHandler类：实现ResultSetHandler，和之前编码业务逻辑一样，只不过提取出来放到它该放的位置上，每个代码都有自己的职责功能。

package cn.bugstack.mybatis.executor.resultset;

public class DefaultResultSetHandler implements ResultSetHandler {

    private final BoundSql boundSql;

    public DefaultResultSetHandler(Executor executor, MappedStatement mappedStatement, BoundSql boundSql) {
        this.boundSql = boundSql;
    }

    @Override
    public <E> List<E> handleResultSets(Statement stmt) throws SQLException {
        ResultSet resultSet = stmt.getResultSet();
        try {
            return resultSet2Obj(resultSet, Class.forName(boundSql.getResultType()));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    private <T> List<T> resultSet2Obj(ResultSet resultSet, Class<?> clazz) {
        List<T> list = new ArrayList<>();
        try {
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            // 每次遍历行值
            while (resultSet.next()) {
                T obj = (T) clazz.newInstance();
                for (int i = 1; i <= columnCount; i++) {
                    Object value = resultSet.getObject(i);
                    String columnName = metaData.getColumnName(i);
                    String setMethod = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
                    Method method;
                    if (value instanceof Timestamp) {
                        method = clazz.getMethod(setMethod, Date.class);
                    } else {
                        method = clazz.getMethod(setMethod, value.getClass());
                    }
                    method.invoke(obj, value);
                }
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
}

Configuration类：此类的更改是添加了上述的执行器，语句处理器，结果器的实例化

package df.middleware.mybatis.session;

  /**
     * 创建结果集处理器
     */
    public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, BoundSql boundSql) {
        return new DefaultResultSetHandler(executor, mappedStatement, boundSql);
    }

    /**
     * 生产执行器
     */
    public Executor newExecutor(Transaction transaction) {
        return new SimpleExecutor(this, transaction);
    }

    /**
     * 创建语句处理器
     */
    public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
        return new PreparedStatementHandler(executor, mappedStatement, parameter, resultHandler, boundSql);
    }

DefaultSqlSession类：此类更改如下，添加执行器全局变量，则可简化成直接执行query即可达到目的。

package df.middleware.mybatis.session.defaults;

public class DefaultSqlSession implements SqlSession {

    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) {
        MappedStatement ms = configuration.getMappedStatement(statement);
        List<T> list = executor.query(ms, parameter, Executor.NO_RESULT_HANDLER, ms.getBoundSql());
        return list.get(0);
    }

    @Override
    public <T> T getMapper(Class<T> type) {
        return configuration.getMapper(type, this);
    }

    @Override
    public Configuration getConfiguration() {
        return configuration;
    }

}

DefaultSqlSessionFactory类：此类更改为，在执行openSession()时创建执行器，并将执行器传给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);
        }
    }

}

准备测试：

mybatis-config-datasource.xml

<configuration>

    <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_demo?useUnicode=true"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/User_Mapper.xml"/>
    </mappers>

</configuration>

User_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.bugstack.mybatis.test.dao.IUserDao">

    <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>

</mapper>

单元测试：这就是职责功能拆分的好处，就是外部调用时没有改内容，但内部已经发生很大的变动


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

        // 2. 获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 3. 测试验证
        User user = userDao.queryUserInfoById(1L);
        logger.info("测试结果：{}", JSON.toJSONString(user));
    }

还是一样的结果

PromisingGirl-Du

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
手敲Mybatis(五)-SQL执行器

上一章节的DefaultSqlSession类获取连接以及执行sql语句再转换结果等的写法不符合单一职责原则，这样日后维护这个方法会越来越长，甚至更改还会出现其他业务错误的可能，所以这一章节围绕的就是按各个职能去拆分不同的类去实现，也方便日后扩展，如执行SQL语句则使用执行器去执行，在执行的过程中需要得到SQL语句，所以需要设计语句处理器需要准备语句，参数化（预处理则将参数进行?转为数据），最后才执行查询等操作，这些类相辅相成，最终的设计则体现在可独自使用，也可按流程合在一起执行。
复制链接

扫一扫