背景

上一篇中讲述了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
                        }
                )
        }
)
@Slf4j
public 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
@Slf4j
public 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);
    }
}

@Component
public 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")
@Data
public 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 comments

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


}

@Data
public 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;
}

@Data
public class SqlStatDto {
    private String tableName;

    private List<SqlStatDtoByTable> list;

}

总结

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