logback日志自定义DBAppender

已于 2024-09-11 17:29:06 修改
阅读量638 收藏 1
点赞数
分类专栏： java 文章标签： logback spring java
于 2023-03-09 10:40:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34533703/article/details/129417767
版权
该文详细介绍了logback-spring-prod.xml配置文件的内容，包括日志级别设定、控制台输出格式、日志异步到数据库的实现，以及如何避免读取不到yaml属性的问题。同时，展示了自定义的DBAppender如何捕获并存储异常信息到数据库。
摘要由CSDN通过智能技术生成

  1. 日志配置文件logback-spring-prod.xml 日志配置文件名称尽量避免默认的，否则有可能读取不到yaml的属性

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。
     当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="10 seconds">

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--1. 输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <springProperty scope="context" name="springAppName" source="spring.application.name"/>
    <springProperty scope="context" name="serverName" source="logging.serverName"/>
    <springProperty scope="context" name="post" source="logging.post"/>
    <springProperty scope="context" name="dbName" source="logging.dbName"/>
    <springProperty scope="context" name="userName" source="logging.userName"/>
    <springProperty scope="context" name="password" source="logging.password"/>
    <springProperty scope="context" name="logLevel" source="logging.logLevel"/>
    <!--日志异步到数据库  -->
    <appender name="dbAppender" class="com.xx.common.extension.CustomDBAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>${logLevel}</level>
        </filter>
        <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">
            <dataSource class="org.apache.commons.dbcp.BasicDataSource">
                <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
                <url>jdbc:mysql://${serverName}:${post}/${dbName}?useUnicode=true;characterEncoding=UTF-8;useSSL=false;serverTimezone=Asia/Shanghai</url>
                <username>${userName}</username>
                <password>${password}</password>
            </dataSource>
        </connectionSource>
    </appender>

    <springProperty scope="context" name="loggerName" source="logging.logName"/>


    <!-- root的默认level是DEBUG -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="dbAppender"/>
    </root>

</configuration>

  1. yaml配置

logging:
  config: classpath:logback-spring-prod.xml
  serverName: xx.xx.xx.xx
  post: 3306
  dbName: dbName
  userName: userName
  password: password
  logLevel: ERROR

  1. CustomDBAppender 复制DBAppender的代码，根据自己的需求修改  


public class CustomDBAppender extends DBAppenderBase<ILoggingEvent> {

    protected String insertExceptionSQL;
    protected String insertSQL;
    protected static final Method GET_GENERATED_KEYS_METHOD;
    private DBNameResolver dbNameResolver;

    static final StackTraceElement EMPTY_CALLER_DATA = CallerData.naInstance();

    public CustomDBAppender() {
    }

    public void setDbNameResolver(DBNameResolver dbNameResolver) {
        this.dbNameResolver = dbNameResolver;
    }

    @Override
    public void start() {
        if (this.dbNameResolver == null) {
            this.dbNameResolver = new DefaultDBNameResolver();
        }

        this.insertExceptionSQL = SQLBuilder.buildInsertExceptionSQL(this.dbNameResolver);

        this.insertSQL = SQLBuilder.buildInsertSQL(this.dbNameResolver);
        super.start();
    }

    @Override
    protected void subAppend(ILoggingEvent event, Connection connection, PreparedStatement insertStatement) throws Throwable {
        this.bindLoggingEventWithInsertStatement(insertStatement, event);
        this.bindLoggingEventArgumentsWithPreparedStatement(insertStatement, event.getArgumentArray());
        StackTraceElement[] stackTraceElements = event.getCallerData();
        if (event.getThrowableProxy() != null) {
            if (event.getThrowableProxy().getCause()!=null){
                StackTraceElementProxy[] stackTraceElementProxies =  event.getThrowableProxy().getCause().getStackTraceElementProxyArray();
                if (stackTraceElementProxies!=null&&stackTraceElementProxies.length>0) {
                    for (StackTraceElementProxy item : stackTraceElementProxies
                    ) {
                        if (item.getStackTraceElement().getClassName().indexOf("com.xx") >= 0 && item.getStackTraceElement().getLineNumber() > 0) {
                            stackTraceElements[0] = item.getStackTraceElement();
                            break;
                        }
                    }
                }
            }
        }
        this.bindCallerDataWithPreparedStatement(insertStatement, stackTraceElements);
        int updateCount = insertStatement.executeUpdate();
        if (updateCount != 1) {
            this.addWarn("Failed to insert loggingEvent");
        }

    }

