格式化打印mybatis的SQL语句

最新推荐文章于 2024-05-13 02:22:52 发布
最新推荐文章于 2024-05-13 02:22:52 发布
阅读量4.3k 收藏 1
点赞数 2
分类专栏： logback
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuayi3136/article/details/92078366
版权

痛点：默认的mybatis打印的SQL语句格式不带参数，使用占位符代替，有==》等多余字符，不可定制。影响阅读（个人觉得）。

解决：打印的mybatis的SQL语句根个人在图形化工具中写的一样。可自定义输出的格式。

先介绍一下我的环境，传统的SSM项目、日志打印使用的logback。

格式化mybatis打印SQL语句步骤：

1、导入jar包   通过maven的形式添加依赖

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.7.0</version>
</dependency>

2、编写配置p6spy的配置文件：spy.properties

logMessageFormat：指向的是自己定义的日志格式类，下面有我的一个使用案例，可以参考使用

其他配置使用默认就好，具体配置的含义文末附上，或可以参考给出的参考文章

reloadproperties=true
appender=com.p6spy.engine.spy.appender.Slf4JLogger
#P6SpyLogger \u7C7B\u5168\u8DEF\u5F84\u540D
logMessageFormat=com.ciitc.utils.P6SpyLogger
databaseDialectDateFormat=yyyy-MM-dd hh:mm:ss
excludecategories=info,debug,result,resultset

3、在配置数据源的配置文件中添加：

bean：数据源对象的id

id：其他需要使用数据源时使用此ID  感觉就是p6spy将数据源进行了包装

<bean id="dataSource" class="com.p6spy.engine.spy.P6DataSource">
    	<constructor-arg>
			<ref bean="dataSourceDefault"/>    	
    	</constructor-arg>
</bean>

4、创建属于自己的日志格式类：可参考使用

此类就是填补第二点需要自定义日志格式的类的坑

MySQLFormatter：自定义的格式SQL语句的类，其实是借鉴另一篇文章从hibernate中抽取出来的类（hibernate用来格式化日志的类），随后附上

package com.ciitc.utils;

import com.p6spy.engine.spy.appender.MessageFormattingStrategy;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * p6spy打印日志输出格式修改 1.只打印最终执行的sql. 2.sql换到下一行 3.结尾处增加分号,以标示sql结尾 Created by
 * odelia on 2016/1/4.
 */
public class P6SpyLogger implements MessageFormattingStrategy {
	private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

	public String formatMessage(int connectionId, String now, long elapsed, String category, String prepared,
			String sql) {
		if (!sql.trim().equals("")) {
			return format.format(new Date()) + " | took " + elapsed + "ms | " + category + " | connection "
					+ connectionId + new MySQLFormatter().format(sql) + ";";
			
		}
		return "";
	}
}

5、MySQLFormatter：格式化SQL的类

package com.ciitc.utils;
 
import java.util.HashSet;  
import java.util.LinkedList;  
import java.util.Set;  
import java.util.StringTokenizer;  

/**
 * 
 * sql格式化工具(从hibernate中弄出来的)
 */
public class MySQLFormatter {  
  
    private static final Set<String> BEGIN_CLAUSES = new HashSet<String>();  
    private static final Set<String> END_CLAUSES = new HashSet<String>();  
    private static final Set<String> LOGICAL = new HashSet<String>();  
    private static final Set<String> QUANTIFIERS = new HashSet<String>();  
    private static final Set<String> DML = new HashSet<String>();  
    private static final Set<String> MISC = new HashSet<String>();  
    public static final String WHITESPACE = " \n\r\f\t";  
    static {  
        BEGIN_CLAUSES.add( "left" );  
        BEGIN_CLAUSES.add( "right" );  
        BEGIN_CLAUSES.add( "inner" );  
        BEGIN_CLAUSES.add( "outer" );  
        BEGIN_CLAUSES.add( "group" );  
        BEGIN_CLAUSES.add( "order" );  
  
        END_CLAUSES.add( "where" );  
        END_CLAUSES.add( "set" );  
        END_CLAUSES.add( "having" );  
        END_CLAUSES.add( "join" );  
        END_CLAUSES.add( "from" );  
        END_CLAUSES.add( "by" );  
        END_CLAUSES.add( "join" );  
        END_CLAUSES.add( "into" );  
        END_CLAUSES.add( "union" );  
  
        LOGICAL.add( "and" );  
        LOGICAL.add( "or" );  
        LOGICAL.add( "when" );  
        LOGICAL.add( "else" );  
        LOGICAL.add( "end" );  
  
        QUANTIFIERS.add( "in" );  
        QUANTIFIERS.add( "all" );  
        QUANTIFIERS.add( "exists" );  
        QUANTIFIERS.add( "some" );  
        QUANTIFIERS.add( "any" );  
  
        DML.add( "insert" );  
        DML.add( "update" );  
        DML.add( "delete" );  
  
        MISC.add( "select" );  
        MISC.add( "on" );  
    }  
  
