利用mybatis拦截器记录sql，辅助我们建立索引(二)

人工智能机器人

背景

上一篇中讲述了mybatis的mapper初始化过程和执行过程，这篇再讲讲具体的拦截器的使用，以实现记录sql到持久化存储，通过分析这些sql，我们就能更方便地建立索引。
利用mybatis拦截器记录sql，辅助我们建立索引(一)
我本地项目的大概版本：
spring boot版本2.7，mybatis版本大致如下：

mybatis中sql执行过程

上篇中介绍了mapper的初始化过程、mapper的简单执行过程，但没涉及太多的mapper执行中的细节，但是不把这里讲细一点，拦截器的部分也不好讲，无法知道拦截器是在什么时间执行的，所以我们本篇会再细化一下mapper的执行过程。
上下文

以下图举例，这里会执行一个sysDictMapper.selectList方法：

mapper构造

上一篇中，我们提到了，每个mapper接口，背后都对应了一个FactoryBean：org.mybatis.spring.mapper.MapperFactoryBean。
对于这种FactoryBean，要生成实际的bean，会调用其getObject方法：


其中，getSqlSession方法，代码如下，就是返回一个org.mybatis.spring.SqlSessionTemplate对象：

然后是getMapper方法：
这里会先获取org.apache.ibatis.session.Configuration类型对象，然后从这个configuration中获取Mapper。
不过我这里，返回的是com.baomidou.mybatisplus.core.MybatisConfiguration，这个类是mybatis-plus的，继承了org.apache.ibatis.session.Configuration。


接下来就是调用com.baomidou.mybatisplus.core.MybatisConfiguration的getMapper方法：
在mybatis-plus版本的configuration对象中，有一个mapper注册表对象：

这里就会从这个注册表中获取Mapper：

注册表对象的getMapper方法代码如下，会先根据mapper的class，获取一个对应的工厂，再调用工厂的方法：

该工厂的newInstance实现如下：

构造了一个MybatisMapperProxy类型的对象，该对象是实现了jdk的动态代理的：

最终呢，就利用这个jdk动态代理对象，代理了mapper对应的class，也就是说，后续调用这个mapper接口的中方法，都会被该动态代理给拦截：


所以，最终构造的mapper，就是下面这样一个动态代理对象，动态代理的处理类呢，为com.baomidou.mybatisplus.core.override.MybatisMapperProxy类型，里面包含了两个field：
sqlSessionTemplate、mapper接口对应的class。

mapper的select方法执行

PlainMethodInvoker创建

接下来，开始执行其select方法：

然后，被动态代理拦截：

上图红框的cacheInvoker如下：
由于我们不是接口中的default方法，所以进入如下红框所示：

先是构造了一个MybatisMapperMethod对象：

然后构造了如下PlainMethodInvoker类型的对象：

PlainMethodInvoker#invoke

public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) {    return mapperMethod.execute(sqlSession, args);}进入MybatisMapperMethod#executeForMany:

接下来，会交给spring的sqlSessionTemplate来执行：

SqlSessionTemplate#selectList


这里会交给sqlSessionProxy，本来正常是每次都要获取一个新的session，但是spring考虑到事务管理，由于事务管理是在整个事务中必须使用同一个session，所以就不能每次获取一个新的session，所以搞了个sqlSessionProxy来实现这个事情。
来看看其构造：

根据上图，最终调用进入到SqlSessionInterceptor

上图中的getSqlSession如下：

由于我们这里没加事务注解，自然是没事务的，所以会走到上面的无事务那部分：

mybatis的sessionFactory#openSession

这里就进入mybatis相关jar包的代码了，当前this为：DefaultSqlSessionFactory
org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSession(org.apache.ibatis.session.ExecutorType)public SqlSession openSession(ExecutorType execType) {  return openSessionFromDataSource(execType, null, false);}我们进入具体实现：

这里刚开始，获取了一个environment，注意这个不是springboot里那个environment，是myabtis里的。具体其中有啥字段，可以看上图右下角：里面包含了transactionFactory、datasource等。
然后，这里会再new一个Transaction：

