spring boot项目格式化sql打印

最新推荐文章于 2023-07-30 14:00:00 发布
最新推荐文章于 2023-07-30 14:00:00 发布
阅读量940 收藏 1
点赞数 1
分类专栏： mysql spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42037525/article/details/101269033
版权 
第一步：创建一个SQL格式化工具类SQLFormatterUtil.java
package com.trackable.small.domain.common.util;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;
import java.util.StringTokenizer;

/**
 * 描述:SQL格式化工具
 *
 * @outhor Administrator
 * @create 2018-11-08 14:01
 */
public class SQLFormatterUtil {

  private static SQLFormatterUtil instance = null;

  public static SQLFormatterUtil getInstance() {
    if (instance == null) {
      instance = new SQLFormatterUtil();
    }
    return instance;
  }

  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 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 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 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;
    }
  }

}

第二步：创建一个sql拦截器SqlStatementInterceptor.java

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
import java.util.regex.Matcher;

/**
 * 描述:数据库操作性能拦截器,记录耗时
 *
 * @outhor Administrator
 * @create 2018-11-07 13:41
 */

@Intercepts(value = {
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class,
        Object.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
        RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
        RowBounds.class, ResultHandler.class})})
public class SqlStatementInterceptor implements Interceptor {

  private static Logger logger = LoggerFactory.getLogger(SqlStatementInterceptor.class);

  private Properties properties;

  public Object intercept(Invocation invocation) throws Throwable {
    Object returnValue;
    long start = System.currentTimeMillis();
    returnValue = invocation.proceed();
    long end = System.currentTimeMillis();
    long time = end - start;
    try {
      final Object[] args = invocation.getArgs();
      //获取原始的ms
      MappedStatement ms = (MappedStatement) args[0];
      Object parameter = null;
      //获取参数，if语句成立，表示sql语句有参数，参数格式是map形式
      if (invocation.getArgs().length > 1) {
        parameter = invocation.getArgs()[1];
      }
      logger.debug("查询参数: " + parameter);
      String sqlId = ms.getId();// 获取到节点的id,即sql语句的id
      BoundSql boundSql = ms.getBoundSql(parameter);  // BoundSql就是封装myBatis最终产生的sql类
      Configuration configuration = ms.getConfiguration();  // 获取节点的配置
      String sql = getSql(configuration, boundSql, sqlId, time); // 获取到最终的sql语句
    } catch (Exception e) {
      logger.error("拦截sql处理出错" + e.getMessage());
    }
    return returnValue;
  }

  // 封装了一下sql语句，使得结果返回完整xml路径下的sql语句节点id + sql语句
  public static String getSql(Configuration configuration, BoundSql boundSql, String sqlId,
                              long time) {
    String sql = showSql(configuration, boundSql);
    StringBuilder str = new StringBuilder(100);
    str.append(sqlId).append(":耗时【").append(time).append("】毫秒");
    String begin = "============================sql begin================================";
    String end = "============================sql end==================================";
    logger.info(begin);
    logger.warn(str.toString() + "\n" + SQLFormatterUtil.getInstance().format(sql));
    logger.info(end);
    return str.toString();
  }


  /*<br>    *如果参数是String，则添加单引号， 如果是日期，则转换为时间格式器并加单引号； 对参数是null和不是null的情况作了处理<br>　　*/
  private static String getParameterValue(Object obj) {
    String value = null;
    if (obj instanceof String) {
      value = "'" + obj.toString() + "'";
    } else if (obj instanceof Date) {
      DateFormat formatter = DateFormat
          .getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
      value = "'" + formatter.format(new Date()) + "'";
    } else {
      if (obj != null) {
        value = obj.toString();
      } else {
        value = "";
      }

    }
    return value;
  }

  // 进行？的替换
  public static String showSql(Configuration configuration, BoundSql boundSql) {
    Object parameterObject = boundSql.getParameterObject();  // 获取参数
    List<ParameterMapping> parameterMappings = boundSql
        .getParameterMappings();
    String sql = boundSql.getSql().replaceAll("[\\s]+", " ");  // sql语句中多个空格都用一个空格代替
    if (!CollectionUtils.isEmpty(parameterMappings) && parameterObject != null) {
      TypeHandlerRegistry typeHandlerRegistry = configuration
          .getTypeHandlerRegistry(); // 获取类型处理器注册器，类型处理器的功能是进行java类型和数据库类型的转换<br>　　　　　　　// 如果根据parameterObject.getClass(）可以找到对应的类型，则替换
      if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
        sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(parameterObject)));

      } else {
        MetaObject metaObject = configuration.newMetaObject(
            parameterObject);// MetaObject主要是封装了originalObject对象，提供了get和set的方法用于获取和设置originalObject的属性值,主要支持对JavaBean、Collection、Map三种类型对象的操作
        for (ParameterMapping parameterMapping : parameterMappings) {
          String propertyName = parameterMapping.getProperty();
          if (metaObject.hasGetter(propertyName)) {
            Object obj = metaObject.getValue(propertyName);
            sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(obj)));
          } else if (boundSql.hasAdditionalParameter(propertyName)) {
            Object obj = boundSql.getAdditionalParameter(propertyName);  // 该分支是动态sql
            sql = sql.replaceFirst("\\?", Matcher.quoteReplacement(getParameterValue(obj)));
          } else {
            sql = sql.replaceFirst("\\?", "缺失");
          }//打印出缺失，提醒该参数缺失并防止错位
        }
      }
    }
    return sql;
  }


  public Object plugin(Object arg0) {
    return Plugin.wrap(arg0, this);
  }


  public void setProperties(Properties arg0) {
    this.properties = arg0;
  }
}