    static final String indentString = "    ";  
    static final String initial = "\n    ";  
  
    public String format(String source) {  
        return new FormatProcess( source ).perform();  
    }  
  
    private static class FormatProcess {  
        boolean beginLine = true;  
        boolean afterBeginBeforeEnd = false;  
        boolean afterByOrSetOrFromOrSelect = false;  
        boolean afterValues = false;  
        boolean afterOn = false;  
        boolean afterBetween = false;  
        boolean afterInsert = false;  
        int inFunction = 0;  
        int parensSinceSelect = 0;  
        private LinkedList<Integer> parenCounts = new LinkedList<Integer>();  
        private LinkedList<Boolean> afterByOrFromOrSelects = new LinkedList<Boolean>();  
  
        int indent = 1;  
  
        StringBuilder result = new StringBuilder();  
        StringTokenizer tokens;  
        String lastToken;  
        String token;  
        String lcToken;  
  
        public FormatProcess(String sql) {  
            tokens = new StringTokenizer(  
                    sql,  
                    "()+*/-=<>'`\"[]," + WHITESPACE,  
                    true  
            );  
        }  
  
        public String perform() {  
  
            result.append( initial );  
  
            while ( tokens.hasMoreTokens() ) {  
                token = tokens.nextToken();  
                lcToken = token.toLowerCase();  
  
                if ( "'".equals( token ) ) {  
                    String t;  
                    do {  
                        t = tokens.nextToken();  
                        token += t;  
                    }  
                    while ( !"'".equals( t ) && tokens.hasMoreTokens() ); // cannot handle single quotes  
                }  
                else if ( "\"".equals( token ) ) {  
                    String t;  
                    do {  
                        t = tokens.nextToken();  
                        token += t;  
                    }  
                    while ( !"\"".equals( t ) );  
                }  
  
                if ( afterByOrSetOrFromOrSelect && ",".equals( token ) ) {  
                    commaAfterByOrFromOrSelect();  
                }  
                else if ( afterOn && ",".equals( token ) ) {  
                    commaAfterOn();  
                }  
  
                else if ( "(".equals( token ) ) {  
                    openParen();  
                }  
                else if ( ")".equals( token ) ) {  
                    closeParen();  
                }  
  
                else if ( BEGIN_CLAUSES.contains( lcToken ) ) {  
                    beginNewClause();  
                }  
  
                else if ( END_CLAUSES.contains( lcToken ) ) {  
                    endNewClause();  
                }  
  
                else if ( "select".equals( lcToken ) ) {  
                    select();  
                }  
  
                else if ( DML.contains( lcToken ) ) {  
                    updateOrInsertOrDelete();  
                }  
  
                else if ( "values".equals( lcToken ) ) {  
                    values();  
                }  
  
                else if ( "on".equals( lcToken ) ) {  
                    on();  
                }  
  
                else if ( afterBetween && lcToken.equals( "and" ) ) {  
                    misc();  
                    afterBetween = false;  
                }  
  
                else if ( LOGICAL.contains( lcToken ) ) {  
                    logical();  
                }  
  
                else if ( isWhitespace( token ) ) {  
                    white();  
                }  
  
                else {  
                    misc();  
                }  
  
                if ( !isWhitespace( token ) ) {  
                    lastToken = lcToken;  
                }  
  
            }  
            return result.toString();  
        }  
  
        private void commaAfterOn() {  
            out();  
            indent--;  
            newline();  
            afterOn = false;  
            afterByOrSetOrFromOrSelect = true;  
        }  
  
        private void commaAfterByOrFromOrSelect() {  
            out();  
            newline();  
        }  
  
        private void logical() {  
            if ( "end".equals( lcToken ) ) {  
                indent--;  
            }  
            newline();  
            out();  
            beginLine = false;  
        }  
  
        private void on() {  
            indent++;  
            afterOn = true;  
            newline();  
            out();  
            beginLine = false;  
        }  
  
