SpringBoot + MyBatis自定义打印sql日志

最新推荐文章于 2024-06-02 17:02:32 发布
最新推荐文章于 2024-06-02 17:02:32 发布
阅读量1k 收藏 2
点赞数
文章标签： spring boot java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Deroser/article/details/122620496
版权

1.准备环境：

  • java8
  • MyBatis-Plus（使用的原因是为了方便生成dao、service和直接使用自带的方法）
    pom文件（包含一部分项目其他地方用的包）
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.deroser.mybatis-plus-test</groupId>
    <artifactId>mybatis-plus-test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-plus-test</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.1</version>
        </dependency>
        <!-- 添加 模板引擎 依赖 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>8.0.22</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.twelvemonkeys.imageio</groupId>
            <artifactId>imageio-tiff</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--时间解析-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.7</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <compilerArguments>
                        <verbose />
<!--                        <bootclasspath>${java.home}/lib/rt.jar;${java.home}/lib/jce.jar;${java.home}/lib/jsse.jar</bootclasspath>-->
                    </compilerArguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

yml文件只配置了dataSource

2.编写config类

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.deroser.mybatisplustest.mybatisplustest.Interceptor.TestInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
@MapperScan("com.deroser.mybatisplustest.mybatisplustest.mapper")
public class MyConfig extends WebMvcConfigurerAdapter {
    /**
     * myBatis-Plus的分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }

	/**
	 * 接下来要写的拦截器
	 */
    @Bean
    public MybatisInterceptor mybatisInterceptor(){return new MybatisInterceptor();}

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(testInterceptor()).addPathPatterns("/**");
    }
}

import com.deroser.mybatisplustest.mybatisplustest.config.util.SQLFormatter;
import org.apache.commons.lang3.StringUtils;
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.type.TypeHandlerRegistry;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.io.Serializable;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.regex.Matcher;

@Intercepts({@Signature(
        type = Executor.class,
        method = "update", 
        args = {MappedStatement.class,Object.class}
)})
// 这个拦截器只处理修改（update）的sql
public class MybatisInterceptor implements Interceptor, Serializable {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement)invocation.getArgs()[0];
        Object paramter = null;
        if (invocation.getArgs().length > 1){
            paramter = invocation.getArgs()[1];
        }
        String sqlId = mappedStatement.getId();
        BoundSql boundSql = mappedStatement.getBoundSql(paramter);
        Configuration configuration = mappedStatement.getConfiguration();
        try {
            String sql = getSql(configuration,boundSql,sqlId);
            System.out.println("sql打印测试："+sql);
        }catch (Exception var15){
            System.out.println(var15.getMessage());
        }
        return invocation.proceed();
    }

    private String getSql(Configuration configuration, BoundSql boundSql, String sqlId) {
        String sql = bindingSQL(configuration,boundSql);
        StringBuilder str = new StringBuilder(100);
        str.append(SQLFormatter.format(sql));
        return str.toString();
    }

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

    @Override
    public void setProperties(Properties properties) {

    }

    private static String bindingSQL(Configuration configuration,BoundSql boundSql){
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        String sql = boundSql.getSql();
        try {
            if (parameterMappings.size() > 0 && parameterObject != null){
                TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
                System.out.println(parameterObject.getClass());
                if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){
                    sql = replaceSqlRegex(sql,parameterObject);
                }else {
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    Iterator var7 = parameterMappings.iterator();

                    while (var7.hasNext()){
                        ParameterMapping parameterMapping = (ParameterMapping) var7.next();
                        String propertyName = parameterMapping.getProperty();
                        Object obj;
                        if (metaObject.hasGetter(propertyName)){
                            obj = metaObject.getValue(propertyName);
                            sql = replaceSqlRegex(sql,obj);
                        }else if (boundSql.hasAdditionalParameter(propertyName)){
                            obj = boundSql.getAdditionalParameter(propertyName);
                            sql = replaceSqlRegex(sql,obj);
                        }
                    }
                }
            }
        }catch (Exception var11){
            throw var11 instanceof RuntimeException ? (RuntimeException)var11 : new RuntimeException(var11);
        }

        sql = SQLFormatter.format(sql);
        return sql;
    }

    private static String replaceSqlRegex(String sql, Object obj){
        String parameterValue = getParameterValue(obj);
        sql = sql.replaceFirst("\\?",parameterValue == null ? null: Matcher.quoteReplacement(parameterValue));
        return sql;
    }

    private static String getParameterValue(Object obj) {
        if (obj == null){
            return null;
        }else {
            String value = null;
            if (obj instanceof String){
                value = "'"+ obj.toString()+ "'";
            }else if (obj instanceof Date){
                value = "'"+ formatDateTime((Date)obj,"yyyy-MM-dd HH:mm:ss")+"'";
            }else if (obj!=null){
                value = obj.toString();
            }else {
                value = "";
            }
            return value;
        }
    }

    private static String formatDateTime(Date time, String format) {
        if (time == null){
            return null;
        }else {
            DateTimeFormatter dateFormat = null;
            if (StringUtils.isNotEmpty(format)){
                dateFormat = DateTimeFormat.forPattern(format);
            }else {
                dateFormat = DateTimeFormat.forPattern("yyyy-MM-dd");
            }

            return (new DateTime(time)).toString(dateFormat);
        }
    }
}

