• 一、执行流程解析
  • 1、配置文件解析 configuration
  • 会话创建 SqlSession
• 二、myBatis插件开发

一、执行流程解析

1、配置文件解析 configuration

讲解解析流程之前先回顾一下myBatis 中配置文件的结构：

mybatis-config.xml

<configuration>
 <properties/>
 <settting/>
 <typeHandlers/>
 <environments />
 <..../>
 <mappers/>
</configuration>

mybatis-mapper.xml

<mapper namespace=""> 
 <cache/>
 <resultMap/>
 <select/> 
 <update/> 
 <delete/> 
 <insert/> 
</mapper>

配置文件的解析流程即是将上述XML描述元素转换成对应的JAVA对像过程，其最终转换对像及其关系如下图：

配置元素解析构建器： 职责单一原则

>org.apache.ibatis.builder.xml.XMLConfigBuilder

>org.apache.ibatis.builder.xml.XMLMapperBuilder

>org.apache.ibatis.builder.xml.XMLStatementBuilder

>org.apache.ibatis.builder.SqlSourceBuilder

>org.apache.ibatis.scripting.xmltags.XMLScriptBuilder

>org.apache.ibatis.builder.annotation.MapperAnnotationBuilder

sql statement 构建流程源码：

>org.apache.ibatis.session.SqlSessionFactoryBuilder#build()

1、Config.xml 文件解析

>org.apache.ibatis.builder.xml.XMLConfigBuilder#parse()

>org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration()

>org.apache.ibatis.builder.xml.XMLConfigBuilder#mapperElement()

2、Mapper.xml 文件解析

>org.apache.ibatis.builder.xml.XMLMapperBuilder#parse()

>org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement()

>org.apache.ibatis.builder.xml.XMLMapperBuilder#buildStatementFromContext()

3、Statemen sql块解析

​ >org.apache.ibatis.builder.xml.XMLStatementBuilder#parseStatementNode

​ >org.apache.ibatis.builder.MapperBuilderAssistant#addMappedStatement()

4、动态SQL脚本解析

>org.apache.ibatis.scripting.xmltags.XMLLanguageDriver#createSqlSource()

>org.apache.ibatis.scripting.xmltags.XMLScriptBuilder#parseScriptNode()

>org.apache.ibatis.scripting.xmltags.XMLScriptBuilder#parseDynamicTags()

会话创建 SqlSession

首先我们还是先来了解一下会话对像的组成结构如下图：

executor 英 /ɪɡˈzekjətə(r)/ 执行者

会话构建源码解析:

>org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSession(boolean)

>org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSessionFromDataSource

>org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory#newTransaction()

>org.apache.ibatis.session.Configuration#newExecutor()

>org.apache.ibatis.executor.SimpleExecutor#SimpleExecutor

>org.apache.ibatis.executor.CachingExecutor#CachingExecutor

//执行器插件包装

>org.apache.ibatis.plugin.InterceptorChain#pluginAll(executor)

>org.apache.ibatis.session.defaults.DefaultSqlSession#DefaultSqlSession()

方法执行 StatementHandler

StatementHandler 源码解析

>org.apache.ibatis.session.defaults.DefaultSqlSession#selectList()

>org.apache.ibatis.executor.CachingExecutor#query()

>org.apache.ibatis.executor.BaseExecutor#query()

>org.apache.ibatis.executor.BaseExecutor#queryFromDatabase

>org.apache.ibatis.session.Configuration#newStatementHandler

org.apache.ibatis.executor.statement.BaseStatementHandler#BaseStatementHandler

org.apache.ibatis.session.Configuration#newParameterHandler

org.apache.ibatis.plugin.InterceptorChain#pluginAll(parameterHandler)

org.apache.ibatis.session.Configuration#newResultSetHandler

org.apache.ibatis.plugin.InterceptorChain#pluginAll(resultSetHandler)

