Logback写入MySQL的源码扩展

最新推荐文章于 2023-06-16 00:41:52 发布
最新推荐文章于 2023-06-16 00:41:52 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Logback
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldllovegyh/article/details/82286334
版权

    Logback是一个开源日志组件,为取代log4j而生。
    Logback主要分为三个模块:logback-core,logback-classic和logback-access。
    Logback有着许多独特而实用的特性,如Marker、参数化记录语句、条件化堆栈跟踪和强大的事件过滤等。在此不详述,有兴趣的朋友可以查看官方文档。
    入正题,在很多实际项目开发中,往往会有将日志写入自定义的用户表的需求,或者需要记录特殊的字段。这两者,原理类似。今天给大家分享下基于logback将日志写入Mysql数据库(写入其他数据库或文件同理)的一个字段扩展。
    Logback记录日志主要用到三张固定的表:logging_event,logging_event_property,logging_event_exception。结构如下: 

BEGIN;
DROP TABLE IF EXISTS logging_event_property;
DROP TABLE IF EXISTS logging_event_exception;
DROP TABLE IF EXISTS logging_event;
COMMIT;

BEGIN;
CREATE TABLE logging_event 
  (
    timestmp         BIGINT NOT NULL,
    formatted_message  TEXT NOT NULL,
    logger_name       VARCHAR(254) NOT NULL,
    level_string      VARCHAR(254) NOT NULL,
    thread_name       VARCHAR(254),
    reference_flag    SMALLINT,
    arg0              VARCHAR(254),
    arg1              VARCHAR(254),
    arg2              VARCHAR(254),
    arg3              VARCHAR(254),
    caller_filename   VARCHAR(254) NOT NULL,
    caller_class      VARCHAR(254) NOT NULL,
    caller_method     VARCHAR(254) NOT NULL,
    caller_line       CHAR(4) NOT NULL,
    event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
  );
COMMIT;