package com.deroser.mybatisplustest.mybatisplustest.config.util;

import java.util.*;
//所需的工具类
public class SQLFormatter {
    private static final String WHITESPACE = " \n\r\f\t";
    private static final Set<String> BEGIN_CLAUSES = new HashSet<>();
    private static final Set<String> END_CLAUSES = new HashSet<>();
    private static final Set<String> LOGICAL = new HashSet<>();
    private static final Set<String> QUANTIFIERS = new HashSet<>();
    private static final Set<String> DML = new HashSet<>();
    private static final Set<String> MISC = new HashSet<>();
    private static final Set<String> SQL_KEY_CASE = new HashSet<>();
    String indentString = "     ";
    String initial = "\n     ";
    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<>();
    private LinkedList<Boolean> afterByOrFromOrSelects = new LinkedList<>();
    int indent = 1;
    StringBuffer result = new StringBuffer();
    StringTokenizer tokens;
    String lastToken;
    String token;
    String lcToken;

    public SQLFormatter(String sql) {
        this.tokens = new StringTokenizer(sql, "()+*/-=<>'`\"[], \n\r\f\t", true);
    }

    public SQLFormatter setIndentString(String indent) {
        this.indentString = indent;
        return this;
    }

    public SQLFormatter setInitialString(String initial) {
        this.initial = initial;
        return this;
    }

    public String format() {
        this.result.append(this.initial);

        while (this.tokens.hasMoreTokens()) {
            this.token = this.tokens.nextToken();
            this.lcToken = this.token.toLowerCase();
            String t;
            if ("'".equals(this.token)) {
                do {
                    t = this.tokens.nextToken();
                    this.token = this.token + t;
                } while (!"'".equals(t) && this.tokens.hasMoreTokens());
            } else if ("\"".equals(this.token)) {
                do {
                    t = this.tokens.nextToken();
                    this.token = this.token + t;
                } while (!"\"".equals(t));
            }

            if (this.afterByOrSetOrFromOrSelect && ",".equals(this.token)) {
                this.commAfterByOrFromOrSelect();
            } else if (this.afterOn && ",".equals(this.token)) {
                this.commaAfterOn();
            } else if ("(".equals(this.token)) {
                this.openParen();
            } else if (")".equals(this.token)) {
                this.closeParen();
            } else if (BEGIN_CLAUSES.contains(this.lcToken)) {
                this.beginNewClause();
            } else if (END_CLAUSES.contains(this.lcToken)) {
                this.endNewClause();
            } else if ("includes".equals(this.lcToken)) {
                this.select();
            } else if (DML.contains(this.lcToken)) {
                this.updateOrInsertOrDelete();
            } else if ("values".equals(this.lcToken)) {
                this.on();
            } else if (this.afterBetween && this.lcToken.equals("and")) {
                this.misc();
                this.afterBetween = false;
            } else if (LOGICAL.contains(this.token)) {
                this.logical();
            } else if (isWhitespace(this.token)) {
                this.white();
            } else {
                this.misc();
            }

            if (!isWhitespace(this.token)) {
                this.lastToken = this.lcToken;
            }
        }

        return this.result.toString();
    }

    private void commAfterByOrFromOrSelect() {
        this.out();
        this.newline();
    }

    private void commaAfterOn() {
        this.out();
        --this.indent;
        this.newline();
        this.afterOn = false;
        this.afterByOrSetOrFromOrSelect = true;
    }

    private void logical() {
        if ("end".equals(this.lcToken)) {
            --this.indent;
        }
        this.out();
        this.beginLine = false;
    }

    private void on() {
        ++this.indent;
        this.afterOn = true;
        this.out();
        this.beginLine = false;
    }