>org.apache.ibatis.plugin.InterceptorChain#pluginAll(statementHandler)

>org.apache.ibatis.executor.BaseExecutor#getConnection

>org.apache.ibatis.executor.statement.PreparedStatementHandler#instantiateStatement

>org.apache.ibatis.executor.statement.PreparedStatementHandler#parameterize

>org.apache.ibatis.scripting.defaults.DefaultParameterHandler#setParameters

org.apache.ibatis.type.BaseTypeHandler#setParameter

org.apache.ibatis.type.UnknownTypeHandler#setNonNullParameter

org.apache.ibatis.type.IntegerTypeHandler#setNonNullParameter

Mapper接口实例构建

二、myBatis插件开发

参考： mybatis（3）—自定义拦截器（上）基础使用 - 简书 (jianshu.com) (opens new window)

插件的四大扩展点

1、Executor 拦截执行器的方法

2、StatementHandler 拦截参数的处理

3、ParameterHandler 拦截结果集的处理

4、ResultSetHandler 拦截Sql语法构建的处理

分页插件实现：

用户在接口中声明Page 对像实现后，由插件实现自动分页。使用示例如下：

public class Page implements java.io.Serializable {
  private int size; // 每页大小
  private int page; // 当前页码
}

page参数声明

@Select("select * from user")
List<User> selectByPage(String name, Page page);

客户端调用

mapper.selectByPage("小明", new Page(3, 2)) 
select * from user limit 10,20

实现目标分解：

1、 修改SQL并添加 limit 语句

2、 判断方法参数中是否有Page对象

3、 取出Page对象 生成limit 语句

4、上述操作必须在PreparedStatement 对像生成前完成

自定义拦截器实现步骤

1、实现org.apache.ibatis.plugin.Interceptor接口。

2、添加拦截器注解org.apache.ibatis.plugin.Intercepts。

3、配置文件中添加拦截器。

参考 ：【myBatis】Mybatis中的拦截器_程序员面试经验分享-CSDN博客_mybatis拦截器 (opens new window)

@ToString
@AllArgsConstructor @NoArgsConstructor
public class Page<T> implements Serializable {

    @Getter@Setter
    private int pageNo = 1;//页码，默认是第一页

    @Getter@Setter
    private int pageSize = 15;//每页显示的记录数，默认是15

    private int totalRecord;//总记录数

    @Getter@Setter
    private int totalPage;//总页数

    @Getter@Setter
    private List<T> results;//对应的当前页记录

    @Getter@Setter
    private Map<String, Object> params = new HashMap<String, Object>();//其他的参数我们把它分装成一个Map对象

    public int getTotalRecord() {
        return totalRecord;
    }

    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
        //在设置总页数的时候计算出对应的总页数，在下面的三目运算中加法拥有更高的优先级，所以最后可以不加括号。
        int totalPage = totalRecord%pageSize==0 ? totalRecord/pageSize : totalRecord/pageSize + 1;
        this.setTotalPage(totalPage);
    }

    public Page(int pageNo, int pageSize) {
        this.pageNo = pageNo;
        this.pageSize = pageSize;
    }
}

定义拦截器

