Mybatis statistics of the execution time of each SQL statement

@Aspect
@Component
@Slf4j
public class MapperAspect {

  @AfterReturning("execution(* cn.xbmchina.mybatissqltime.mapper.*Mapper.*(..))")
  public void logServiceAccess(JoinPoint joinPoint) {
    log.info("Completed: " + joinPoint);
  }


  /**
   * Monitor all public methods of cn.xbmchina.mybatissqltime.mapper..*Mapper package and its subpackages*/
  @Pointcut("execution(* cn.xbmchina.mybatissqltime.mapper.*Mapper.*(..))")
  private void pointCutMethod() {
  }

  /**
   * Declaration around notification *
   * @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("Calling Mapper method: {}, parameters: {}, execution time: {} nanoseconds, time consumed: {} milliseconds",
        pjp.getSignature().toString(), Arrays.toString(pjp.getArgs()),
        (end - begin), (end - begin) / 1000000);
    return obj;
  }
}

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 execution time recording interceptor*
 * @author zero
 * December 13, 2019 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);

  /**
   * Maximum length of the printed parameter string */
  private final static int MAX_PARAM_LENGTH = 50;

  /**
   * Maximum SQL length of the record */
  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();

      // Format the SQL statement, remove line breaks, and replace parameters sql = formatSQL(sql, parameterObject, parameterMappingList);

      logger.info("Execute SQL: [, {}] Execution time [{} ms]", sql, timeCount);
    }
  }


  /**
   * Format/beautify SQL statements*
   * @param sql sql statement * @param parameterObject parameter Map
   * @param parameterMappingList parameter List
   * @return formatted SQL
   */
  private String formatSQL(String sql, Object parameterObject, List<ParameterMapping> parameterMappingList) {
    // Input sql string empty judgment if (sql == null || sql.length() == 0) {
      return "";
    }
    // Beautify sql
    sql = beautifySql(sql);
    // In the scenario where no parameters are passed, just beautify the SQL and return it if (parameterObject == null || parameterMappingList == null || parameterMappingList.size() == 0) {
      return sql;
    }
    return LimitSQLLength(sql);
  }


  /**
   * Returns the SQL statement after the length limit*
   *
   * @param sql original SQL statement*/
  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) {

  }




  /**
   * Replace the value corresponding to ? in SQL, only keep the first 50 characters*
   * @param sql sql statement* @param valueOf ? corresponding value*/
  private String replaceValue(String sql, String valueOf) {
    //If there are more than 50 characters, only take the first 50 if (valueOf != null && valueOf.length() > MAX_PARAM_LENGTH) {
      valueOf = valueOf.substring(0, MAX_PARAM_LENGTH);
    }
    sql = sql.replaceFirst("\\?", valueOf);
    return sql;
  }

  /**
   * Beautify SQL
   *
   * @param sql sql statement */
  private String beautifySql(String sql) {
    sql = sql.replaceAll("[\\s\n ]+", " ");
    return sql;
  }
 }

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 and before used com.mysql.jdbc.Driver
    Username: root
    password: root
    platform:mysql
    #Through this configuration, the druid connection pool is introduced into our configuration. Spring will try its best to determine the type and then match the driver class according to the situation.
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5 # Initialization sizemin-idle: 5 # Minimummax-active: 100 # Maximummax-wait: 60000 # Configure the timeout for waiting to get the connectiontime-between-eviction-runs-millis: 60000 # Configure the interval for checking and detecting idle connections that need to be closed, in millisecondsmin-evictable-idle-time-millis: 300000 # Specify the minimum idle time for an idle connection to be cleared, in millisecondsvalidationQuery: select 'x'
      test-while-idle: true # Whether to perform a connection test when the connection is idletest-on-borrow: false # Whether to test the connection when borrowing a connection from the connection pooltest-on-return: false # Whether to test the connection when it is returned to the connection poolfilters: config,wall,stat # Configure filters for monitoring statistics interception. After removing them, the monitoring interface sql cannot be counted. 'wall' is used for firewallpoolPreparedStatements: true # Turn on PSCache and specify the size of PSCache on each connectionmaxPoolPreparedStatementPerConnectionSize: 20
      maxOpenPreparedStatements: 20
      # Enable mergeSql function through connectProperties property; slow SQL record connectionProperties: druid.stat.slowSqlMillis=200;druid.stat.logSlowSql=true;config.decrypt=false
       #Merge monitoring data from multiple DruidDataSources#use-global-data-source-stat: true
      # WebStatFilter configuration, for instructions, please refer to Druid Wiki, Configuration_Configure WebStatFilter
      web-stat-filter:
        enabled: true #Whether to enable StatFilter. The default value is true.
        url-pattern: /*
        exclusions: /druid/*,*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico
        session-stat-enable: true
        session-stat-max-count: 10
      #StatViewServlet configuration, please refer to Druid Wiki for instructions, configure_StatViewServletConfigure stat-view-servlet:
        enabled: true #Whether to enable StatViewServlet. The default value is true.
        url-pattern: /druid/*
        reset-enable: true
        login-username: admin
        login-password: admin