    private void misc() {
        this.out();
        if ("between".equals(this.lcToken)) {
            this.afterBetween = true;
        }

        if (this.afterInsert) {
            this.newline();
            this.afterInsert = false;
        } else {
            this.beginLine = false;
            if ("case".equals(this.lcToken)) {
                ++this.indent;
            }
        }
    }

    private void white() {
        if (!this.beginLine) {
            this.result.append(" ");
        }
    }

    private void updateOrInsertOrDelete() {
        this.out();
        ++this.indent;
        this.beginLine = false;
        if ("updateByPk".equals(this.lcToken)) {
            this.newline();
        }

        if ("insert".equals(this.lcToken)) {
            this.afterInsert = true;

        }
    }

    private void select() {
        this.out();
        ++this.indent;
        this.newline();
        this.parenCounts.addLast(this.parensSinceSelect);
        this.afterByOrFromOrSelects.addLast(this.afterByOrSetOrFromOrSelect);
        this.parensSinceSelect = 0;
        this.afterByOrSetOrFromOrSelect = true;
    }

    private void out() {
        if (SQL_KEY_CASE.contains(this.token.toLowerCase())) {
            this.token = this.token.toUpperCase();
        }
        this.result.append(this.token);
    }

    private void endNewClause() {
        if (!this.afterBeginBeforeEnd) {
            --this.indent;
            if (this.afterOn) {
                --this.indent;
                this.afterOn = false;
            }

            this.newline();
        }
        this.out();
        if (!"union".equals(this.lcToken)) {
            ++this.indent;
        }

        this.result.append(" ");
        this.afterBeginBeforeEnd = false;
        this.afterByOrSetOrFromOrSelect = "by".equals(this.lcToken) || "set".equals(this.lcToken) || "from".equals(this.lcToken);
    }

    private void values() {
        --this.indent;
        this.newline();
        this.out();
        ++this.indent;
        this.newline();
        this.afterValues = true;
    }

    private void beginNewClause() {
        if (!this.afterBeginBeforeEnd) {
            if (this.afterOn) {
                --this.indent;
                this.afterOn = false;
            }

            --this.indent;
            this.newline();
        }
        this.out();
        this.beginLine = false;
        this.afterBeginBeforeEnd = true;
    }

    private void closeParen() {
        --this.parensSinceSelect;
        if (this.parensSinceSelect < 0) {
            --this.indent;
            this.parensSinceSelect = (Integer) this.parenCounts.removeLast();
            this.afterByOrSetOrFromOrSelect = (Boolean) this.afterByOrFromOrSelects.removeLast();
        }

        if (this.inFunction > 0) {
            --this.inFunction;
            this.out();
        } else {
            if (!this.afterByOrSetOrFromOrSelect) {
                --this.indent;
                this.newline();
            }
            this.out();
        }
        this.beginLine = false;
    }

    private void openParen() {
        if (isFunctionName(this.lastToken) || this.inFunction > 0) {
            ++this.inFunction;
        }
        this.beginLine = false;
        if (this.inFunction > 0) {
            this.out();
        } else {
            this.out();
            if (!this.afterByOrSetOrFromOrSelect) {
                ++this.indent;
                this.newline();
                this.beginLine = true;
            }
        }
        ++this.parensSinceSelect;
    }

    public static String format(String sql) {
        try {
            return (new SQLFormatter(sql)).format();
        } catch (Throwable var2) {
            return sql;
        }
    }

    private static boolean isFunctionName(String tok) {
        char begin = tok.charAt(0);
        boolean isIdentifier = Character.isJavaIdentifierPart(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 " \n\r\f\t".contains(token);
    }

    private void newline() {
        this.result.append("\n");
        for (int i = 0; i < this.indent; i++) {
            this.result.append(this.indentString);
        }
        this.beginLine = true;
    }

    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("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("updateByPk");
        DML.add("delete");
        DML.add("includes");
        DML.add("on");
        SQL_KEY_CASE.addAll(Arrays.asList("includes", "insert", "updateByPk", "delete", "on", "left", "right", "inner", "outer", "group", "order", "where", "set", "having", "join", "from", "by", "into", "union", "and", "or", "when", "else", "end", "in", "all", "exists", "if", "some", "any", "distinct", "count", "sum", "as", "asc", "desc", "between", "alter", "table", "else", "elseif", "index", "ignore", "limit", "like", "offset"));
    }
}

2.写好这些就可以了，接下来随便写个修改的接口

import com.deroser.mybatisplustest.mybatisplustest.model.User;
import com.deroser.mybatisplustest.mybatisplustest.service.UserService;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author deroser
 * @since 2021-05-11
 */
@RestController
@RequestMapping("/mybatisplustest/user")
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping(value = "/updateUser",method = RequestMethod.POST)
    public boolean getUser(@RequestBody User user){
        return userService.saveOrUpdate(user);
    }

}