BEGIN;
CREATE TABLE logging_event_property
  (
    event_id       BIGINT NOT NULL,
    mapped_key        VARCHAR(254) NOT NULL,
    mapped_value      TEXT,
    PRIMARY KEY(event_id, mapped_key),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;

BEGIN;
CREATE TABLE logging_event_exception
  (
    event_id         BIGINT NOT NULL,
    i                SMALLINT NOT NULL,
    trace_line       VARCHAR(254) NOT NULL,
    PRIMARY KEY(event_id, i),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;

    细心的读者很容易发现logging_event的设计者提供了4个(arg0,arg1,arg2,arg3)扩展字段,本文就是实现往arg0字段写入内容,写入自定义的表同理。


1.新建测试的java工程,导入相应jar包。项目目录结构如下:

2.修改logback的配置文件logback.xml,引用我们自己编写的Appender类。以下为简化的配置文件,有兴趣的读者可以查阅详细配置文档。

<?xml version="1.0" encoding="UTF-8" ?>

<configuration>
    <appender name="DB" class="com.ldl.cn.MyAppender">
        <connectionSource
            class="ch.qos.logback.core.db.DriverManagerConnectionSource">
            <driverClass>com.mysql.jdbc.Driver</driverClass>
            <url>jdbc:mysql://localhost:3306/logback</url>
            <user>*******</user>
            <password>********</password>
        </connectionSource>
    </appender>

    <root level="ALL">
        <appender-ref ref="DB" />
    </root>
</configuration>

3.编写Appender类和SQLBuilder类。

Appender类源码:

package com.ldl.cn;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import ch.qos.logback.classic.db.DBHelper;
import ch.qos.logback.classic.db.names.DBNameResolver;
import ch.qos.logback.classic.db.names.DefaultDBNameResolver;
import ch.qos.logback.classic.spi.CallerData;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.IThrowableProxy;
import ch.qos.logback.classic.spi.StackTraceElementProxy;
import ch.qos.logback.classic.spi.ThrowableProxyUtil;
import ch.qos.logback.core.db.DBAppenderBase;

public class MyAppender extends DBAppenderBase<ILoggingEvent>{

       public MyAppender() {}
    
       protected String insertPropertiesSQL;
       protected String insertExceptionSQL;
       protected String insertSQL;
       protected static final Method GET_GENERATED_KEYS_METHOD;
       private DBNameResolver dbNameResolver;
       static final int TIMESTMP_INDEX = 1;
       static final int FORMATTED_MESSAGE_INDEX = 2;
       static final int LOGGER_NAME_INDEX = 3;
       static final int LEVEL_STRING_INDEX = 4;
       static final int THREAD_NAME_INDEX = 5;
       static final int REFERENCE_FLAG_INDEX = 6;
       static final int ARG0_INDEX = 7;
       static final int ARG1_INDEX = 8;
       static final int ARG2_INDEX = 9;
       static final int ARG3_INDEX = 10;
       static final int CALLER_FILENAME_INDEX = 11;
       static final int CALLER_CLASS_INDEX = 12;
       static final int CALLER_METHOD_INDEX = 13;
       static final int CALLER_LINE_INDEX = 14;
       static final int EVENT_ID_INDEX = 15;
       static final StackTraceElement EMPTY_CALLER_DATA = CallerData.naInstance();
       
          static
          {
            Method getGeneratedKeysMethod;
            try
            {
             getGeneratedKeysMethod = PreparedStatement.class.getMethod("getGeneratedKeys", (Class[])null);
            }
            catch (Exception ex) {
              getGeneratedKeysMethod = null;
            }
            GET_GENERATED_KEYS_METHOD = getGeneratedKeysMethod;
          }
          
          public void setDbNameResolver(DBNameResolver dbNameResolver) {
              this.dbNameResolver = dbNameResolver;
          }
          
             public void start()
             {
                if (this.dbNameResolver == null)
                 this.dbNameResolver = new DefaultDBNameResolver();
                this.insertExceptionSQL = SQLBuilder.buildInsertExceptionSQL(this.dbNameResolver);
                this.insertPropertiesSQL = SQLBuilder.buildInsertPropertiesSQL(this.dbNameResolver);
                this.insertSQL = SQLBuilder.buildInsertSQL(this.dbNameResolver);
                super.start();
             }
       
             @Override
            protected void subAppend(ILoggingEvent event, Connection connection, PreparedStatement insertStatement)
                    throws Throwable 
                   {
                          bindLoggingEventWithInsertStatement(insertStatement, event);
                          bindLoggingEventArgumentsWithPreparedStatement(insertStatement, event.getArgumentArray());
                          bindCallerDataWithPreparedStatement(insertStatement, event.getCallerData());
                         
                          int updateCount = insertStatement.executeUpdate();
                          if (updateCount != 1) {
                            addWarn("Failed to insert loggingEvent");
                         }
                       }
             
             
            @Override
            protected void secondarySubAppend(ILoggingEvent event, Connection connection, long eventId)
                    throws Throwable {
                // TODO Auto-generated method stub
                Map<String, String> mergedMap = mergePropertyMaps(event);
                insertProperties(mergedMap, connection, eventId);
                if (event.getThrowableProxy() != null) {
                    insertThrowable(event.getThrowableProxy(), connection, eventId);
                }
            }
            
            void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException
           {
              stmt.setLong(1, event.getTimeStamp());
              stmt.setString(2, event.getFormattedMessage());
              stmt.setString(3, event.getLoggerName());
              stmt.setString(4, event.getLevel().toString());
              stmt.setString(5, event.getThreadName());
              stmt.setShort(6, DBHelper.computeReferenceMask(event));
              stmt.setString(7, "yourString");
           }
            
              void bindLoggingEventArgumentsWithPreparedStatement(PreparedStatement stmt, Object[] argArray)
                        throws SQLException
                      {
                        int arrayLen = argArray != null ? argArray.length : 0;
                        
                        for (int i = 0; (i < arrayLen) && (i < 4); i++) {
                          stmt.setString(8 + i, asStringTruncatedTo254(argArray[i]));
                        }
                        if (arrayLen < 4) {
                          for (int i = arrayLen; i < 4; i++) {
                            stmt.setString(8 + i, null);
                          }
                        }
                      }
              
              String asStringTruncatedTo254(Object o) {
                    String s = null;
                     if (o != null) {
                       s = o.toString();
                    }
                    
                     if (s == null) {
                      return null;
                    }
                    if (s.length() <= 254) {
                      return s;
                    }
                     return s.substring(0, 254);
                  }
              
                 void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray)
                           throws SQLException
                         {
                            StackTraceElement caller = extractFirstCaller(callerDataArray);
                           
                            stmt.setString(11, caller.getFileName());
                            stmt.setString(12, caller.getClassName());
                            stmt.setString(13, caller.getMethodName());
                            stmt.setString(14, Integer.toString(caller.getLineNumber()));
                         }
                 
                 
                 private StackTraceElement extractFirstCaller(StackTraceElement[] callerDataArray) {
                        StackTraceElement caller = EMPTY_CALLER_DATA;
                        if (hasAtLeastOneNonNullElement(callerDataArray))
                          caller = callerDataArray[0];
                        return caller;
                     }
                 
                 private boolean hasAtLeastOneNonNullElement(StackTraceElement[] callerDataArray) {
                     return (callerDataArray != null) && (callerDataArray.length > 0) && (callerDataArray[0] != null);
                 }

                 Map<String, String> mergePropertyMaps(ILoggingEvent event) {
                      Map<String, String> mergedMap = new HashMap();
                     
                     Map<String, String> loggerContextMap = event.getLoggerContextVO().getPropertyMap();
                     
                      Map<String, String> mdcMap = event.getMDCPropertyMap();
                     if (loggerContextMap != null) {
                        mergedMap.putAll(loggerContextMap);
                     }
                      if (mdcMap != null) {
                        mergedMap.putAll(mdcMap);
                     }
                     
                      return mergedMap;
                   }
                 
            @Override
            protected Method getGeneratedKeysMethod() {
                // TODO Auto-generated method stub
                return GET_GENERATED_KEYS_METHOD;
            }
        
            @Override
            protected String getInsertSQL() {
                // TODO Auto-generated method stub
                return this.insertSQL;
            }
    
          protected void insertProperties(Map<String, String> mergedMap, Connection connection, long eventId) throws SQLException
          {
             Set<String> propertiesKeys = mergedMap.keySet();
             if (propertiesKeys.size() > 0) {
               PreparedStatement insertPropertiesStatement = null;
              try {
                 insertPropertiesStatement = connection.prepareStatement(this.insertPropertiesSQL);
        
                 for (String key : propertiesKeys) {
                   String value = (String)mergedMap.get(key);
                  
                  insertPropertiesStatement.setLong(1, eventId);
                   insertPropertiesStatement.setString(2, key);
                   insertPropertiesStatement.setString(3, value);
                  
                   if (this.cnxSupportsBatchUpdates) {
                     insertPropertiesStatement.addBatch();
                  } else {
                     insertPropertiesStatement.execute();
                  }
                }
                
                 if (this.cnxSupportsBatchUpdates) {
                   insertPropertiesStatement.executeBatch();
                }
              } finally {
                 ch.qos.logback.core.db.DBHelper.closeStatement(insertPropertiesStatement);
              }
            }
          }
          
                 void updateExceptionStatement(PreparedStatement exceptionStatement, String txt, short i, long eventId)
                           throws SQLException
                         {
                           exceptionStatement.setLong(1, eventId);
                            exceptionStatement.setShort(2, i);
                            exceptionStatement.setString(3, txt);
                            if (this.cnxSupportsBatchUpdates) {
                              exceptionStatement.addBatch();
                           } else {
                              exceptionStatement.execute();
                           }
                         }
          
             short buildExceptionStatement(IThrowableProxy tp, short baseIndex, PreparedStatement insertExceptionStatement, long eventId)
                       throws SQLException
                     {
                        StringBuilder buf = new StringBuilder();
                        ThrowableProxyUtil.subjoinFirstLine(buf, tp);
                        baseIndex = (short)(baseIndex + 1);updateExceptionStatement(insertExceptionStatement, buf.toString(), baseIndex, eventId);
                       
                   
                        int commonFrames = tp.getCommonFrames();
                        StackTraceElementProxy[] stepArray = tp.getStackTraceElementProxyArray();
                        for (int i = 0; i < stepArray.length - commonFrames; i++) {
                         StringBuilder sb = new StringBuilder();
                          sb.append('\t');
                          ThrowableProxyUtil.subjoinSTEP(sb, stepArray[i]);
                          baseIndex = (short)(baseIndex + 1);updateExceptionStatement(insertExceptionStatement, sb.toString(), baseIndex, eventId);
                       }
                       
                        if (commonFrames > 0) {
                          StringBuilder sb = new StringBuilder();
                          sb.append('\t').append("... ").append(commonFrames).append(" common frames omitted");
                         
                          baseIndex = (short)(baseIndex + 1);updateExceptionStatement(insertExceptionStatement, sb.toString(), baseIndex, eventId);
                       }
                       
                       return baseIndex;
                     }
          
             protected void insertThrowable(IThrowableProxy tp, Connection connection, long eventId)
                       throws SQLException
                     {
                        PreparedStatement exceptionStatement = null;
                       try {
                          exceptionStatement = connection.prepareStatement(this.insertExceptionSQL);
                         
                          short baseIndex = 0;
                         while (tp != null) {
                            baseIndex = buildExceptionStatement(tp, baseIndex, exceptionStatement, eventId);
                           
                            tp = tp.getCause();
                         }
                         
                          if (this.cnxSupportsBatchUpdates) {
                            exceptionStatement.executeBatch();
                         }
                       } finally {
                          ch.qos.logback.core.db.DBHelper.closeStatement(exceptionStatement);
                       }
                     }
          
}

SQLBuilder类源码(该类自带,默认为protected类型,外部调用会报错,故贴出):

package com.ldl.cn;

import ch.qos.logback.classic.db.names.ColumnName;
import ch.qos.logback.classic.db.names.DBNameResolver;
import ch.qos.logback.classic.db.names.TableName;

public class SQLBuilder
{

 public SQLBuilder()
 {
 }

 static String buildInsertPropertiesSQL(DBNameResolver dbNameResolver)
 {
     StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
     sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT_PROPERTY)).append(" (");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.EVENT_ID)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.MAPPED_KEY)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.MAPPED_VALUE)).append(") ");
     sqlBuilder.append("VALUES (?, ?, ?)");
     return sqlBuilder.toString();
 }

 static String buildInsertExceptionSQL(DBNameResolver dbNameResolver)
 {
     StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
     sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT_EXCEPTION)).append(" (");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.EVENT_ID)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.I)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.TRACE_LINE)).append(") ");
     sqlBuilder.append("VALUES (?, ?, ?)");
     return sqlBuilder.toString();
 }

 static String buildInsertSQL(DBNameResolver dbNameResolver)
 {
     StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
     sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT)).append(" (");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.TIMESTMP)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.FORMATTED_MESSAGE)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.LOGGER_NAME)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.LEVEL_STRING)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.THREAD_NAME)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.REFERENCE_FLAG)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG0)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG1)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG2)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG3)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_FILENAME)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_CLASS)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_METHOD)).append(", ");
     sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_LINE)).append(") ");
     sqlBuilder.append("VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     return sqlBuilder.toString();
 }
}

