一、基础知识

**
 * @author wl
 * @description 单据生命流程日志
 * @date 2019/10/9 21:06
 */
@Data
public class PayLifeLog implements Serializable {

    /**
     * 日志主键编码
     */
    private Integer logId;
    /**
     * 单据包编码
     */
    private String packageId;
    /**
     * 单据编码
     */
    private String billCode;
    /**
     * 节点执行结果
     */
    private Byte lifeStatus;
    /**
     * 节点
     */
    private Byte lifeState;
    /**
     * 备注
     */
    private String markMsg;
    /**
     * 更新时间
     */
    private LocalDateTime updatetime;
   }

package com.trace.base.tool.mybatis.study.plugin;

import com.mysql.jdbc.PreparedStatement;
import com.trace.base.tool.logging.BaseLog;
import com.trace.base.tool.logging.Channel;
import com.trace.base.tool.logging.LevelEnum;
import com.trace.base.tool.mybatis.monitor.SlowSqlEnum;
import com.trace.base.tool.mybatis.monitor.SlowSqlLog;
import com.trace.base.tool.util.LocalDateTimeUtil;
import com.zaxxer.hikari.pool.ProxyStatement;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.logging.jdbc.PreparedStatementLogger;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.postgresql.jdbc.PgStatement;

import java.lang.reflect.Field;
import java.lang.reflect.Proxy;
import java.sql.Statement;
import java.util.Properties;

/**
 * 监控慢SQL插件
 *
 * @author wl
 */
@Intercepts({
        @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}),
        @Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class})
})
public class SlowSqlMonitorPlugin implements Interceptor {
    public static final String SLOW_SQL_ENABLE = "sql.slow.enable";
    private static boolean POSTGRESQL_DRIVER_AVAILABLE;
    private static boolean MYSQL_DRIVER_AVAILABLE;
    private static boolean HIKARICP_AVAILABLE;
    private static Field DELEGATE_FIELD;

    static {
        try {
            Class.forName("org.postgresql.jdbc.PgPreparedStatement");
            POSTGRESQL_DRIVER_AVAILABLE = true;
        } catch (ClassNotFoundException e) {
            // ignore
            POSTGRESQL_DRIVER_AVAILABLE = false;
        }
        try {
            Class.forName("com.mysql.jdbc.PreparedStatement");
            MYSQL_DRIVER_AVAILABLE = true;
        } catch (ClassNotFoundException e) {
            // ignore
            MYSQL_DRIVER_AVAILABLE = false;
        }
        try {
            Class.forName("com.zaxxer.hikari.pool.HikariProxyPreparedStatement");
            DELEGATE_FIELD = ProxyStatement.class.getDeclaredField("delegate");
            DELEGATE_FIELD.setAccessible(true);
            HIKARICP_AVAILABLE = true;
        } catch (ClassNotFoundException | NoSuchFieldException e) {
            // ignore
            HIKARICP_AVAILABLE = false;
        }
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            Object obj = invocation.proceed();
            return obj;
        } finally {
            long end = System.currentTimeMillis();
            long used = end - start;
            // >= 1s
            final long max = 1000L;
            if (used >= max) {
                try {
                    Object target = invocation.getTarget();
                    String sql = "unknown";
                    if (target instanceof StatementHandler) {
                        sql = ((StatementHandler) target).getBoundSql().getSql();
                    }
                    // 外部提前做一次猜测是否为预处理语句,只用instanceof PreparedStatement有可能没有?,这种情况不需要执行下面逻辑
                    boolean mightPreparedSql = sql.contains("?");
                    Object statementArg = invocation.getArgs()[0];
                    // 可能是预处理语句才处理
                    if (mightPreparedSql) {
                        // 这里还要区分是否为debug模式,debug模式下,生成的connection和statement都是被mybatis logger类代理
                        if (Proxy.isProxyClass(statementArg.getClass())) {
                            // 获取到真实被代理的statement
                            statementArg = ((PreparedStatementLogger) Proxy.getInvocationHandler(statementArg)).getPreparedStatement();
                        }
                        // 被HikariProxyPreparedStatement代理，通过反射才能获取到真实的PreparedStatement
                        if (HIKARICP_AVAILABLE && statementArg instanceof ProxyStatement) {
                            java.sql.PreparedStatement preparedStatement = (java.sql.PreparedStatement) DELEGATE_FIELD.get(statementArg);
                            // postgresql,前提是SQL为预处理语句,避免非预处理语句也执行了toString()造成拿到内存地址
                            if (POSTGRESQL_DRIVER_AVAILABLE && preparedStatement instanceof PgStatement) {
                                // 因为PgPreparedStatement是保护类,只能使用PgStatement转换,实际是执行子类的toString()
                                sql = preparedStatement.toString();
                            }
                            // mysql
                            else if (MYSQL_DRIVER_AVAILABLE && preparedStatement instanceof PreparedStatement) {
                                sql = ((PreparedStatement) preparedStatement).asSql();
                            }
                        }

                    }
                    // 记录日志信息
                    SlowSqlLog slowSqlLog = new SlowSqlLog();
                    slowSqlLog.setTraceId("idnum-0001");
                    slowSqlLog.setType(SlowSqlEnum.DML);
                    slowSqlLog.setMessage("执行DML[" + sql + "]超时1秒");
                    slowSqlLog.setStart(LocalDateTimeUtil.formatMilliPlus8(start));
                    slowSqlLog.setEnd(LocalDateTimeUtil.formatMilliPlus8(end));
                    slowSqlLog.setUsed(used);
                    BaseLog<SlowSqlLog> baseLog = new BaseLog<>();
                    baseLog.setContext(slowSqlLog);
                    baseLog.setLevel(LevelEnum.WARNING.getLevel());
                    baseLog.setLevelName(LevelEnum.WARNING.getLevelName());
                    baseLog.setChannel(Channel.SYSTEM);
                    baseLog.setMessage("slowsql log");
                    baseLog.setDatetime(LocalDateTimeUtil.getMicroSecondFormattedNow());
                    String sqlLog=slowSqlLog.toString();
                    // todo 记录日志信息
                } catch (Throwable ex) {
                    // ignore
                }
            }
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
    }
}