        private void misc() {  
            out();  
            if ( "between".equals( lcToken ) ) {  
                afterBetween = true;  
            }  
            if ( afterInsert ) {  
                newline();  
                afterInsert = false;  
            }  
            else {  
                beginLine = false;  
                if ( "case".equals( lcToken ) ) {  
                    indent++;  
                }  
            }  
        }  
  
        private void white() {  
            if ( !beginLine ) {  
                result.append( " " );  
            }  
        }  
  
        private void updateOrInsertOrDelete() {  
            out();  
            indent++;  
            beginLine = false;  
            if ( "update".equals( lcToken ) ) {  
                newline();  
            }  
            if ( "insert".equals( lcToken ) ) {  
                afterInsert = true;  
            }  
        }  
  
        @SuppressWarnings( {"UnnecessaryBoxing"})  
        private void select() {  
            out();  
            indent++;  
            newline();  
            parenCounts.addLast( Integer.valueOf( parensSinceSelect ) );  
            afterByOrFromOrSelects.addLast( Boolean.valueOf( afterByOrSetOrFromOrSelect ) );  
            parensSinceSelect = 0;  
            afterByOrSetOrFromOrSelect = true;  
        }  
  
        private void out() {  
            result.append( token );  
        }  
  
        private void endNewClause() {  
            if ( !afterBeginBeforeEnd ) {  
                indent--;  
                if ( afterOn ) {  
                    indent--;  
                    afterOn = false;  
                }  
                newline();  
            }  
            out();  
            if ( !"union".equals( lcToken ) ) {  
                indent++;  
            }  
            newline();  
            afterBeginBeforeEnd = false;  
            afterByOrSetOrFromOrSelect = "by".equals( lcToken )  
                    || "set".equals( lcToken )  
                    || "from".equals( lcToken );  
        }  
  
        private void beginNewClause() {  
            if ( !afterBeginBeforeEnd ) {  
                if ( afterOn ) {  
                    indent--;  
                    afterOn = false;  
                }  
                indent--;  
                newline();  
            }  
            out();  
            beginLine = false;  
            afterBeginBeforeEnd = true;  
        }  
  
        private void values() {  
            indent--;  
            newline();  
            out();  
            indent++;  
            newline();  
            afterValues = true;  
        }  
  
        @SuppressWarnings( {"UnnecessaryUnboxing"})  
        private void closeParen() {  
            parensSinceSelect--;  
            if ( parensSinceSelect < 0 ) {  
                indent--;  
                parensSinceSelect = parenCounts.removeLast().intValue();  
                afterByOrSetOrFromOrSelect = afterByOrFromOrSelects.removeLast().booleanValue();  
            }  
            if ( inFunction > 0 ) {  
                inFunction--;  
                out();  
            }  
            else {  
                if ( !afterByOrSetOrFromOrSelect ) {  
                    indent--;  
                    newline();  
                }  
                out();  
            }  
            beginLine = false;  
        }  
  
        private void openParen() {  
            if ( isFunctionName( lastToken ) || inFunction > 0 ) {  
                inFunction++;  
            }  
            beginLine = false;  
            if ( inFunction > 0 ) {  
                out();  
            }  
            else {  
                out();  
                if ( !afterByOrSetOrFromOrSelect ) {  
                    indent++;  
                    newline();  
                    beginLine = true;  
                }  
            }  
            parensSinceSelect++;  
        }  
  
        private static boolean isFunctionName(String tok) {  
            final char begin = tok.charAt( 0 );  
            final boolean isIdentifier = Character.isJavaIdentifierStart( begin ) || '"' == begin;  
            return isIdentifier &&  
                    !LOGICAL.contains( tok ) &&  
                    !END_CLAUSES.contains( tok ) &&  
                    !QUANTIFIERS.contains( tok ) &&  
                    !DML.contains( tok ) &&  
                    !MISC.contains( tok );  
        }  
  
        private static boolean isWhitespace(String token) {  
            return WHITESPACE.indexOf( token ) >= 0;  
        }  
  
        private void newline() {  
            result.append( "\n" );  
            for ( int i = 0; i < indent; i++ ) {  
                result.append( indentString );  
            }  
            beginLine = true;  
        }  
    }  
  
      public static void main(String[] args) {  
        String sql = new MySQLFormatter().format("select * from t_sss");  
        System.out.println(sql);  
    }  
  
  
}

输出结果样例：

 

按以上步骤，添加相关文件一定可以实现mybatis的格式化打印，但是有一个小坑，可能会打印两遍日志，因为又一遍是没有格式化的。去掉默认打印的配置即可。

