mybatis统计每条SQL的执行时间的方法示例

背景

最近面试经常被问到关于数据库的事务的问题，可能平时我就知道加个注解@transactional之后就一脸懵逼的。现在发现这一块真的是常常被忽略了，然而面试官就是最喜欢这种看是不常用，但是非常重要的问题，进而达到出其不意攻其不备。不吹水了，开始正文。

方案一：切面编程@aspect

此方案主要是通过环绕切面的方式将mapper包下的接口方法，然后前后计算时间差即可。这就是典型的aop知识，不过这种计算比较粗糙，但是也是个办法。具体方法如下：

@aspect
@component
@slf4j
public class mapperaspect {

  @afterreturning("execution(* cn.xbmchina.mybatissqltime.mapper.*mapper.*(..))")
  public void logserviceaccess(joinpoint joinpoint) {
    log.info("completed: " + joinpoint);
  }


  /**
   * 监控cn.xbmchina.mybatissqltime.mapper..*mapper包及其子包的所有public方法
   */
  @pointcut("execution(* cn.xbmchina.mybatissqltime.mapper.*mapper.*(..))")
  private void pointcutmethod() {
  }

  /**
   * 声明环绕通知
   *
   * @param pjp
   * @return
   * @throws throwable
   */
  @around("pointcutmethod()")
  public object doaround(proceedingjoinpoint pjp) throws throwable {
    long begin = system.nanotime();
    object obj = pjp.proceed();
    long end = system.nanotime();

    log.info("调用mapper方法：{}，参数：{}，执行耗时：{}纳秒，耗时：{}毫秒",
        pjp.getsignature().tostring(), arrays.tostring(pjp.getargs()),
        (end - begin), (end - begin) / 1000000);
    return obj;
  }
}

方案二：mybatis 的插件

mybatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。

mybatis 允许在已映射语句执行过程中的某一点进行拦截调用。

默认情况下，mybatis 允许使用插件来拦截的方法调用包括：

①executor(update, query, flushstatements, commit, rollback, gettransaction, close, isclosed)
②parameterhandler(getparameterobject, setparameters)
③resultsethandler(handleresultsets, handleoutputparameters)
④statementhandler(prepare, parameterize, batch, update, query)

下面是代码:

import org.apache.ibatis.executor.statement.statementhandler;
import org.apache.ibatis.mapping.boundsql;
import org.apache.ibatis.mapping.parametermapping;
import org.apache.ibatis.plugin.interceptor;
import org.apache.ibatis.plugin.intercepts;
import org.apache.ibatis.plugin.invocation;
import org.apache.ibatis.plugin.plugin;
import org.apache.ibatis.plugin.signature;
import org.apache.ibatis.session.resulthandler;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;

import java.sql.statement;
import java.util.list;
import java.util.properties;

/**
 * sql执行时间记录拦截器
 *
 * @author zero
 * 2019年12月13日17:05:28
 */
@intercepts({@signature(type = statementhandler.class, method = "query", args = {statement.class, resulthandler.class}),
    @signature(type = statementhandler.class, method = "update", args = {statement.class}),
    @signature(type = statementhandler.class, method = "batch", args = {statement.class})})
@component
public class sqlexecutetimecountinterceptor implements interceptor {

  private static logger logger = loggerfactory.getlogger(sqlexecutetimecountinterceptor.class);

  /**
   * 打印的参数字符串的最大长度
   */
  private final static int max_param_length = 50;

  /**
   * 记录的最大sql长度
   */
  private final static int max_sql_length = 200;


  @override
  public object intercept(invocation invocation) throws throwable {
    object target = invocation.gettarget();
    long starttime = system.currenttimemillis();
    statementhandler statementhandler = (statementhandler) target;
    try {
      return invocation.proceed();
    } finally {
      long endtime = system.currenttimemillis();
      long timecount = endtime - starttime;

      boundsql boundsql = statementhandler.getboundsql();
      string sql = boundsql.getsql();
      object parameterobject = boundsql.getparameterobject();
      list<parametermapping> parametermappinglist = boundsql.getparametermappings();

      // 格式化sql语句，去除换行符，替换参数
      sql = formatsql(sql, parameterobject, parametermappinglist);

      logger.info("执行 sql：[ , {} ]执行耗时[ {} ms]", sql, timecount);
    }
  }