运行项目后调用接口，效果如下
在这里插入图片描述

PS：实际上可以通过如下方式(yml配置)直接打印sql日志：

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

如果用的是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>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
</configuration>

但是因为我所在的公司项目用的是自己的框架，不可修改，里面只是打印了查询的sql，而因为日志已经写的五花八门的，再配置这个东西就显得有些鸡肋，只能用这种方法针对update做了处理

Der Ingenieur
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL语句即可在数据库工具中执行。 使用方法： 找到你springboot项目中的配置文件，增加如下配置即可 application.yml 配置如下： sql: slow-threshold: 100 或 application.properties 配置如下： sql.slow-threshold=100 参数解释：以上数值单位为：毫秒，意思是超过100毫秒的SQL将被定义为慢SQL并打印出可执行的语句。
MyBatis Plus配置日志CRUD的使用详解
08-18
主要介绍了MyBatis Plus配置日志,CRUD的使用,，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
实习日志（6）SpringMVC + Mybatis +Logback配置
jsh_941112341的博客
12-11 617
工具IDEA2018，JDK8 项目结构 web.xml &amp;amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot;?&amp;amp;amp;gt; &amp;amp;amp;lt;web-app version=&amp;amp;quot;4.0&amp;a
mybatis自定义日志实现
星月昭铭的博客
04-16 936
网上挺多文章是通过mybatis的拦截器来实现的，但是测试发现，sql条数如果过多的话，相比于mybatis原生的输出方式，通过拦截器方式输出日志会对性能有影响。当然，因为mybatis原生的输出级别是debug，在有些情况下可能不适用（比如有的系统只保存INFO、ERROR级别的日志，但又想要保留SQL日志方便排查问题），所以这里通过自定义日志来达到不通过拦截器且能输出日志的目的。
从零开始SpringCloud Alibaba实战（44）——mybatis 打印日志
liuerchong的博客
08-21 946
前言 在程序开发过程中，为了调试方便、了解程序的运行过程，进行必要的日志输出总是免不了的。对于使用Mybatis而言，我们常见的需求是希望可以在日志中打印出Mybatis执行过程中进行数据库操作的SQL语句及其传递的参数。Mybatis的日志输出是统一管理的，它有自己的日志接口，然后在需要进行日志输出的时候使用统一的API进行日志输出。这个统一的接口是org.apache.ibatis.logging.Log。Mybatis分别基于常用的日志输出工具给出了对应的实现，比如LOG4J、SLF4J等。默认情况下
mybatis自定义日志实现类
weixin_37862824的博客
05-24 1012
在使用mybatis，有时候，我们会选择自己的日志类，那么针对mybatis日志选择，如果要使用我们自定义的。 1、实现org.apache.ibatis.logging.Log接口。 public class TestLog implements org.apache.ibatis.logging.Log { public TestLog(){ System.out.println("wucan"); } Logger logger = null;
mybatis自定义日志类
return
01-04 1304
在使用springboot的logback输出日志时，通过mybatis打印出来 的sql结果没有写入到日志文件中，为了可以把sql语句和sql结果 都输出到日志文件中，就自定义一个日志类 输出日志的前提条件需要配置好前提配置好logback的相关配置 打印sql的方法有两个 1. (控制台会输出sql语句和执行sql的结果，但输出的日志文件没有sql语句和执行结果) mybatis-plus: configuration: log-impl: org.apache.ibatis.logg
mybatis 打印自定义完整日志
weixin_39660224的博客
11-14 1710
需求 项目中遇到需要打印sql语句日志，还有其执行时间，还要把sql语句美化下(把 ？替换成实际的参数、换行符删除)，目的在于打印sql语句时加入我们自己的日志关键字。比如说项目中集成了链路追踪功能，那么我们想打印sql 语句时，能如下输出： span:xxxx, [SQL:......] 执行耗时 [.. ms] 这样如果我们有集成了es的话后期出问题查日志很方便，只要有这个链路id，我们就可以找到所有这个链路中执行的sql（异步除外） 这个肯定是用mybatis plugins没错了，但是具体sql
SpringBoot集成Mybatis-Plus、Druid（SQL监控）
小石潭记丶
06-29 3583
1.创建springboot项目，先实现mybatis-plus、druid 2.pom文件引入 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <de
基于Springboot+Mybatis+ SpringMvc+springsecrity+Redis完整网站后台管理系统
10-31
sl4j日志分包：将sql日志、业务日志、异常日志进行了分离，更方便定位问题 日志表：使用aop拦截实现 权限控制：基于token方式，禁用session 对各种不同异常进行了全局统一处理 使用lombok简化java代码，让源码...
本科毕业设计+基于SpringBoot+Vue构建的中小企业进销存管理系统
06-20
优势 严格遵循阿里编码规约开发，便于阅读及二次开发 支持 MySQL、MariaDB、Oracle、DB2、...自定义实现swagger文档支持，方便编写API接口文档 使用Mybatis拦截器实现数据权限，对代码侵入小 完成Activiti6集成，可实现
jorian-framework:即开即用的基于SpringBoot的后台管理系统脚手架，已集成权限管理，文件上传，定时任务，邮件中心，监控中心等模块，前后端项目分离开发，技术栈：SpringBoot+Redis+Mybatis+MPPlus+Mysql+Shiro+JWT，适用于学习和小型项目快速启动
05-14
4.使用自定义注释完成日志收集,消息队列异步完成存储 5.包含有定时任务,文件中心,邮件中心,监控中心等基础功能 6.集成了rabbitmq,elasticsearch ,适用于学习和轻量级项目开发 所用技术栈 1.SpringBoot 2.0 2.Shiro ...
百度地图开发java源码-discussion:SpringBootMybatisRedis开发脚手架平台，浏览器支持IE8以上版本
06-06
SQL Server和redis即可运行，操作简单明了，适用于百台规模以下机器的部署运维操作。 主要功能： 系统用户,角色,权限增删改查,权限分配，权限配色 系统字典 配置网站基本信息，包括博客数据限制 查看系统...
日志（自定义）
不好看的博客
09-27 174
一般python使用日志功能 import logging def logging_init(): app_name = "AppName" log_file_name = "myapp_test.log" logger = logging.getLogger(app_name) format_str = "[%(asctime)s][%(levelname)s]&g...
SpringBoot中使用mybatis/ibatis日志打印sql
weixin_49442658的博客
12-03 1636
SpringBoot中使用mybatis/ibatis日志打印sql控制台打印mybatis/ibatis对应的sql主机的日志文件中打印sql 控制台打印mybatis/ibatis对应的sql 只需在配置文件中增加以下配置，调整自己想要的日志输出级别即可在控制台看到自己sql的打印日志。 （举例为.properties的配置格式，如果是yaml格式自行修改即可） # 配置sql日志的打印级别（这里设置成自己mapper的所在路径） logging.level.com.xxx.jay.cust.mapp
实现自动记录日志
柒七的博客
07-17 315
Aop和拦截器实现自动记录日志
SpringBoot + MyBatis + slf4j 自定义日志输出
qq587492的博客
09-09 3246
在使用 MyBatis 时，如果想将日志输出可以在application 配置文件中配置 mybatis-plus.configuration.log-impl 该属性选择日志输出方式 在实际开发中，可能需要将MyBatis查询SQL放入日志中，而org.apache.ibatis.logging.stdout.StdOutImpl 只能将SQL数据打印在控制台不能输出日志。org.apache.ibatis.logging.slf4j.Slf4jImpl 设置相对繁琐，并且只能在DEBUG或TRA..
springboot2 集成log4 mybatis 日志_SpringBoot2 集成日志，复杂业务下的自定义实现
weixin_42146230的博客
01-25 68
一、日志体系集成1、日志管理在系统的开发中，最关键的一个组件工具就是日志，日志打印方便问题排查，或者生产事故回溯，日志记录用来监控并分析系统性能点，并以此为依据，不断对系统进行优化；同时基于用户的操作日志，对用户行为进行分析，开发智能推荐的功能，或者进行营销投放，这在系统中都是常见且关键的业务流程。2、ELK日志体系在大型系统架构中，ELK的日志管理系统是系统必备功能，ELK-Stack...
Java Spring Boot 从必应爬取图片
最新发布
2302_79789602的博客
06-02 405
获取图片主要就是通过必应图片页面控制台的元素，确认图片和标题在哪个类中（浏览器 F12）
java springboot + mybatis 打印sql语句
07-27
在Java SpringBoot项目中，如果使用了Mybatis框架，默认情况下执行的所有SQL操作都不会打印日志。但是有时候我们需要对一些错误的语句进行排查，这时候就需要配置打印SQL日志。有两种常见的配置方法可以实现这个目的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值