一文搞懂mybatis Executor执行器体系

 众所周知mybatis是目前主流的持久层框架，使用广泛。先来看下mybatis执行流程

 

 

接下来我们再复习下JDBC连接

 

 代码演示

   private  Properties prop = new Properties();;

   private Connection connection;


    // 获取数据库连接
    @Before
    public void init() throws SQLException, IOException {
        prop.load(this.getClass().getResourceAsStream("/app.properties"));
        String URL =  String.valueOf(prop.get("jdbc.url"));
        String USERNAME = String.valueOf(prop.get("jdbc.username"));;
        String PASSWORD = String.valueOf(prop.get("jdbc.password"));;
        connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }

    @Test
    public void jdbcTest() throws SQLException {
        String sql = "SELECT * FROM user ";
        // 解析sql
        PreparedStatement sql1 = connection.prepareStatement(sql);
        // 执行sql语句
        sql1.execute();
        // 获取执行结果
        ResultSet resultSet = sql1.getResultSet();
        while (resultSet.next()) {
            System.out.println(resultSet.getString(2));
        }
        resultSet.close();
        // 关闭连接
        sql1.close();
    }

 

接下来着重介绍下下Executor执行器体系

 

 

Executor类图

 

Executor是MyBatis的SQL顶层执行器接口，声明了对数据库所有的增删改查操作。其中 query()和queryCursor()方法用于执行查询操作，update()方法用于执行插入、删除、修改操作。

BaseExecutor是Executor的抽象实现类，采用模板设计模式，它声明的抽象方法由子类SimpleExecutor、ReuseExecutor、BatchExecutor实现。

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

  protected abstract List<BatchResult> doFlushStatements(boolean isRollback)
      throws SQLException;

  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

  protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)
      throws SQLException;

 

SimpleExecutor是基础的Executor，能够完成基本的增删改查操作

 

    private static Configuration configuration;
    private static Transaction jdbcTransaction;
    private static MappedStatement ms;
    private static SqlSessionFactory factory;

    @Before
    public void init() throws IOException {
        // 获取构建器
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        // 解析XML 并构造会话工厂
        factory = factoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        configuration = factory.getConfiguration();
        jdbcTransaction = new JdbcTransaction(factory.openSession().getConnection());
        // 获取SQL映射
        ms = configuration.getMappedStatement("org.coderead.mybatis.UserMapper.selectByid");
    }

    // 简单执行器测试
    @Test
    public void simpleTest() throws SQLException {
        SimpleExecutor executor = new SimpleExecutor(configuration, jdbcTransaction);
        List<Object> list = executor.doQuery(ms, 10, RowBounds.DEFAULT,
                SimpleExecutor.NO_RESULT_HANDLER, ms.getBoundSql(10));

        executor.doQuery(ms, 10, RowBounds.DEFAULT,
                SimpleExecutor.NO_RESULT_HANDLER, ms.getBoundSql(10));
        System.out.println(list.get(0));
    }

 

ResueExecutor对JDBC中的Statement对象做了缓存，当执行相同的SQL语句时，直接从缓存中取出Statement对象进行复用，避免了频繁创建和销毁Statement对象，从而提升系统性能，这是享元思想的应用。

 

    private static Configuration configuration;
    private static Transaction jdbcTransaction;
    private static MappedStatement ms;
    private static SqlSessionFactory factory;

    @Before
    public void init() throws IOException {
        // 获取构建器
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        // 解析XML 并构造会话工厂
        factory = factoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        configuration = factory.getConfiguration();
        jdbcTransaction = new JdbcTransaction(factory.openSession().getConnection());
        // 获取SQL映射
        ms = configuration.getMappedStatement("org.coderead.mybatis.UserMapper.selectByid");
    }
   // 重用执行器
    @Test
    public void ReuseTest() throws SQLException {
        ReuseExecutor executor = new ReuseExecutor(configuration, jdbcTransaction);
        List<Object> list = executor.doQuery(ms, 10, RowBounds.DEFAULT,
                SimpleExecutor.NO_RESULT_HANDLER, ms.getBoundSql(10));
        //  相同的SQL 会缓存对应的 PrepareStatement-->缓存周期：会话
        executor.doQuery(ms, 10, RowBounds.DEFAULT,
                SimpleExecutor.NO_RESULT_HANDLER, ms.getBoundSql(10));
        System.out.println(list.get(0));
    }

 

BatchExecutor则会对调用同一个Mapper执行的update、insert和delete操作，调用Statement对象的批量操作功能。

    private static Configuration configuration;
    private static Transaction jdbcTransaction;
    private static MappedStatement ms;
    private static SqlSessionFactory factory;

    @Before
    public void init() throws IOException {
        // 获取构建器
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        // 解析XML 并构造会话工厂
        factory = factoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        configuration = factory.getConfiguration();
        jdbcTransaction = new JdbcTransaction(factory.openSession().getConnection());
        // 获取SQL映射
        ms = configuration.getMappedStatement("org.coderead.mybatis.UserMapper.selectByid");
    }
 // 批处理执行器
    @Test
    public void BatchTest() throws SQLException {
        BatchExecutor executor = new BatchExecutor(configuration, jdbcTransaction);
        MappedStatement setName = configuration
                .getMappedStatement("org.coderead.mybatis.UserMapper.setName");
        Map param = new HashMap<>();
        param.put("arg0", 10);
        param.put("arg1", "鲁班大叔 is good man");
        executor.doUpdate(setName, param); //设置
        executor.doUpdate(setName, param);// 设置
        executor.doFlushStatements(false);
    }

 

 

 

 

另外，我们知道MyBatis支持一级缓存和二级缓存，当MyBatis开启了二级缓存功能时，会使用CachingExecutor对SimpleExecutor、ResueExecutor、BatchExecutor进行装饰，为查询操作增加二级缓存功能，这是装饰器模式的应用。

 

    private static Configuration configuration;
    private static Transaction jdbcTransaction;
    private static MappedStatement ms;
    private static SqlSessionFactory factory;

    @Before
    public void init() throws IOException {
        // 获取构建器
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        // 解析XML 并构造会话工厂
        factory = factoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        configuration = factory.getConfiguration();
        jdbcTransaction = new JdbcTransaction(factory.openSession().getConnection());
        // 获取SQL映射
        ms = configuration.getMappedStatement("org.coderead.mybatis.UserMapper.selectByid");
    }
    @Test
    public void cacheExecutorTest() throws SQLException {
        // BaseExecutor
        Executor executor = new SimpleExecutor(configuration, jdbcTransaction);
        // 装饰器模式
        Executor cachingExecutor = new CachingExecutor(executor);// 二级缓存相关逻辑 执行数据操作逻辑

        cachingExecutor.query(ms, 10, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);
        cachingExecutor.commit(true);
        //  提交之后才会更新
        cachingExecutor.query(ms, 10, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);

    }