4.测试

查看数据库:

OK!

丿SeeYouAgain
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
logback扩展字段
weixin_38815505的博客
10-15 1822
利用logback的MDC进行扩展 文档 MDC类： package org.slf4j; public class MDC { // 将上下文的值作为 MDC 的 key 放到线程上下的 map 中 public static void put(String key, String val); // 通过 key 获取上下文标识 public static String g...
logback将日志写入MySQL数据库
weixin_40263219的博客
11-22 1933
logback将日志写入MySQL数据库，出现no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]]问题背景信息解决办法 背景信息 在springboot 项目中，logback将日志写入MySQL数据库，出现"no applicable action for [springProfile], current ElementPath is [[configuration
logback 记录到mysql_使用Logback把日志记录到数据库中
weixin_42676678的博客
01-27 487
先看一下日志被记录到数据库中的效果图：引入logback依赖包：dependencies{compile group: 'ch.qos.logback', name: 'logback-core', version: '1.2.1'compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'compile gr...
logback 记录到mysql_logback日志写入mysql数据库
weixin_32557927的博客
01-19 361
1,创建springBoot 项目 在pom中引入dbcp 以及mysqlcommons-dbcpcommons-dbcp20030825.184428commons-poolcommons-poolmysqlmysql-connector-javaruntime2,添加配置文件${CONSOLE_LOG_PATTERN}com.mysql.cj.jdbc.Driverjdbc:mysql://...
Logback输出日志到自定义MySQL数据库（重写DBAppender）
DeepZ的博客
06-19 9738
目录 前言：需求 1 项目总览 2 原始logback输出日志至MySQL数据库配置 3 源码解析 3.1 names 3.2 script 3.3DBAppender 3.3.1 数据格式化方法 3.3.2 数据插入以及入口方法 3.4SQLBuilder 3.4 其他 4 重写源码 4.1 数据库表设计 4.2 数据库插入语句生成 ...
Java博客管理系统源码-毕业设计.zip
10-26
【Java博客管理系统源码-毕业设计.zip】是一个包含完整的Java博客管理系统的源代码，适合用于毕业设计或教学实践。这个项目通常涵盖了Web开发中的多个重要技术领域，包括后端服务、前端界面、数据库管理和用户交互等...
基于springboot的在线教育网站源码.zip
11-29
《基于SpringBoot的在线教育网站源码解析》 在当今数字化时代，教育行业正在逐步向线上转型，基于SpringBoot框架的在线教育网站源码成为开发者和教育从业者关注的焦点。SpringBoot以其轻量级、快速开发的特点，为...
管理系统的源码
12-23
- `src/main/java`：存放Java源代码，按照Maven或Gradle的标准目录结构，如`com.example.cms`。 - `src/main/resources`：配置文件、数据库连接信息、静态资源等存放于此。 - `src/main/webapp`：如果是传统的Web...
smbms-web（狂神视频代码）.zip
10-24
【smbms-web（狂神视频代码）】是狂神在B站上分享的一套视频教程的源码，主要用于讲解Web开发技术。这个压缩包包含了名为`smbms-web`的项目，这通常是一个Web应用程序的后台管理系统。通过分析这个项目，我们可以...
building.control
03-16
在IT行业中，"building.control"这个主题通常指的是建筑物自动化控制系统，它涉及到利用计算机技术、网络通信和...开发者可以通过查阅这些源代码，学习实际的项目结构、编程实践以及如何将上述知识点应用于实际场景。
Logback 使用手册
12-13
比Log4j更好的Java日志工具库，性能和特性都有很大提高，是Log4j很好的替代。
logback保存日志到数据库主要代码.zip
07-22
springboot项目，使用logback保存日志到数据库，非自增主键id，insert使用的是UUID
logback-ext:Logback日志库的扩展
05-27
登录扩展 Logback日志库的扩展主要适用于针对Amazon Web Services的附加程序，包括CloudWatch Logs，DynamoDB，Kinesis，SNS和SQS附加程序。 还包含基于LMAX Disrupotr的高性能异步附加器和某些实用程序，例如Jackson JSON编码器。 使用Logback扩展 Logback Extensions需要Java 7或更高版本。 在项目的依赖管理中包括所需的模块，并使用Logback的XML配置或Java API配置附加器或编码器。 模组 所有模块都属于org.eluder.logback组。 有关特定文档，请参见每个模块。 扩展核心模块： AWS核心模块： 杰克逊JSON编码器： LMAX Disruptor附加器： CloudWatch附加程序： DynamoDB附加程序： Kinesis追加器： SNS
logback 持久化mysql_mysql单表回复工具binlogback_mysql
weixin_42514310的博客
01-27 163
mysql单表恢复工具binlogback在维护mysql的经验中，很多时候我们需要进行单表恢复，以应对误操作 或者sql注入引起的故障，本人也在实际的工作中遇到若干次开发误操作需要恢复数据的情况。为了方便的恢复数据，所以写了一个逆向解析binlog的工具，能够方便的进行单表恢复操作。目前仅支持5.5，binlog格式必须为row格式工具下载地址：https://github.com/visici...
手写logback_logback日志写入mysql自定义表
weixin_35385921的博客
12-31 405
1，创建springboot项目(同上)2，pom中添加配置(同上)3，logback 中 ch.qos.logback.classic.db 包下的所有源代码 主要这下边的源码看看4，重写 DBAppender 类package com.liudandan.logbackmysql.controller.config;import ch.qos.logback.classic.spi.*;imp...
logback 使用mysql 性能差_logback日志写入mysql自定义表(根据日志的级别分别存入不同的数据库中)...
weixin_33417371的博客
01-19 372
细节看上一篇1，先看DBAppenderpackage com.liudandan.logbackmysql.controller.config;import ch.qos.logback.classic.db.names.DBNameResolver;import ch.qos.logback.classic.db.names.DefaultDBNameResolver;import ch.q...
c mysql错误处理_Mysql DBAppender 正确配置方法 以及错误处理
weixin_39525812的博客
01-26 197
第一必要条件：jar 包所需要的包：logback-core-0.9.8.jarlogback-classic-0.9.8.jarslf4j-api-1.6.8.jar写该文时，最新版本为 logback的版本为1.1.2. 对应的Slf4j-api 为 1.7.6 (两种配方都可以)第二必要条件：数据库表创建脚本。包括stackoverflow上的很多朋友在内的coder都被官方中提到的 get...
深入理解 SpringBoot 日志框架：从入门到高级应用——（三）Logback 输出日志到 MySQL 数据库
最新发布
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
06-16 2386
Logback 输出日志到 MySQL 数据库
springboot使用logback将日志数据写入mysql数据库的代码
03-23
以下是使用logback将日志数据写入mysql数据库的示例代码： 1. 添加依赖 在pom.xml文件中添加以下依赖： ``` <groupId>ch.qos.logback <artifactId>logback-classic <version>1.2.3 <groupId>mysql ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值