完成事务对象tx创建后，进入如下方法：
final Executor executor = configuration.newExecutor(tx, execType);  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {    // 1 计算Executor的type    executorType = executorType == null ? defaultExecutorType : executorType;    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;    // 2 根据type，创建不同类的Executor对象，我们一般是Simple    Executor executor;    if (ExecutorType.BATCH == executorType) {      executor = new BatchExecutor(this, transaction);    } else if (ExecutorType.REUSE == executorType) {      executor = new ReuseExecutor(this, transaction);    } else {      executor = new SimpleExecutor(this, transaction);    }    // 3 如果开启了缓存，会装饰一层    if (cacheEnabled) {      executor = new CachingExecutor(executor);    }    // 4 利用拦截器对Executor进行代理    executor = (Executor) interceptorChain.pluginAll(executor);    return executor;  }如上图所示，先是计算ExecutorType，我们一般是simple


在完成SimpleExecutor的创建后，检查是否开启了cacheEnabled选项，就是mybatis的一二级缓存啥的，这个是默认开启的，我这边为了减少干扰，改了配置项，先关了。
  configuration:    cache-enabled: false
再接下来，会有一个拦截器链，对我们创建出来的Executor对象进行动态代理（如果发现Executor接口中的方法，有匹配的拦截器的话）

拦截器链


我们这里只有一个拦截器，就是分页的拦截器，target就是我们传入的SimpleExecutor。
然后调用拦截器的plugin方法：

这里会继续调用Plugin类的wrap方法，这是个static方法，参数就是拦截器本身、要被拦截的target本身（即这里的SimpleExecutor）。
我们看看分页插件的代码中怎么定义的，看看是拦截了哪些方法：

这里怎么检查target（SimpleExecutor）是否需要被拦截呢，那就检测下有没有交集就行了（看看target实现的所有接口，是否和拦截器定义的类匹配）。如下，先获取target中的接口和拦截器中接口，是否有交集：

如果有交集，就会给SimpleExecutor创建代理对象，其中invocationHandler的类型就是Plugin类型：


通过这样，就完成了对Executor对象的动态代理。
接下来呢，就会继续完成DefaultSqlSession的创建：


接下来，放入事务中（如果开了的话）：


session执行select





这里的细节就是，根据statement唯一标识，获取具体的statement。

这样，Executor就知道要具体做什么事，要执行的statement在哪里了。
接下来，执行Executor的方法：

由于Executor被代理了，这里就会跳转到Plugin中，判断要执行的方法，是否在拦截器链中定义了，决定是否要执行拦截器

我这边，会被分页拦截器拦截住，就执行到了如下代码：



statementHandler创建

如下图，执行configuration的newStatementHandler方法：

可以看到，创建完成后，又会被拦截器链给拦截，检查是否需要创建动态代理。
我们继续看看statementHandler如何创建的：



在上图，在创建PreparedStatementHandler时，先创建父类BaseStatementHandler.
在父类BaseStatementHandler的构造函数的倒数两行，又去创建了：
ParameterHandler/ResultSetHandler点进具体实现后，我们看到：分别创建这两种对象后，又用拦截器链进行了代理（当然，还是会先看看是否匹配拦截器中是否拦截了这些接口）

至此，这几个对象就都创建好了，而且，拦截器目前也仅支持拦截这几种接口：

prepareStatement

接下来继续看下执行流程：

  private Statement prepareStatement(StatementHandler handler, Log statementLog)  {    Statement stmt;    // 获取连接    Connection connection = getConnection(statementLog);    // StatementHandler#prepare，该方法可以被拦截器链拦截    stmt = handler.prepare(connection, transaction.getTimeout());    handler.parameterize(stmt);    return stmt;  }这里会先去获取连接：

这里也会看看是否要对连接进行动态代理，如果需要打印statement的log，就会对connection进行代理：


我们平时看到的mybatis sql日志，就是这里打印的。
我们回到主航线：

这里就会调用jdk中的connection类的prepareStatement方法，传入了原始的预编译sql：

完成statement创建后，再设置下属性：

再后面，就是执行具体的statement了，这块就不讲了：

sql统计拦截器相关代码

原理

至此，我们搞清楚了拦截器的大概逻辑：
拦截器链，会对四大对象进行动态代理：
org.apache.ibatis.executor.Executor
org.apache.ibatis.executor.statement.StatementHandler
org.apache.ibatis.executor.resultset.ResultSetHandler
org.apache.ibatis.executor.parameter.ParameterHandler
动态代理后，会先执行：

像我们的sql统计这个场景，需要获取到具体的sql，我这里选择拦截如下这个方法：
public interface StatementHandler {  Statement prepare(Connection connection, Integer transactionTimeout)      throws SQLException;  ...拦截器代码

import com.xx.util.spring.ApplicationContextUtils;import lombok.extern.slf4j.Slf4j;import org.apache.ibatis.executor.statement.StatementHandler;import org.apache.ibatis.mapping.BoundSql;import org.apache.ibatis.plugin.Interceptor;import org.apache.ibatis.plugin.Intercepts;import org.apache.ibatis.plugin.Invocation;import org.apache.ibatis.plugin.Signature;import org.springframework.beans.BeansException;import java.sql.Connection;import java.util.Objects;@Intercepts(        {                @Signature(                        type = StatementHandler.class,                        method = "prepare",                        args = {                                Connection.class,                                Integer.class                        }                )        })@Slf4jpublic class SqlStatInterceptor implements Interceptor {    private SqlStatService sqlStatService;    private SqlStatProperties sqlStatProperties;    private Boolean init = null;    public SqlStatInterceptor() {        log.info("create sqlStatInterceptor");    }    @Override    public Object intercept(Invocation invocation) throws Throwable {        if (init == null) {            try {                sqlStatService = ApplicationContextUtils.getBean(SqlStatService.class);                sqlStatProperties = ApplicationContextUtils.getBean(SqlStatProperties.class);            } catch (BeansException exception) {                log.warn("no bean of type:SqlStatService or SqlStatProperties");            }            init = true;        }        if (sqlStatService == null) {            return invocation.proceed();        }        if (sqlStatProperties == null) {            return invocation.proceed();        }        boolean enableInterceptorOrNot = Objects.equals(sqlStatProperties.getStartInterceptOrNot(),                true);        if (!enableInterceptorOrNot) {            return invocation.proceed();        }        if (invocation.getTarget() instanceof StatementHandler) {            StatementHandler statementHandler = (StatementHandler) invocation.getTarget();            BoundSql boundSql = statementHandler.getBoundSql();            String sql = boundSql.getSql();            sqlStatService.sqlStat(sql);        }        return invocation.proceed();    }}核心代码就这两行：

这个sqlStatServcie可以自由定义，反正就是一个service，用来存储sql。
sqlStatService

/** * 每次遇到一个sql，就记录到数据库； * 目的是为了方便建索引 */@Service@Slf4jpublic class SqlStatServiceImpl implements SqlStatService {    @Autowired    private SysSqlStatMapper sysSqlStatMapper;    @Autowired    private DataSource dataSource;    @Override    public void sqlStat(String sql) {        // 我这边是存储到db的，表名为sys_sql_stat，这里return是为了避免循环        boolean b = sql.contains("sys_sql_stat");        if (b) {            return;        }        /**         * 没有where的语句一般不用建索引，直接不记录         */        boolean hasWhereClause = sql.contains("where") || sql.contains("WHERE");        if (!hasWhereClause) {            return;        }        try {            String sqlAfterTrim = trimLimitClause(sql);            String md5Hex = MD5Util.md5Hex(sqlAfterTrim);            LocalDateTime now = LocalDateTime.now();            int count = sysSqlStatMapper.updateBySqlHash(now, md5Hex);            if (count == 0) {                saveSqlStat(sqlAfterTrim, md5Hex, now);            }        } catch (Throwable throwable) {            // rawSqlHash为唯一索引，未加锁的情况下，可能重复            log.error("err", throwable);        }    }                private void saveSqlStat(String sql, String md5Hex, LocalDateTime now) {        SysSqlStat sysSqlStat = new SysSqlStat();        sysSqlStat.setRawSql(sql);        sysSqlStat.setRawSqlHash(md5Hex);        sysSqlStat.setCount(1L);        sysSqlStat.setCreatedAt(now);        sysSqlStat.setUpdatedAt(now);        sysSqlStatMapper.insert(sysSqlStat);    }            private static final Pattern PATTERN = Pattern.compile("limit\\s+\\d+,\\d+");    private String trimLimitClause(String sql) {        int index = sql.lastIndexOf("limit");        if (index == -1) {            return sql;        }        String limitClause = sql.substring(index);        Matcher m = PATTERN.matcher(limitClause.trim());        if (m.matches()) {            String newSql = sql.substring(0,index);            return newSql;        }        return sql;    }<dependency>    <groupId>commons-codec</groupId>    <artifactId>commons-codec</artifactId>    <version>1.15</version></dependency>public class MD5Util {    public static String md5Hex(final String data) {        return DigestUtils.md5Hex(data);    }}@Componentpublic final class ApplicationContextUtils implements BeanFactoryPostProcessor{    /**     * Spring应用上下文环境     */    private static ConfigurableListableBeanFactory beanFactory;    @Override    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {        ApplicationContextUtils.beanFactory = beanFactory;    }        public static <T> T getBean(Class<T> requiredType) {        return beanFactory.getBean(requiredType);    }}为什么使用spring工具类呢，因为如果改成autowired注入的话，会导致constructor类型的循环依赖，可以自行试试。
外部装配类、properties类

@ConfigurationProperties(prefix = "sql-stat")@Datapublic class SqlStatProperties {    private Boolean enabled;    private Boolean startInterceptOrNot;}@Configuration@Slf4j@EnableConfigurationProperties(SqlStatProperties.class)@ConditionalOnProperty(value = "sql-stat.enabled", havingValue = "true")public class SqlStatInterceptorConfig {    @Bean    public SqlStatInterceptor sqlStatInterceptor(){        SqlStatInterceptor interceptor = new SqlStatInterceptor();        return interceptor;    }}sql ddl

我这边只有pg版本的（现在改成信创db了，这个db是基于pg改的）
CREATE TABLE sys_sql_stat (        id bigserial NOT NULL, -- id主键        raw_sql varchar NOT NULL, -- 原始sql        raw_sql_hash varchar NOT NULL, -- 对原始sql进行md5这类hash操作，便于计数        count int8 NULL, -- sql的执行次数        created_at timestamp NULL, -- 创建时间        updated_at timestamp NULL, -- 更新时间        CONSTRAINT sys_sql_stat_pk PRIMARY KEY (id))WITH (        orientation=row,        compression=no,        fillfactor=80);CREATE UNIQUE INDEX sys_sql_stat_raw_sql_hash_idx ON sys_sql_stat USING btree (raw_sql_hash) TABLESPACE pg_default;-- Column commentsCOMMENT ON COLUMN sys_sql_stat.id IS 'id主键';COMMENT ON COLUMN sys_sql_stat.raw_sql IS '原始sql';COMMENT ON COLUMN sys_sql_stat.raw_sql_hash IS '对原始sql进行md5这类hash操作，便于计数';COMMENT ON COLUMN sys_sql_stat.count IS 'sql的执行次数';COMMENT ON COLUMN sys_sql_stat.created_at IS '创建时间';COMMENT ON COLUMN sys_sql_stat.updated_at IS '更新时间';查询接口

我还写了个查询接口来按表将这些sql查出来，逆序排序。
    @Autowired    private SysSqlStatMapper sysSqlStatMapper;    @Autowired    private DataSource dataSource;    @Override    public List<SqlStatDto> querySqlStat() {        Connection connection = null;        List<String> tableNames;        try {            connection = dataSource.getConnection();            DatabaseMetaData metaData = connection.getMetaData();            ResultSet resultSet = metaData.getTables(null, "改成自己的schema", null, new String[]{"TABLE"});            tableNames = new ArrayList<>();            while (resultSet.next()) {                tableNames.add(resultSet.getString("TABLE_NAME"));            }        } catch (Throwable throwable) {            throw new RuntimeException(throwable);        }        List<SysSqlStat> sysSqlStats = sysSqlStatMapper.selectList(null);        List<SqlStatDto> list = tableNames.stream().map(tableName -> {            SqlStatDto dto = new SqlStatDto();            dto.setTableName(tableName);            List<SysSqlStat> sqlStatListByTable = sysSqlStats.stream().filter(sqlStat -> {                return sqlStat.getRawSql().contains(tableName);            }).sorted(Comparator.comparing(SysSqlStat::getCount).reversed())                    .collect(Collectors.toList());            List<SqlStatDtoByTable> sqlStatDtoByTableList = sqlStatListByTable.stream().map(item -> {                SqlStatDtoByTable statDtoByTable = new SqlStatDtoByTable();                statDtoByTable.setId(item.getId());                statDtoByTable.setRawSql(item.getRawSql());                statDtoByTable.setRawSqlHash(item.getRawSqlHash());                statDtoByTable.setCount(item.getCount());                statDtoByTable.setCreatedAt(item.getCreatedAt());                statDtoByTable.setUpdatedAt(item.getUpdatedAt());                return statDtoByTable;            }).collect(Collectors.toList());            dto.setList(sqlStatDtoByTableList);            return dto;        }).collect(Collectors.toList());        return list;    }@Data@Schema(description = "")public class SysSqlStat {    /**     * 字典表     */    @Schema(description = "字典表")    private Long id;    /**     * 原始sql     */    @Schema(description = "原始sql")    private String rawSql;    /**     * 对原始sql进行md5这类hash操作，便于计数     */    @Schema(description = "对原始sql进行md5这类hash操作，便于计数")    private String rawSqlHash;    /**     * sql的执行次数     */    @Schema(description = "sql的执行次数")    private Long count;    /**     * 创建时间     */    @Schema(description = "创建时间")    private LocalDateTime createdAt;    /**     * 更新时间     */    @Schema(description = "更新时间")    private LocalDateTime updatedAt;}@Datapublic class SqlStatDtoByTable {    @Schema(description = "字典表")    private Long id;    /**     * 原始sql     */    @Schema(description = "原始sql")    private String rawSql;    /**     * 对原始sql进行md5这类hash操作，便于计数     */    @Schema(description = "对原始sql进行md5这类hash操作，便于计数")    private String rawSqlHash;    /**     * sql的执行次数     */    @Schema(description = "sql的执行次数")    private Long count;    /**     * 创建时间     */    @Schema(description = "创建时间")    private LocalDateTime createdAt;    /**     * 更新时间     */    @Schema(description = "更新时间")    private LocalDateTime updatedAt;}@Datapublic class SqlStatDto {    private String tableName;    private List<SqlStatDtoByTable> list;}总结

这个拦截器就算写完了。写得过程中，也算是梳理了下代码，方便后续查看吧。