本人是用logback进行日志打印的。我去掉了logback配置文件的如下配置后，就只打印了以便格式化后的SQL语句。供参考。

上一篇文章：https://mp.csdn.net/postedit/91788348。介绍使用logback打印日志，也是填补上一篇说要格式化打印mybatis输出的SQL语句的坑。

参考资料：

https://blog.csdn.net/gnd15732625435/article/details/81626095

https://blog.csdn.net/zknxx/article/details/69070330

https://www.ibm.com/developerworks/cn/java/j-lo-p6spy/  p6spy配置文件详解

https://www.cnblogs.com/luodengxiong/p/6766357.html

https://www.cnblogs.com/plain-heart/p/5012728.html

https://blog.csdn.net/kwy15732621629/article/details/77924398

https://blog.csdn.net/kisscatforever/article/details/78784254

yuayi3136
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【问题记录】IDEA Mybatis *Mapper.xml 中 sql 无提示、无高亮、格式化失效问题 (已解决）
weixin_50624398的博客
10-21 4645
其实我还试过那个，就是idea 的插件，比如 SQLFormatter 之类的，那个也可以满足要求，但是问题比语言注入还多，缺点全都有而优点可以忽略，还不如打开一个sql控制台复制粘贴，所以还是放弃了。如标题，想去格式化mybatis中写的sql，但是ctrl alt L 一顿处理，其中的sql没有按照sql命令的格式去格式化，此外写sql 无提示也无高亮。虽然不是什么大问题，但看着膈应，差点就重装idea了，最后挣扎一次，幸好是解决了。（其实这样还合理一点，但是这接手的二开，原来的就是混杂的），又。
格式化打印mybatis的SQL语句，不用再手动复制参数填充
u010050427的专栏
03-19 548
具体内容见原创作者文章：https://blog.csdn.net/yuayi3136/article/details/92078366
Mybatis调试经常需要输出SQL语句，但你知道是怎么输出的嘛？
最新发布
2401_84788504的博客
05-13 640
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
IDEA控制台如何查看格式化的SQL（MyBatis Log插件）
阿甘兄
12-14 5304
在IDEA的控制台，我们可以查看打印的SQL语句，但是需要我们把SQL复制出来，然后一个参数一个一个参数的复制进去?，然后在Navicat工具执行SQL，这个过程非常的麻烦。其实IDEA自带了MyBatis 日志格式化插件，帮我们做好了这些事，本文讲解下如何使用。 02 安装 首先打开IDEA的 ...
mybatisplus @tablefield注解_MyBatisPlus学习整理（二）
weixin_39636176的博客
11-28 560
不多bibi，直接建表DROP TABLE IF EXISTS `user`;CREATE TABLE `user` ( `id` bigint(20) NULL DEFAULT NULL COMMENT '主键', `name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT ...
p6spy监测mysql_P6Spy监控你的Spring boot数据库操作
weixin_39568889的博客
01-28 389
一、简介：p6Spy通过劫持JDBC驱动，在调用实际`JDBC`驱动前拦截调用的目标语，达到`SQL`语句日志记录的目的。它包括`P6Log`和`P6Outage`两个模块。P6Log 用来拦截和记录任务应用程序的 JDBC 语句P6Outage 专门用来检测和记录超过配置条件里时间的 SQL 语句二、使用步骤：1.导入pomp6spyp6spy3.8.12.在 spy.properties中指定...
ideal mybatis打印sql插件
06-13
点击窗口左边的 "Format Sql" 按钮，可以格式化输出的sql语句。 选中console的sql日志，右击 "Restore Sql from Selection" 菜单可以还原sql语句。 前提条件：输出的sql日志必须包含"Preparing:"和"Parameters:...
Mybatis日志SQL解析工具
03-22
该工具可以将mybatis输出的sql日志提取出来，并将其格式化为可以直接执行的sql语句，节约开发人员时间
mybatis 插件: 打印 sql 及其执行时间实现方法
08-30
在 intercept 方法中，首先记录开始时间，然后执行原始方法，最后记录结束时间，计算执行时间，并格式化 SQL 语句，最后打印 SQL 语句及其执行时间。 这个插件可以帮助开发者 debug 和优化 SQL 语句的执行速度，...
springboot+mybatis配置控制台打印sql日志的方法
09-07
设置为`DEBUG`级别后，所有与这些类相关的日志信息，包括SQL语句和参数，都会被打印到控制台。 注意，`debug="false"`表示不开启Logback自身的调试模式，如果需要看到Logback内部的配置信息，可以将其设置为`true`...
SQL代码格式化插件.zip
12-29
超好用一款sqlserver的代码自动补全插件
SQL格式化工具
10-13
SQL格式化工具，用mybatis时，需要用stringbuffer将SQL格式化，推荐使用这个工具
Mybatis日志中的SQL解析工具（网页版）.html
04-23
Mybatis日志中的SQL解析工具（网页版） 说明：复制日志时，必须注意，日志必须包含Preparing:和Parameters:全部内容，而且日志换行格式要保留，不要复制成纯文本，直接ctrl+c即可。
SpringBoot整合Mybatis格式化运行SQL以及SQL运行时间
A169388842的博客
06-05 1017
主要代码如下所示： package com.aoke.oa.search.plugins; import com.baomidou.mybatisplus.core.toolkit.PluginUtils; import com.baomidou.mybatisplus.core.toolkit.SystemClock; import com.baomidou.mybatisplus.core.toolkit.sql.SqlFormatter; import lombok.extern.slf4j.S.
mybatis-plus使用sql的date_format()函数来查询数据
mcband的博客
10-30 8992
mybatis-plus使用sql的date_format()函数来查询数据
【SpringBoot应用篇】SpringBoot集成p6spy格式化SQL
拾一二的博客
08-17 6367
P6Spy 的一个非常典型的用例是启用 SQL 日志记录来解决开发过程中的各种数据库相关问题。 springboot集成P6Spy，mybatis,用的application.properties，配置直接复制可用 1.pom.xml添加依赖 <dependency> <groupId>p6spy</groupId> <artifactId>p6spy</artifactId> <version>3
设置Mybatis打印调试sql的两种方式
热门推荐
Ibex-Relieved的专栏
12-14 8万+
问题描述在使用mybatis进行开发的时候，由于可以动态拼接sql，这样大大方便了我们。但是也有一定的问题，当我们动态sql拼接的块很多的时候，我们要想从*mapper.xml中直接找出完整的sql就会非常的难，这个时候经常会需要把组合之后的完整sql调试出来比较好。下面来看两种调试出sql的两种方式解决方案方案1： 网上说的比较多的，之前也是这么用的一种方式 1:首先将ibatis log4j
Mybatis的sql语句中下划线_，百分号%的转义处理---escape的作用
杨杨得懿的博客
05-11 3万+
escape 是sql中的关键字，定义转义字符。如下：SELECT * FROM student t where t.name like '%/%' escape '/';执行结果为：SELECT * FROM student t where t.name like '%%' escape '/';执行结果为：注：由此可见，escape '/' 是指用'/'说明在/后面的字符不是通配符，而是普通符...
mybatis格式化输出标签之set标签
JDIT的博客
10-21 401
没有使用if标签时，如果有一个参数为null，都会导致错误。 当在update语句中使用if标签时，如果最后的if没有执行，则或导致逗号多余错误。 使用set标签可以将动态的配置set关键字，和剔除追加到条件末尾的任何不相关的逗号。 <update id="updateNodeById" parameterType="com.wht.demo.dao.vo.AgentVo"> u...
mybatis sql 设置时间格式
07-08
在 MyBatis 中，您可以使用 Java 的 SimpleDateFormat 类来设置和格式化日期和时间。以下是在 MyBatis SQL 中设置时间格式的示例： ```xml <select id="getFormattedTime" resultType="String"> SELECT DATE_FORMAT(current_time(), '%H:%i:%s') AS formatted_time FROM dual </select> ``` 在这个示例中，我们使用 SELECT 语句和 DATE_FORMAT 函数来获取当前时间的格式化版本。我们将结果命名为 "formatted_time"，并将其作为字符串类型返回。 然后，在您的 Java 代码中，您可以调用该 SQL 语句并使用 SimpleDateFormat 类来解析结果： ```java String formattedTime = sqlSession.selectOne("getFormattedTime"); SimpleDateFormat inputFormat = new SimpleDateFormat("HH:mm:ss"); Date time = inputFormat.parse(formattedTime); ``` 在这个示例中，我们首先通过调用 sqlSession 的 selectOne 方法来执行 SQL 查询并获取结果。然后，我们创建一个 SimpleDateFormat 对象来指定输入时间的格式，并使用 parse 方法将字符串转换为 Date 对象。 请注意，您需要根据您所使用的数据库和时间格式进行相应的调整。 希望这对您有帮助！如果您有任何其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值