第三步：创建mybatis-config.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 在这个文件放置一些全局性的配置
    <typeAliases>
        <typeAlias type="实体类" alias="别名"/>
    </typeAliases> -->

    <settings>
        <setting name="cacheEnabled" value="false" />
        <!-- 打印查询语句 -->
        <!--<setting name="logImpl" value="STDOUT_LOGGING" />-->
        <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间  -->

        <!--  设置缓存和延迟加载等等重要的运行时的行为方式
         <setting name="defaultStatementTimeout" value="25000"/>
         &lt;!&ndash; 这个配置使全局的映射器启用或禁用缓存  &ndash;&gt;
         <setting name="cacheEnabled" value="true" />
         <setting name="lazyLoadingEnabled" value="true"/>
         <setting name="useColumnLabel" value="true" />
         <setting name="mapUnderscoreToCamelCase" value="true" />-->
    </settings>
    <!-- 以下内容不再需要手动配置  已经自动映射 -->


    <!--配置sql拦截器-->
    <plugins>
        <plugin interceptor="com.trackable.small.domain.common.util.SqlStatementInterceptor"></plugin>
    </plugins>
    <!--<plugins>
      <plugin interceptor="cn.chenlilin.blog.filter.SqlStatementInterceptor" />
    </plugins>-->

</configuration>

第四步：application.yml配置，特别注意：mybatis要与spring平级，不然sql不打印

server:
  port: 9082

spring:
# datasource
#spring:
  datasource:
    ###dev
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/trackable_manage?characterEncoding=utf8&useSSL=false
    username: root
    password: root


    # 初始化大小，最小，最大
    initialSize: 5
    minIdle: 5
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql将无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合并多个DruidDataSource的监控数据
    #useGlobalDataSourceStat=true