@Slf4j
@Intercepts({
    @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
public class PageIntercepter implements Interceptor {

    private String databaseType;//数据库类型，不同的数据库有不同的分页方法

    @Override
    public Object intercept(Invocation invocation) throws Throwable {

        //对于StatementHandler其实只有两个实现类，一个是RoutingStatementHandler，另一个是抽象类BaseStatementHandler，
        //BaseStatementHandler有三个子类，分别是SimpleStatementHandler，PreparedStatementHandler和CallableStatementHandler，
        //SimpleStatementHandler是用于处理Statement的，PreparedStatementHandler是处理PreparedStatement的，而CallableStatementHandler是
        //处理CallableStatement的。Mybatis在进行Sql语句处理的时候都是建立的RoutingStatementHandler，而在RoutingStatementHandler里面拥有一个
        //StatementHandler类型的delegate属性，RoutingStatementHandler会依据Statement的不同建立对应的BaseStatementHandler，即SimpleStatementHandler、
        //PreparedStatementHandler或CallableStatementHandler，在RoutingStatementHandler里面所有StatementHandler接口方法的实现都是调用的delegate对应的方法。
        //我们在PageInterceptor类上已经用@Signature标记了该Interceptor只拦截StatementHandler接口的prepare方法，又因为Mybatis只有在建立RoutingStatementHandler的时候
        //是通过Interceptor的plugin方法进行包裹的，所以我们这里拦截到的目标对象肯定是RoutingStatementHandler对象。
        RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
        //通过反射获取到当前RoutingStatementHandler对象的delegate属性
        StatementHandler delegate = (StatementHandler)ReflectUtil.getFieldValue(handler, "delegate");
        //获取到当前StatementHandler的 boundSql，这里不管是调用handler.getBoundSql()还是直接调用delegate.getBoundSql()结果是一样的，因为之前已经说过了
        //RoutingStatementHandler实现的所有StatementHandler接口方法里面都是调用的delegate对应的方法。
        BoundSql boundSql = delegate.getBoundSql();
        //拿到当前绑定Sql的参数对象，就是我们在调用对应的Mapper映射语句时所传入的参数对象
        Object obj = boundSql.getParameterObject();
        //这里我们简单的通过传入的是Page对象就认定它是需要进行分页操作的。
        if (obj instanceof Page<?>) {
            Page<?> page = (Page<?>) obj;
            //通过反射获取delegate父类BaseStatementHandler的mappedStatement属性
            MappedStatement mappedStatement = (MappedStatement) ReflectUtil.getFieldValue(delegate, "mappedStatement");
            //拦截到的prepare方法参数是一个Connection对象
            Connection connection = (Connection)invocation.getArgs()[0];
            //获取当前要执行的Sql语句，也就是我们直接在Mapper映射语句中写的Sql语句
            String sql = boundSql.getSql();
            //给当前的page参数对象设置总记录数
            this.setTotalRecord(page,
                    mappedStatement, connection);
            //获取分页Sql语句
            String pageSql = this.getPageSql(page, sql);
            //利用反射设置当前BoundSql对应的sql属性为我们建立好的分页Sql语句
            ReflectUtil.setFieldValue(boundSql, "sql", pageSql);
        }
        return invocation.proceed();
    }

    /**
     * 判断是否拦截这个类型对象（根据@Intercepts注解决定），然后决定是返回一个代理对象还是返回原对象
     * 1、CachingExecutor (SimpleExecutor)
     * 2、DefaultParameterHandler
     * 3、DefaultResultSetHandler
     * 3、RoutingStatementHandler PreparedStatementHandler
      */
    @Override
    public Object plugin(Object target) {
        log.debug("类型："+target);
        if (target instanceof StatementHandler) {
            log.debug("适配到类型："+target);
            return Plugin.wrap(target, this);
            /*return Proxy.newProxyInstance(
                    PageIntercepter.class.getClassLoader(),
                    new Class[]{StatementHandler.class},
                    new PageHandler((StatementHandler) target));*/
        }
        return target;
    }

    // 添加可配置的属性
    @Override
    public void setProperties(Properties properties) {
        log.debug("插件属性："+properties);
        this.databaseType = StrUtil.blankToDefault(properties.getProperty("databaseType"),"mysql");
        Interceptor.super.setProperties(properties);
    }

    /**
     * 根据page对象获取对应的分页查询Sql语句，这里只做了两种数据库类型，Mysql和Oracle
     * 其它的数据库都 没有进行分页
     *
     * @param page 分页对象
     * @param sql 原sql语句
     * @return
     */
    private String getPageSql(Page<?> page, String sql) {
        StringBuffer sqlBuffer = new StringBuffer(sql);
        if ("mysql".equalsIgnoreCase(databaseType)) {
            return getMysqlPageSql(page, sqlBuffer);
        } else if ("oracle".equalsIgnoreCase(databaseType)) {
            return getOraclePageSql(page, sqlBuffer);
        }
        return sqlBuffer.toString();
    }

    /**
     * 获取Mysql数据库的分页查询语句
     * @param page 分页对象
     * @param sqlBuffer 包含原sql语句的StringBuffer对象
     * @return Mysql数据库分页语句
     */
    private String getMysqlPageSql(Page<?> page, StringBuffer sqlBuffer) {
        //计算第一条记录的位置，Mysql中记录的位置是从0开始的。
        int offset = (page.getPageNo() - 1) * page.getPageSize();
        sqlBuffer.append(" limit ").append(offset).append(",").append(page.getPageSize());
        return sqlBuffer.toString();
    }

    /**
     * 获取Oracle数据库的分页查询语句
     * @param page 分页对象
     * @param sqlBuffer 包含原sql语句的StringBuffer对象
     * @return Oracle数据库的分页查询语句
     */
    private String getOraclePageSql(Page<?> page, StringBuffer sqlBuffer) {
        //计算第一条记录的位置，Oracle分页是通过rownum进行的，而rownum是从1开始的
        int offset = (page.getPageNo() - 1) * page.getPageSize() + 1;
        sqlBuffer.insert(0, "select u.*, rownum r from (").append(") u where rownum < ").append(offset + page.getPageSize());
        sqlBuffer.insert(0, "select * from (").append(") where r >= ").append(offset);
        //上面的Sql语句拼接之后大概是这个样子：
        //select * from (select u.*, rownum r from (select * from t_user) u where rownum < 31) where r >= 16
        return sqlBuffer.toString();
    }

    /**
     * 给当前的参数对象page设置总记录数
     *
     * @param page Mapper映射语句对应的参数对象
     * @param mappedStatement Mapper映射语句
     * @param connection 当前的数据库连接
     */
    private void setTotalRecord(Page<?> page,
                                MappedStatement mappedStatement, Connection connection) {
        //获取对应的BoundSql，这个BoundSql其实跟我们利用StatementHandler获取到的BoundSql是同一个对象。
        //delegate里面的boundSql也是通过mappedStatement.getBoundSql(paramObj)方法获取到的。
        BoundSql boundSql = mappedStatement.getBoundSql(page);
        //获取到我们自己写在Mapper映射语句中对应的Sql语句
        String sql = boundSql.getSql();
        //通过查询Sql语句获取到对应的计算总记录数的sql语句
        String countSql = this.getCountSql(sql);
        //通过BoundSql获取对应的参数映射
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        //利用Configuration、查询记录数的Sql语句countSql、参数映射关系parameterMappings和参数对象page建立查询记录数对应的BoundSql对象。
        BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, page);
        //通过mappedStatement、参数对象page和BoundSql对象countBoundSql建立一个用于设定参数的ParameterHandler对象
        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, page, countBoundSql);
        //通过connection建立一个countSql对应的PreparedStatement对象。
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            pstmt = connection.prepareStatement(countSql);
            //通过parameterHandler给PreparedStatement对象设置参数
            parameterHandler.setParameters(pstmt);
            //之后就是执行获取总记录数的Sql语句和获取结果了。
            rs = pstmt.executeQuery();
            if (rs.next()) {
                int totalRecord = rs.getInt(1);
                //给当前的参数page对象设置总记录数
                page.setTotalRecord(totalRecord);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null)
                    rs.close();
                if (pstmt != null)
                    pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 根据原Sql语句获取对应的查询总记录数的Sql语句
     * @param sql
     * @return
     */
    private String getCountSql(String sql) {
        int index = sql.indexOf("from");
        return "select count(*) " + sql.substring(index);
    }
}