  /**
   * 格式化/美化 sql语句
   *
   * @param sql         sql 语句
   * @param parameterobject   参数的map
   * @param parametermappinglist 参数的list
   * @return 格式化之后的sql
   */
  private string formatsql(string sql, object parameterobject, list<parametermapping> parametermappinglist) {
    // 输入sql字符串空判断
    if (sql == null || sql.length() == 0) {
      return "";
    }
    // 美化sql
    sql = beautifysql(sql);
    // 不传参数的场景，直接把sql美化一下返回出去
    if (parameterobject == null || parametermappinglist == null || parametermappinglist.size() == 0) {
      return sql;
    }
    return limitsqllength(sql);
  }


  /**
   * 返回限制长度之后的sql语句
   *
   *
   * @param sql 原始sql语句
   */
  private string limitsqllength(string sql) {
    if (sql == null || sql.length() == 0) {
      return "";
    }
    if (sql.length() > max_sql_length) {
      return sql.substring(0, max_sql_length);
    } else {
      return sql;
    }
  }


  @override
  public object plugin(object target) {
    return plugin.wrap(target, this);
  }

  @override
  public void setproperties(properties properties) {

  }




  /**
   * 替换sql 中? 所对应的值, 只保留前50个字符
   *
   * @param sql   sql语句
   * @param valueof ?对应的值
   */
  private string replacevalue(string sql, string valueof) {
    //超过50个字符只取前50个
    if (valueof != null && valueof.length() > max_param_length) {
      valueof = valueof.substring(0, max_param_length);
    }
    sql = sql.replacefirst("\\?", valueof);
    return sql;
  }

  /**
   * 美化sql
   *
   * @param sql sql语句
   */
  private string beautifysql(string sql) {
    sql = sql.replaceall("[\\s\n ]+", " ");
    return sql;
  }
 }

方案三：直接用druid

这种就是我们平时用的最多的，但是面试的话说一下就得了，估计也没有怎么好问的了。

springboot+druid的配置application.yml文件如下：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/testdb1?characterencoding=utf-8&useunicode=true&usessl=false&servertimezone=utc
    driver-class-name: com.mysql.jdbc.driver # mysql8.0以前使用com.mysql.jdbc.driver
    username: root
    password: root
    platform: mysql
    #通过这句配置将druid连接池引入到我们的配置中，spring会尽可能判断类型是什么，然后根据情况去匹配驱动类。
    type: com.alibaba.druid.pool.druiddatasource
    druid:
      initial-size: 5 # 初始化大小
      min-idle: 5 # 最小
      max-active: 100 # 最大
      max-wait: 60000 # 配置获取连接等待超时的时间
      time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      min-evictable-idle-time-millis: 300000 # 指定一个空闲连接最少空闲多久后可被清除，单位是毫秒
      validationquery: select 'x'
      test-while-idle: true # 当连接空闲时，是否执行连接测试
      test-on-borrow: false # 当从连接池借用连接时，是否测试该连接
      test-on-return: false # 在连接归还到连接池时是否测试该连接
      filters: config,wall,stat # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      poolpreparedstatements: true # 打开pscache，并且指定每个连接上pscache的大小
      maxpoolpreparedstatementperconnectionsize: 20
      maxopenpreparedstatements: 20
      # 通过connectproperties属性来打开mergesql功能；慢sql记录
      connectionproperties: druid.stat.slowsqlmillis=200;druid.stat.logslowsql=true;config.decrypt=false
       # 合并多个druiddatasource的监控数据
      #use-global-data-source-stat: true
      #webstatfilter配置，说明请参考druid wiki，配置_配置webstatfilter
      web-stat-filter:
        enabled: true #是否启用statfilter默认值true
        url-pattern: /*
        exclusions: /druid/*,*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico
        session-stat-enable: true
        session-stat-max-count: 10
      #statviewservlet配置，说明请参考druid wiki，配置_statviewservlet配置
      stat-view-servlet:
        enabled: true #是否启用statviewservlet默认值true
        url-pattern: /druid/*
        reset-enable: true
        login-username: admin
        login-password: admin

总结

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。