mybatis:
  config-location: classpath:mybatis-config.xml
  mapper-locations: classpath:com/trackable/small/domain/mapper/*.xml
  type-aliases-package: com.trackable.small.domain.entity

pagehelper:
  helper-dialect: mysql
  reasonable: true
  support-methods-arguments: true
  params: count=countsql

logging:
  #path: classpath:log/
  file: trackablesmall.log

sql打印结果如下图，便是配置成功

 

 

 

 

 

你的微笑，乱了夏天
关注
专栏目录
Spring Boot进阶(52)：轻松管理数据库版本，Spring Boot集成Flyway实现SQL脚本自动化执行！
**My Coding Family**
06-15 1519
Spring Boot 如何集成Flyway并初始化执行 SQL 脚本？一文带你搞定它。
SpringBoot中Mybatis打印sql
qq_30347133的博客
09-28 716
SpringBoot中Mybatis打印sql 如果使用的是application.properties文件，加入如下配置： logging.level.com.example.demo.dao=debug logging.level.com，后面的路径指的是mybatis对应的方法接口所在的包。并不是mapper.xml所在的包。 如果使用的是application.yml文件，加入如下配置： # 打印sql logging: level: com.example.demo.dao :
Mybatis Log plugin实现Springboot+mybatis打印完整的sql格式
m_i_dlong的博客
08-15 1213
IDEA插件：Mybatis Log Plugin插件 问题：最近在做一个springboot项目，想要打印sql语句，但是mybatis的sql语句是语句和参数分离，如果参数太多，使用起来不是特别方便，编程人员在调试sql的时候也不是很方便。因为太烂，不想重写mybatis的sql打印类，就直接使用了这个插件，还是不错的，所以推荐以下。 好，接下来直接讲解步骤： 1.打开idea后，使用Ctrl+Alt+S打开软件设置，找到Plugins标签并进入 2.按照图片顺序，安装Mybatis Log Plug
SpringBoot整合Mybatis格式化运行SQL以及SQL运行时间
A169388842的博客
06-05 1039
主要代码如下所示： 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.
【SpringBoot应用篇】SpringBoot集成p6spy格式化SQL
拾一二的博客
08-17 7252
P6Spy 的一个非常典型的用例是启用 SQL 日志记录来解决开发过程中的各种数据库相关问题。 springboot集成P6Spy，mybatis,用的application.properties，配置直接复制可用 1.pom.xml添加依赖 <dependency> <groupId>p6spy</groupId> <artifactId>p6spy</artifactId> <version>3
SpringBoot中设置Hibernate format_sql
helloworld的专栏
11-28 1万+
spring: jpa: properties: hibernate: format_sql: true show_sql: truehttps://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-creating-and-dropping-
SpringBoot：阿里数据源配置、JPA显示sql语句、格式化JPA查询的sql语句
weixin_30906185的博客
07-23 1557
1 数据源和JPA配置 　　1.1 显示sql配置和格式化sql配置 　　　　者两个配置都是属于hibernate的配置，但是springdatajpa给我们简化了；所有hibernate的配置都在jpa下面的properties中；若果直接配置到jpa下面可能不会生效 eureka: client: service-url: defaultZon...
Spring Boot配置hibernate显示sql语句和格式化sql语句
qq_41700374的博客
02-04 4781
server.port=8989 spring.datasource.url=jdbc:mysql://localhost:3306/weather?useUnicode=true&amp;characterEncoding=UTF-8 spring.datasource.username=root spring.datasource.password=123456 spring.datasou...
SQL注入原理以及Spring Boot如何防止SQL注入（含详细示例代码）
12-29
SQL注入是一种严重的安全威胁，它允许攻击者通过在应用程序的输入字段中插入恶意SQL代码来执行未经授权的数据库...Spring Boot通过提供JdbcTemplate和Spring Data JPA等工具，为开发者提供了防止SQL注入的有效手段。
Spring Boot项目开发实战教程.docx
最新发布
05-03
### Spring Boot项目开发实战教程知识点概述 #### 一、Spring Boot框架环境搭建 - **环境配置**：在开始Spring Boot项目开发之前，首先需要搭建一个完整的开发环境。这包括安装JDK并设置环境变量；安装IDE（如...
springboot log4jdbc 打印完整sql
03-04
打印完整带参数sql，不用自己去替换问号，后端省时省力。
《滚雪球学Spring Boot》教程导航帖（更新于2024.06.20）
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由CSDN博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如CSDN、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
热门推荐
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
springboot日志2(实现，输出，格式化控制)
阿七的博客
04-07 395
springboot日志 1.写工具类，让需要的类继承即可 2.用注解@Slf4j 需要在pom中引入slf4j依赖 3.日志格式化输出控制
在Spring Boot中打印SQL语句的方法
pleaseprintf的博客
07-30 5854
在Spring Boot项目中，调试和优化数据库操作是很常见的需求。通过打印SQL语句可以帮助开发人员快速了解数据库的操作情况，进而进行性能分析和调试。本文将介绍在Spring Boot中打印SQL语句的几种方法，帮助你更好地理解和优化数据库操作。通过本文，你了解了在Spring Boot项目中打印SQL语句的几种方法。你可以根据实际需求选择合适的方法来查看和优化数据库操作。希望本文对你有所帮助。如果你有任何问题或疑问，欢迎留言讨论。需要系统源码或者BiShe加V。
Spring Boot 配置MyBatis 显示SQL日志
zhouzhiwengang的专栏
04-21 8975
刚刚在IDEA 编辑器上集成SQL Params Setter SQL格式化插件，需要控制台输出MyBatis sql 语句。 打印SQL语句的配置非常简单 在application.properties或application.yml文件中配置对应mapper所在包的日志级别即可。 示列：com.zzg.mapper 指向mapper 接口包路径地址 # 日志记录输出配置 logging.level.com.zzg.mapper=debug 控制台效果展示： 2022-04-21 17
Springboot logback JPA打印sql参数
zetor的专栏
01-24 6612
1、配置方式： springboot + logback + jpa，打印sql（格式化），打印参数方式如下： 在application.yml中，追加配置 spring: jpa: show-sql: true properties: hibernate: format_sql: true logging: level: org.hibernate.SQL: debug org.hibernate.type.de...
spring boot 打印myabtis sql语句以及JSON格式化
威尼斯的泪
05-28 1868
关于如何打印mybatis 日志： 其实在application.properties 文件下，添加一下配置即可：logging.level.org.springframework=WARN logging.level.org.spring.springboot.dao=DEBUG logging.file=logs/spring-boot-logging.log至于输出级别和日志路径，根据需要自...
【Springboot】——整合p6spy格式化SQL日志
漫漫长途，终有回转；余味苦涩，终有回甘
11-11 6915
项目现状介绍 &nbsp;&nbsp;&nbsp;&nbsp;项目使用Springboot+Mybatis作为基础框架，项目中日志框架采用logback+Slf4J，关于日志中SQL部分日志的打印采用的mybatis本身打印格式，sql语句正常输出，参数的位置使用占位符“？”替代。这样造成问题就是在处理项目中的sql问题，sql格式打印不规范，从sql日志查看，到sql日志运行判断都会花费一些重...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值