使用MyBatisMyBatis Plus实现SQL日记打印与执行监控

使用MyBatis/MyBatis Plus实现SQL日记打印与执行监控

一、配景与代价

在开发过程中，SQL日记的完整输出对于调试和性能优化至关紧张。MyBatis默认的日记输出仅显示带占位符的SQL语句，无法直接看到现实参数值，且缺乏执行时间统计。本文将介绍两种实现方案：

• 原生配置方案：通过日记框架直接输出基础SQL日记
  
• 增强方案：使用MyBatis拦截器实现完整SQL打印和执行监控
  

二、原生配置方案（快速上手）

1. 日记框架配置（以Logback为例）

1. <!-- logback-spring.xml -->
2. <configuration>
3.     <logger name="com.zaxxer.hikari" level="INFO"/>
4.     <logger name="java.sql.Connection" level="INFO"/>
5.     <logger name="java.sql.Statement" level="DEBUG"/>
6.     <logger name="java.sql.PreparedStatement" level="DEBUG"/>
7. </configuration>

复制代码

2. 输出示例

1. DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE name = ?
2. DEBUG [main] - ==> Parameters: John(String)

复制代码

3. 局限性

• 参数值单独显示，无法直接拼接完整SQL
  
• 缺乏执行耗时统计
  
• 动态SQL处理不敷直观
  

三、增强方案：自界说拦截器实现

1. SQL美化与参数更换

1. public class MybatisPlusAllSqlLog implements InnerInterceptor {
2.     public static final Logger log = LoggerFactory.getLogger("sys-sql");
4.     @Override
5.     public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
6.         logInfo(boundSql, ms, parameter);
7.     }
9.     @Override
10.     public void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {
11.         BoundSql boundSql = ms.getBoundSql(parameter);
12.         logInfo(boundSql, ms, parameter);
13.     }
15.     private static void logInfo(BoundSql boundSql, MappedStatement ms, Object parameter) {
16.         try {
17.             log.info("parameter = " + parameter);
18.             // 获取到节点的id,即sql语句的id
19.             String sqlId = ms.getId();
20.             log.info("sqlId = " + sqlId);
21.             // 获取节点的配置
22.             Configuration configuration = ms.getConfiguration();
23.             // 获取到最终的sql语句
24.             String sql = getSql(configuration, boundSql, sqlId);
25.             log.info("完整的sql:{}", sql);
26.         } catch (Exception e) {
27.             log.error("异常:{}", e.getLocalizedMessage(), e);
28.         }
29.     }
31.     // 封装了一下sql语句，使得结果返回完整xml路径下的sql语句节点id + sql语句
32.     public static String getSql(Configuration configuration, BoundSql boundSql, String sqlId) {
33.         return sqlId + ":" + showSql(configuration, boundSql);
34.     }
36.     // 进行？的替换
37.     public static String showSql(Configuration configuration, BoundSql boundSql) {
38.         // 获取参数
39.         Object parameterObject = boundSql.getParameterObject();
40.         List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
41.         // sql语句中多个空格都用一个空格代替
42.         String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
43.         if (!CollectionUtils.isEmpty(parameterMappings) && parameterObject != null) {
44.             // 获取类型处理器注册器，类型处理器的功能是进行java类型和数据库类型的转换
45.             TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
46.             // 如果根据parameterObject.getClass(）可以找到对应的类型，则替换
47.             if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
48.                 sql = sql.replaceFirst("\\?",
49.                         Matcher.quoteReplacement(getParameterValue(parameterObject)));
50.             } else {
51.                 // MetaObject主要是封装了originalObject对象，提供了get和set的方法用于获取和设置originalObject的属性值,主要支持对JavaBean、Collection、Map三种类型对象的操作
52.                 MetaObject metaObject = configuration.newMetaObject(parameterObject);
53.                 for (ParameterMapping parameterMapping : parameterMappings) {
54.                     String propertyName = parameterMapping.getProperty();
55.                     if (metaObject.hasGetter(propertyName)) {
56.                         Object obj = metaObject.getValue(propertyName);
57.                         sql = sql.replaceFirst("\\?",
58.                                 Matcher.quoteReplacement(getParameterValue(obj)));
59.                     } else if (boundSql.hasAdditionalParameter(propertyName)) {
60.                         // 该分支是动态sql
61.                         Object obj = boundSql.getAdditionalParameter(propertyName);
62.                         sql = sql.replaceFirst("\\?",
63.                                 Matcher.quoteReplacement(getParameterValue(obj)));
64.                     } else {
65.                         // 打印出缺失，提醒该参数缺失并防止错位
66.                         sql = sql.replaceFirst("\\?", "缺失");
67.                     }
68.                 }
69.             }
70.         }
71.         return sql;
72.     }
74.     // 如果参数是String，则添加单引号， 如果是日期，则转换为时间格式器并加单引号； 对参数是null和不是null的情况作了处理
75.     private static String getParameterValue(Object obj) {
76.         String value;
77.         if (obj instanceof String) {
78.             value = "'" + obj.toString() + "'";
79.         } else if (obj instanceof Date) {
80.             DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT,
81.                     DateFormat.DEFAULT, Locale.CHINA);
82.             value = "'" + formatter.format(new Date()) + "'";
83.         } else {
84.             if (obj != null) {
85.                 value = obj.toString();
86.             } else {
87.                 value = "";
88.             }
89.         }
90.         return value;
91.     }
93. }

复制代码

2. 执行耗时监控

1. @Intercepts({
2.         @Signature(type = Executor.class, method = "update", args = {MappedStatement.class,
3.                 Object.class}),
4.         @Signature(type = Executor.class, method = "query", args = {MappedStatement.class,
5.                 Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})})
6. public class SqlStatementInterceptor implements Interceptor {
8.     public static final Logger log = LoggerFactory.getLogger("sys-sql");
10.     @Override
11.     public Object intercept(Invocation invocation) throws Throwable {
12.         long startTime = System.currentTimeMillis();
13.         try {
14.             return invocation.proceed();
15.         } finally {
16.             long timeConsuming = System.currentTimeMillis() - startTime;
17.             log.info("执行SQL:{}ms", timeConsuming);
18.             if (timeConsuming > 999 && timeConsuming < 5000) {
19.                 log.info("执行SQL大于1s:{}ms", timeConsuming);
20.             } else if (timeConsuming >= 5000 && timeConsuming < 10000) {
21.                 log.info("执行SQL大于5s:{}ms", timeConsuming);
22.             } else if (timeConsuming >= 10000) {
23.                 log.info("执行SQL大于10s:{}ms", timeConsuming);
24.             }
25.         }
26.     }
28.     @Override
29.     public Object plugin(Object target) {
30.         return Plugin.wrap(target, this);
31.     }
33.     @Override
34.     public void setProperties(Properties properties) {
36.     }
37. }

复制代码

自界说拦截器之后，请注意配置该拦截器
3.输出示例

1. INFO  [http-nio-8080-exec-1] - SQLID: com.example.mapper.UserMapper.selectById
2. INFO  [http-nio-8080-exec-1] - 完整SQL: SELECT id,name,age FROM user WHERE id=1
3. INFO  [http-nio-8080-exec-1] - 执行耗时: 48ms
4. WARN  [http-nio-8080-exec-1] - 慢SQL警告: 执行耗时1204ms

复制代码

四.总结

通过合理配置SQL日记输出，开发者可以：

• 快速定位SQL执行题目
  
• 直观分析现实执行的SQL语句
  
• 有效识别性能瓶颈
  
• 提拔动态SQL调试效率
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。