package com.trace.base.tool.mybatis.study;


import com.trace.base.tool.mybatis.monitor.MonitorSpringManagedTransactionFactory;
import com.trace.base.tool.mybatis.study.plugin.PagePlugin;
import com.trace.base.tool.mybatis.study.plugin.SlowSqlMonitorPlugin;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.AutoMappingBehavior;
import org.apache.ibatis.session.Configuration;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;


/**
 * 自定义的sqlSessionFactoryBean
 *
 * @author wl
 * @date 2021-3-9
 */
public class StudySqlSessionFactoryBean extends SqlSessionFactoryBean implements EnvironmentAware {
    private Interceptor[] plugins;
    public static Configuration CONFIGURATION;
    private boolean slowSqlEnabled = false;

    public StudySqlSessionFactoryBean() {
        this(null);
    }

    public StudySqlSessionFactoryBean(Configuration configuration) {
        super();
        if (configuration == null) {
            configuration = new Configuration();
            configuration.setMapUnderscoreToCamelCase(true);
            configuration.setAutoMappingBehavior(AutoMappingBehavior.FULL);
        }
        CONFIGURATION = configuration;
        setConfiguration(configuration);
    }

    @Override
    public void setPlugins(Interceptor[] plugins) {
        this.plugins = plugins;
    }

    /**
     * 真实执行设置插件,setPlugins只用于记录客户端自定义的plugin,便于后续拷贝
     */
    private void actualSetPlugins() {
        if (slowSqlEnabled) {
            // 使用自定义监控功能的事务管理器工厂类
            setTransactionFactory(new MonitorSpringManagedTransactionFactory());
            this.plugins = ArrayUtils.add(plugins == null ? new Interceptor[0] : plugins, new SlowSqlMonitorPlugin());
        }
        super.setPlugins(plugins);
    }

    @Override
    public void setEnvironment(Environment environment) {
        slowSqlEnabled = environment.getProperty(SlowSqlMonitorPlugin.SLOW_SQL_ENABLE, boolean.class, true);
        actualSetPlugins();
    }
}