    @Override
    protected void secondarySubAppend(ILoggingEvent event, Connection connection, long eventId) throws Throwable {
        /*Map<String, String> mergedMap = this.mergePropertyMaps(event);
        this.insertProperties(mergedMap, connection, eventId);*/
        if (event.getThrowableProxy() != null) {
            this.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));
    }

    void bindLoggingEventArgumentsWithPreparedStatement(PreparedStatement stmt, Object[] argArray) throws SQLException {
        int arrayLen = argArray != null ? argArray.length : 0;

        int i;
        for(i = 0; i < arrayLen && i < 4; ++i) {
            stmt.setString(7 + i, this.asStringTruncatedTo254(argArray[i]));
        }

        if (arrayLen < 4) {
            for(i = arrayLen; i < 4; ++i) {
                stmt.setString(7 + i, (String)null);
            }
        }

    }

    String asStringTruncatedTo254(Object o) {
        String s = null;
        if (o != null) {
            s = o.toString();
        }

        if (s == null) {
            return null;
        } else {
            return s.length() <= 254 ? s : s.substring(0, 254);
        }
    }

    void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray) throws SQLException {
        StackTraceElement caller = this.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 (this.hasAtLeastOneNonNullElement(callerDataArray)) {
            caller = callerDataArray[0];
        }

        return caller;
    }

    private boolean hasAtLeastOneNonNullElement(StackTraceElement[] callerDataArray) {
        return callerDataArray != null && callerDataArray.length > 0 && callerDataArray[0] != null;
    }



    @Override
    protected Method getGeneratedKeysMethod() {
        return GET_GENERATED_KEYS_METHOD;
    }

    @Override
    protected String getInsertSQL() {
        return this.insertSQL;
    }



    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 {
        try{
            StringBuilder buf = new StringBuilder();
            ThrowableProxyUtil.subjoinFirstLine(buf, tp);
            this.updateExceptionStatement(insertExceptionStatement, buf.toString(), baseIndex++, eventId);
            int commonFrames = tp.getCommonFrames();
            StackTraceElementProxy[] stepArray = tp.getStackTraceElementProxyArray();

            for(int i = 0; i < stepArray.length; ++i) {
                StringBuilder sb = new StringBuilder();
                sb.append('\t');
                ThrowableProxyUtil.subjoinSTEP(sb, stepArray[i]);
                this.updateExceptionStatement(insertExceptionStatement, sb.toString(), baseIndex++, eventId);
            }


        }catch (Exception e){
            System.out.println("11");
        }
        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(true) {
                if (tp == null) {
                    if (this.cnxSupportsBatchUpdates) {
                        exceptionStatement.executeBatch();
                    }
                    break;
                }
                if (tp.getCause()!=null){
                    tp = tp.getCause();
                }
                baseIndex = this.buildExceptionStatement(tp, baseIndex, exceptionStatement, eventId);
                tp = tp.getCause();
            }
        } finally {
            ch.qos.logback.core.db.DBHelper.closeStatement(exceptionStatement);
        }

    }

    static {
        Method getGeneratedKeysMethod;
        try {
            getGeneratedKeysMethod = PreparedStatement.class.getMethod("getGeneratedKeys", (Class[])null);
        } catch (Exception var2) {
            getGeneratedKeysMethod = null;
        }

        GET_GENERATED_KEYS_METHOD = getGeneratedKeysMethod;
    }
}

  1. SQLBuilder


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

表结构 logging_event.sql


SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for logging_event
-- ----------------------------
DROP TABLE IF EXISTS `logging_event`;
CREATE TABLE `logging_event`  (
  `timestmp` bigint(20) NOT NULL,
  `formatted_message` longtext CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `logger_name` varchar(254) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `level_string` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `thread_name` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci DEFAULT NULL,
  `reference_flag` smallint(6) DEFAULT NULL,
  `arg0` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci DEFAULT NULL,
  `arg1` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci DEFAULT NULL,
  `arg2` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci DEFAULT NULL,
  `arg3` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci DEFAULT NULL,
  `caller_filename` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `caller_class` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `caller_method` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `caller_line` char(4) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  `event_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `create_time` datetime(0) DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`event_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 504 CHARACTER SET = latin1 COLLATE = latin1_swedish_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

表结构 logging_event_exception.sql


SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for logging_event_exception
-- ----------------------------
DROP TABLE IF EXISTS `logging_event_exception`;
CREATE TABLE `logging_event_exception`  (
  `event_id` bigint(20) NOT NULL,
  `i` smallint(6) NOT NULL,
  `trace_line` varchar(254) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
  PRIMARY KEY (`event_id`, `i`) USING BTREE,
  CONSTRAINT `logging_event_exception_ibfk_1` FOREIGN KEY (`event_id`) REFERENCES `logging_event` (`event_id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = latin1 COLLATE = latin1_swedish_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;
logback 存数据库_logback实时记录日志 保存入库
weixin_29499957的博客
01-14 1167
需求:收集系统中打印的日志，例如 log.info(), log.warn(),log.infor(),log.debug()等等，并且做入库处理。public static void main(String[] args) {System.setProperty("es.set.netty.runtime.available.processors", "false");SpringApplica...
logback扩展字段
weixin_38815505的博客
10-15 1875
利用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 日志记录到数据库中
baobeituping的专栏
11-10 370
&lt;!--不采用连接池的配置--&gt;   &lt;appender name="DB1" class="ch.qos.logback.classic.db.DBAppender"&gt;        &lt;connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource"&gt;           ..
【SpringBoot】【log】 自定义logback日志配置
最新发布
weixin_66568937的博客
11-21 1498
SpringBoot官方建议使用logback-spring.xml作为logback框架的自定义日志配置文件，使用logback-spring.xml而不是logback.xml，因为带-spring后缀的配置文件可以使用使用Spring扩展profile支持，提供profile多环境日志输出得功能。日志记录器（Logger）的行为是分等级的，日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出。
Logback写入MySQL的源码扩展
SeeYouAgain的博客
09-01 1291
Logback是一个开源日志组件,为取代log4j而生。 Logback主要分为三个模块:logback-core,logback-classic和logback-access。 Logback有着许多独特而实用的特性,如Marker、参数化记录语句、条件化堆栈跟踪和强大的事件过滤等。在此不详述,有兴趣的朋友可以查看官方文档。 入正题,在很多实际项目开发中,往往会有...
Logback自定义DBAppender输出日志
weixin_60498767的博客
01-23 1983
自定义DBAppender输出日志到数据库，附带常见问题的解决思路，以及logback漏洞的解决办法
Logback自定义DBAppender保存系统日志到数据库
Aesop的博客
06-09 1989
可以根据实际情况增加或减少和修改字段。
logback将日志写入MySQL数据库
weixin_40263219的博客
11-22 2003
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数据库（重写DBAppender）
热门推荐
DeepZ的博客
06-19 1万+
目录 前言：需求 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 数据库插入语句生成 ...
logback自定义的DBappender可以注册为bean吗
09-27
Logback的DBAppender（数据库日志适配器）是一种用于将日志信息持久化到数据库中的组件，通常在需要长期存储和分析日志数据的应用中使用。它允许您配置一个特定的数据库连接，并自定义日志条目的插入操作。 在...
自定义日志logback
ADbyCool的博客
08-06 260
跟杨春娟学SpringBoot笔记：自定义日志logback 完成：第一遍 1.如何自定义配置多个日志文件？ 步骤一:在application-dev.yml中添加 logging: config: classpath:springboot-log.xml 步骤二：src/main/resources下新建springboot-log.xml springboot-log.xml <?xml version="1.0" encoding="UTF-8"?> <configuratio
logback系列之五：输出日志到数据库-DBAppender生成的表
Sunny
08-23 9299
需要手动添加 # Logback: the reliable, generic, fast and flexible logging framework. # Copyright (C) 1999-2010, QOS.ch. All rights reserved. # # See http://logback.qos.ch/license.html for the applicable lic
logback 存数据库_SpringBoot Logback日志记录到数据库的实现方法
weixin_30082367的博客
12-24 691
对于日志的处理，有时候需要把符合条件的日志计入数据库中一、添加pom依赖org.springframework.bootspring-boot-starter-webcommons-dbcpcommons-dbcp1.4mysqlmysql-connector-javaruntime二、创建logback配置文件%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5le...
logback 自定义
CA
12-18 1357
Overview自定义Converter，通过conversionRule或者layout实现注入 常规使用Logback的方式不在本篇wiki的范围内 本文旨在解决我写的common_util.log组件在包装slf4j后丢失行号的问题，这是给出的logback解决方案LineConverter包装logback + slf4j之后，使用会丢失行号 // 注入Converter，全局覆盖
logback自定义转换的问题
weixin_30248399的博客
11-21 365
上个星期领导交给我一个任务,就是写logback自定义转换实现以下要求 [IP][文件名][行号][YYMMDD][HHMMSS.sss][线程名称][socket号][代码包和函数名.行号]-[卡号|单位|商户|终端|交易类型][message] eg： 输出结果[192.168.1.134][comm.20880.log][100][16-11-07][19:20:01.002]...
logback 记录到mysql_使用Logback把日志记录到数据库中
weixin_42676678的博客
01-27 546
先看一下日志被记录到数据库中的效果图：引入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 403
1,创建springBoot 项目 在pom中引入dbcp 以及mysqlcommons-dbcpcommons-dbcp20030825.184428commons-poolcommons-poolmysqlmysql-connector-javaruntime2,添加配置文件${CONSOLE_LOG_PATTERN}com.mysql.cj.jdbc.Driverjdbc:mysql://...
logback自定义生成DB日志（java环境）
只会写bug的靓仔的博客
02-03 1642
实际上这个东西的核心就是设置一个预编译的sql，也就是实现subAppend(ILoggingEvent event, Connection connection, PreparedStatement stmt)方法，就是jdbc的简单应用，理解过程就很简单。
logback自定义日志文件
weixin_39300480的博客
07-29 1201
一、自定义文件路径 1、application.yml 添加配置 spring: application: name: test logging: config: path: logs/${spring.application.name} 2、logback-spring.xml 添加配置 <springProperty scop="Context" na...
012_logback中的DBAppender
aihiao的专栏
03-21 1165
1. DBAppender把记录事件写入数据库的三张表。三张表分别是logging_event、logging_event_property和logging_event_exception。在使用DBAppender之前, 这三张表必须已经被创建。Logback提供创建这些表的SQL脚本, 位于logback-classic/src/main/java/ch/qos/logback/classic/db/script目录, 对各个流行数据库分别有一个脚本。如果没有你想用的数据库的脚本, 那就按照现有的脚本自
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>