devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Logback输出日志到自定义MySQL数据库（重写DBAppender）_logback日志输出到mysql数据库

作者：AllinToyou | 2024-03-25 22:05:26

赞

踩

logback日志输出到mysql数据库

目录

前言：需求

1  项目总览

2  原始logback输出日志至MySQL数据库配置

3  源码解析

3.1  names 

3.2  script

3.3  DBAppender

3.3.1  数据格式化方法

3.3.2  数据插入以及入口方法

3.4  SQLBuilder

3.4  其他

4  重写源码 

4.1  数据库表设计

4.2  数据库插入语句生成

4.3  数据格式化

4.4  修改后代码 （MyDBAppender.java）

4.5  运行测试

5  总结

附：

前言：需求

在一个系统开发过程中，日志系统和测试系统必不可少，在整个开发流程中扮演着及其重要的角色。在现有的主流日志框架中，有log4j,slf4j和logback等，本着买新不买旧的原则，在系统中采用了logback＋slf4j的日志框架。

在配置过程中，可以实现日志实时格式化显示在console中，也可以分时间分大小记录到文件中。因为项目中需要将日志实时记录到MySQL数据库中，查找了很多资料，遇到很多问题，基本都在配置文件中倒下。

以下，将分享两种记录日志至MySQL数据库中的方式，其一是根据logback原始配置，其二是自定义数据库表，记录日志。

1  项目总览

2  原始logback输出日志至MySQL数据库配置

  1.     <!-- 输出日志到数据库 -->
  2.     <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
  3.         <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
  4.             <driverClass>com.mysql.cj.jdbc.Driver</driverClass>
  5.             <url>jdbc:mysql://127.0.0.1:3306/log?serverTimezone=UTC</url>
  6.             <user>root</user>
  7.             <password>z111111</password>
  8.         </connectionSource>
  9.     </appender>

此上代码段，为输出日志到MySQL数据库中的配置，其中<appender> 标签中 class的具体值，指向处理日志输出至数据库中的具体类，同时，在数据库连接的配置，没有用到数据库连接池，在查询各种资料并试验后，使用数据库连接池的都无法正常运行。

logback-text.xml 配置文件源码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration debug="false">
  3.     <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
  4.     <property name="LOG_HOME" value="/home" />
  5.  
  6.     <property name="CONSOLE_LOG_PATTERN"
  7.               value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) |- %highlight(%-5level) | %blue(%thread) | %blue(%file:%line) | %green(%logger) - %cyan(%msg%n)"/>
  8.     <property name="FILE_LOG_PATTERN"
  9.               value="%d{yyyy-MM-dd HH:mm:ss} |- %-5level - %thread - %file:%line - %logger : %msg%n"/>
  10.  
  11.  
  12.     <!-- 控制台输出 -->
  13.     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  14.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  15.             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
  16.             <pattern>${CONSOLE_LOG_PATTERN}</pattern>
  17.         </encoder>
  18.     </appender>
  19.  
  20.     <!-- 输出日志到数据库 -->
  21.     <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
  22.         <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
  23.             <driverClass>com.mysql.cj.jdbc.Driver</driverClass>
  24.             <url>jdbc:mysql://127.0.0.1:3306/log?serverTimezone=UTC</url>
  25.             <user>root</user>
  26.             <password>z111111</password>
  27.         </connectionSource>
  28.     </appender>
  29.  
  30.     <!-- 日志输出级别 -->
  31.     <root level="DEBUG">
  32.         <appender-ref ref="STDOUT" />
  33.         <appender-ref ref="FILE_ALL" />
  34.         <appender-ref ref="FILE_ERROR"/>
  35.         <appender-ref ref="DB"/>
  36.     </root>
  37. </configuration>

MySQL数据库表创建脚本在 ch.qos.logback.classic.db.scrip 包下，选择mysql.sql 内容如下，运行并创建数据库表：

  1. BEGIN;
  2. DROP TABLE IF EXISTS logging_event_property;
  3. DROP TABLE IF EXISTS logging_event_exception;
  4. DROP TABLE IF EXISTS logging_event;
  5. COMMIT;
  6.  
  7.  
  8. BEGIN;
  9. CREATE TABLE logging_event 
  10.   (
  11.     timestmp         BIGINT NOT NULL,
  12.     formatted_message  TEXT NOT NULL,
  13.     logger_name       VARCHAR(254) NOT NULL,
  14.     level_string      VARCHAR(254) NOT NULL,
  15.     thread_name       VARCHAR(254),
  16.     reference_flag    SMALLINT,
  17.     arg0              VARCHAR(254),
  18.     arg1              VARCHAR(254),
  19.     arg2              VARCHAR(254),
  20.     arg3              VARCHAR(254),
  21.     caller_filename   VARCHAR(254) NOT NULL,
  22.     caller_class      VARCHAR(254) NOT NULL,
  23.     caller_method     VARCHAR(254) NOT NULL,
  24.     caller_line       CHAR(4) NOT NULL,
  25.     event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
  26.   );
  27. COMMIT;
  28.  
  29. BEGIN;
  30. CREATE TABLE logging_event_property
  31.   (
  32.     event_id	      BIGINT NOT NULL,
  33.     mapped_key        VARCHAR(254) NOT NULL,
  34.     mapped_value      TEXT,
  35.     PRIMARY KEY(event_id, mapped_key),
  36.     FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  37.   );
  38. COMMIT;
  39.  
  40. BEGIN;
  41. CREATE TABLE logging_event_exception
  42.   (
  43.     event_id         BIGINT NOT NULL,
  44.     i                SMALLINT NOT NULL,
  45.     trace_line       VARCHAR(254) NOT NULL,
  46.     PRIMARY KEY(event_id, i),
  47.     FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  48.   );
  49. COMMIT;

测试类如下： 

  1. public class BlogAction {
  2.  
  3.     private static Logger logger = LoggerFactory.getLogger(BlogAction.class);
  4.     
  5.     public static void main(String[] args) {
  6.         for(int i = 0 ; i < 3 ; i++){
  7.             logger.info("logback So"+i);
  8.             logger.error("logback Down");
  9.             logger.debug("debug");
  10.         }
  11.  
  12.         logger.info("logback So44");
  13.     }
  14. }

运行后，控制台显示如下

数据库中数据如下所示

3  源码解析

在上面第一条试验后，我们发现，在实际项目开发中，项目日志并不需要很多内容，如此繁多的表项反而会耽误我们阅读查看的时间和效率，于是在考虑到实际需要，我想着能不能将数据库表自定义，仅保留下一部分重要信息，以便阅读。

在此之前，反复查看 logback 中 ch.qos.logback.classic.db 包下的所有源代码，结构如下图：

在db包下，有names 、script 、和DBAppender 、DBHelper 、SQLBuilder文件，下面分别介绍其作用：

3.1  names 

此包下含有几个文件，包含枚举类和一些方法，总结来说就是，这几个文件的作用为，规定数据库表名和数据库表中各个表项的名字，在枚举类ColumnName中包含三个表中各个表项的名字

  1. package ch.qos.logback.classic.db.names;
  2.  
  3. public enum ColumnName {
  4.  
  5.     EVENT_ID,
  6.  
  7.     TIMESTMP, FORMATTED_MESSAGE, LOGGER_NAME, LEVEL_STRING, THREAD_NAME, REFERENCE_FLAG, ARG0, ARG1, ARG2, ARG3, CALLER_FILENAME, CALLER_CLASS, CALLER_METHOD, CALLER_LINE,
  8.  
  9.     // MDC
  10.     MAPPED_KEY, MAPPED_VALUE,
  11.  
  12.     I, TRACE_LINE;
  13. }

在枚举类TableName中包含三个表的名字

  1. /**
  2.  * @author Tomasz Nurkiewicz
  3.  * @since 0.9.19
  4.  */
  5. public enum TableName {
  6.  
  7.     LOGGING_EVENT, LOGGING_EVENT_PROPERTY, LOGGING_EVENT_EXCEPTION
  8.  
  9. }

其余的类中包含一些必须的方法，例如将枚举类中数据转换为小写字母的表名等方法。

3.2  script

此包下包含的所有文件为SQL脚本，对应不同的数据库，有不同的数据库表创建脚本。

3.3  DBAppender

此类，为重点，其继承自 DBAppenderBase<ILoggingEvent> ，实现了将日志数据插入数据库中的方法，源码如下：

  1. package ch.qos.logback.classic.db;
  2.  
  3. import static ch.qos.logback.core.db.DBHelper.closeStatement;
  4.  
  5. import java.lang.reflect.Method;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.SQLException;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11. import java.util.Set;
  12.  
  13. import ch.qos.logback.classic.db.names.DBNameResolver;
  14. import ch.qos.logback.classic.db.names.DefaultDBNameResolver;
  15. import ch.qos.logback.classic.spi.*;
  16. import ch.qos.logback.core.CoreConstants;
  17. import ch.qos.logback.core.db.DBAppenderBase;
  18.  
  19. /**
  20.  * The DBAppender inserts logging events into three database tables in a format
  21.  * independent of the Java programming language.
  22.  *
  23.  * For more information about this appender, please refer to the online manual
  24.  * at http://logback.qos.ch/manual/appenders.html#DBAppender
  25.  *
  26.  * @author Ceki G&uuml;lc&uuml;
  27.  * @author Ray DeCampo
  28.  * @author S&eacute;bastien Pennec
  29.  */
  30. public class DBAppender extends DBAppenderBase<ILoggingEvent> {
  31.     protected String insertPropertiesSQL;
  32.     protected String insertExceptionSQL;
  33.     protected String insertSQL;
  34.     protected static final Method GET_GENERATED_KEYS_METHOD;
  35.  
  36.     private DBNameResolver dbNameResolver;
  37.  
  38.     static final int TIMESTMP_INDEX = 1;
  39.     static final int FORMATTED_MESSAGE_INDEX = 2;
  40.     static final int LOGGER_NAME_INDEX = 3;
  41.     static final int LEVEL_STRING_INDEX = 4;
  42.     static final int THREAD_NAME_INDEX = 5;
  43.     static final int REFERENCE_FLAG_INDEX = 6;
  44.     static final int ARG0_INDEX = 7;
  45.     static final int ARG1_INDEX = 8;
  46.     static final int ARG2_INDEX = 9;
  47.     static final int ARG3_INDEX = 10;
  48.     static final int CALLER_FILENAME_INDEX = 11;
  49.     static final int CALLER_CLASS_INDEX = 12;
  50.     static final int CALLER_METHOD_INDEX = 13;
  51.     static final int CALLER_LINE_INDEX = 14;
  52.     static final int EVENT_ID_INDEX = 15;
  53.  
  54.     static final StackTraceElement EMPTY_CALLER_DATA = CallerData.naInstance();
  55.  
  56.     static {
  57.         // PreparedStatement.getGeneratedKeys() method was added in JDK 1.4
  58.         Method getGeneratedKeysMethod;
  59.         try {
  60.             // the
  61.             getGeneratedKeysMethod = PreparedStatement.class.getMethod("getGeneratedKeys", (Class[]) null);
  62.         } catch (Exception ex) {
  63.             getGeneratedKeysMethod = null;
  64.         }
  65.         GET_GENERATED_KEYS_METHOD = getGeneratedKeysMethod;
  66.     }
  67.  
  68.     public void setDbNameResolver(DBNameResolver dbNameResolver) {
  69.         this.dbNameResolver = dbNameResolver;
  70.     }
  71.  
  72.     @Override
  73.     public void start() {
  74.         if (dbNameResolver == null)
  75.             dbNameResolver = new DefaultDBNameResolver();
  76.         insertExceptionSQL = SQLBuilder.buildInsertExceptionSQL(dbNameResolver);
  77.         insertPropertiesSQL = SQLBuilder.buildInsertPropertiesSQL(dbNameResolver);
  78.         insertSQL = SQLBuilder.buildInsertSQL(dbNameResolver);
  79.         super.start();
  80.     }
  81.  
  82.     @Override
  83.     protected void subAppend(ILoggingEvent event, Connection connection, PreparedStatement insertStatement) throws Throwable {
  84.  
  85.         bindLoggingEventWithInsertStatement(insertStatement, event);
  86.         bindLoggingEventArgumentsWithPreparedStatement(insertStatement, event.getArgumentArray());
  87.  
  88.         // This is expensive... should we do it every time?
  89.         bindCallerDataWithPreparedStatement(insertStatement, event.getCallerData());
  90.  
  91.         int updateCount = insertStatement.executeUpdate();
  92.         if (updateCount != 1) {
  93.             addWarn("Failed to insert loggingEvent");
  94.         }
  95.     }
  96.  
  97.     protected void secondarySubAppend(ILoggingEvent event, Connection connection, long eventId) throws Throwable {
  98.         Map<String, String> mergedMap = mergePropertyMaps(event);
  99.         insertProperties(mergedMap, connection, eventId);
  100.  
  101.         if (event.getThrowableProxy() != null) {
  102.             insertThrowable(event.getThrowableProxy(), connection, eventId);
  103.         }
  104.     }
  105.  
  106.     void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException {
  107.         stmt.setLong(TIMESTMP_INDEX, event.getTimeStamp());
  108.         stmt.setString(FORMATTED_MESSAGE_INDEX, event.getFormattedMessage());
  109.         stmt.setString(LOGGER_NAME_INDEX, event.getLoggerName());
  110.         stmt.setString(LEVEL_STRING_INDEX, event.getLevel().toString());
  111.         stmt.setString(THREAD_NAME_INDEX, event.getThreadName());
  112.         stmt.setShort(REFERENCE_FLAG_INDEX, DBHelper.computeReferenceMask(event));
  113.     }
  114.  
  115.     void bindLoggingEventArgumentsWithPreparedStatement(PreparedStatement stmt, Object[] argArray) throws SQLException {
  116.  
  117.         int arrayLen = argArray != null ? argArray.length : 0;
  118.  
  119.         for (int i = 0; i < arrayLen && i < 4; i++) {
  120.             stmt.setString(ARG0_INDEX + i, asStringTruncatedTo254(argArray[i]));
  121.         }
  122.         if (arrayLen < 4) {
  123.             for (int i = arrayLen; i < 4; i++) {
  124.                 stmt.setString(ARG0_INDEX + i, null);
  125.             }
  126.         }
  127.     }
  128.  
  129.     String asStringTruncatedTo254(Object o) {
  130.         String s = null;
  131.         if (o != null) {
  132.             s = o.toString();
  133.         }
  134.  
  135.         if (s == null) {
  136.             return null;
  137.         }
  138.         if (s.length() <= 254) {
  139.             return s;
  140.         } else {
  141.             return s.substring(0, 254);
  142.         }
  143.     }
  144.  
  145.     void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray) throws SQLException {
  146.  
  147.         StackTraceElement caller = extractFirstCaller(callerDataArray);
  148.  
  149.         stmt.setString(CALLER_FILENAME_INDEX, caller.getFileName());
  150.         stmt.setString(CALLER_CLASS_INDEX, caller.getClassName());
  151.         stmt.setString(CALLER_METHOD_INDEX, caller.getMethodName());
  152.         stmt.setString(CALLER_LINE_INDEX, Integer.toString(caller.getLineNumber()));
  153.     }
  154.  
  155.     private StackTraceElement extractFirstCaller(StackTraceElement[] callerDataArray) {
  156.         StackTraceElement caller = EMPTY_CALLER_DATA;
  157.         if (hasAtLeastOneNonNullElement(callerDataArray))
  158.             caller = callerDataArray[0];
  159.         return caller;
  160.     }
  161.  
  162.     private boolean hasAtLeastOneNonNullElement(StackTraceElement[] callerDataArray) {
  163.         return callerDataArray != null && callerDataArray.length > 0 && callerDataArray[0] != null;
  164.     }
  165.  
  166.     Map<String, String> mergePropertyMaps(ILoggingEvent event) {
  167.         Map<String, String> mergedMap = new HashMap<String, String>();
  168.         // we add the context properties first, then the event properties, since
  169.         // we consider that event-specific properties should have priority over
  170.         // context-wide properties.
  171.         Map<String, String> loggerContextMap = event.getLoggerContextVO().getPropertyMap();
  172.         Map<String, String> mdcMap = event.getMDCPropertyMap();
  173.         if (loggerContextMap != null) {
  174.             mergedMap.putAll(loggerContextMap);
  175.         }
  176.         if (mdcMap != null) {
  177.             mergedMap.putAll(mdcMap);
  178.         }
  179.  
  180.         return mergedMap;
  181.     }
  182.  
  183.     @Override
  184.     protected Method getGeneratedKeysMethod() {
  185.         return GET_GENERATED_KEYS_METHOD;
  186.     }
  187.  
  188.     @Override
  189.     protected String getInsertSQL() {
  190.         return insertSQL;
  191.     }
  192.  
  193.     protected void insertProperties(Map<String, String> mergedMap, Connection connection, long eventId) throws SQLException {
  194.         Set<String> propertiesKeys = mergedMap.keySet();
  195.         if (propertiesKeys.size() > 0) {
  196.             PreparedStatement insertPropertiesStatement = null;
  197.             try {
  198.                 insertPropertiesStatement = connection.prepareStatement(insertPropertiesSQL);
  199.  
  200.                 for (String key : propertiesKeys) {
  201.                     String value = mergedMap.get(key);
  202.  
  203.                     insertPropertiesStatement.setLong(1, eventId);
  204.                     insertPropertiesStatement.setString(2, key);
  205.                     insertPropertiesStatement.setString(3, value);
  206.  
  207.                     if (cnxSupportsBatchUpdates) {
  208.                         insertPropertiesStatement.addBatch();
  209.                     } else {
  210.                         insertPropertiesStatement.execute();
  211.                     }
  212.                 }
  213.  
  214.                 if (cnxSupportsBatchUpdates) {
  215.                     insertPropertiesStatement.executeBatch();
  216.                 }
  217.             } finally {
  218.                 closeStatement(insertPropertiesStatement);
  219.             }
  220.         }
  221.     }
  222.  
  223.     /**
  224.      * Add an exception statement either as a batch or execute immediately if
  225.      * batch updates are not supported.
  226.      */
  227.     void updateExceptionStatement(PreparedStatement exceptionStatement, String txt, short i, long eventId) throws SQLException {
  228.         exceptionStatement.setLong(1, eventId);
  229.         exceptionStatement.setShort(2, i);
  230.         exceptionStatement.setString(3, txt);
  231.         if (cnxSupportsBatchUpdates) {
  232.             exceptionStatement.addBatch();
  233.         } else {
  234.             exceptionStatement.execute();
  235.         }
  236.     }
  237.  
  238.     short buildExceptionStatement(IThrowableProxy tp, short baseIndex, PreparedStatement insertExceptionStatement, long eventId) throws SQLException {
  239.  
  240.         StringBuilder buf = new StringBuilder();
  241.         ThrowableProxyUtil.subjoinFirstLine(buf, tp);
  242.         updateExceptionStatement(insertExceptionStatement, buf.toString(), baseIndex++, eventId);
  243.  
  244.         int commonFrames = tp.getCommonFrames();
  245.         StackTraceElementProxy[] stepArray = tp.getStackTraceElementProxyArray();
  246.         for (int i = 0; i < stepArray.length - commonFrames; i++) {
  247.             StringBuilder sb = new StringBuilder();
  248.             sb.append(CoreConstants.TAB);
  249.             ThrowableProxyUtil.subjoinSTEP(sb, stepArray[i]);
  250.             updateExceptionStatement(insertExceptionStatement, sb.toString(), baseIndex++, eventId);
  251.         }
  252.  
  253.         if (commonFrames > 0) {
  254.             StringBuilder sb = new StringBuilder();
  255.             sb.append(CoreConstants.TAB).append("... ").append(commonFrames).append(" common frames omitted");
  256.             updateExceptionStatement(insertExceptionStatement, sb.toString(), baseIndex++, eventId);
  257.         }
  258.  
  259.         return baseIndex;
  260.     }
  261.  
  262.     protected void insertThrowable(IThrowableProxy tp, Connection connection, long eventId) throws SQLException {
  263.  
  264.         PreparedStatement exceptionStatement = null;
  265.         try {
  266.             exceptionStatement = connection.prepareStatement(insertExceptionSQL);
  267.  
  268.             short baseIndex = 0;
  269.             while (tp != null) {
  270.                 baseIndex = buildExceptionStatement(tp, baseIndex, exceptionStatement, eventId);
  271.                 tp = tp.getCause();
  272.             }
  273.  
  274.             if (cnxSupportsBatchUpdates) {
  275.                 exceptionStatement.executeBatch();
  276.             }
  277.         } finally {
  278.             closeStatement(exceptionStatement);
  279.         }
  280.  
  281.     }
  282. }

因为方法较多，所以我将几个重要的方法单独提出来讲解

3.3.1  数据格式化方法

首先，查找对应数据库插入的方法：

  1. void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException {
  2.         stmt.setLong(TIMESTMP_INDEX, event.getTimeStamp());
  3.         stmt.setString(FORMATTED_MESSAGE_INDEX, event.getFormattedMessage());
  4.         stmt.setString(LOGGER_NAME_INDEX, event.getLoggerName());
  5.         stmt.setString(LEVEL_STRING_INDEX, event.getLevel().toString());
  6.         stmt.setString(THREAD_NAME_INDEX, event.getThreadName());
  7.         stmt.setShort(REFERENCE_FLAG_INDEX, DBHelper.computeReferenceMask(event));
  8.     }
  9.  
  10. void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray) throws SQLException {
  11.  
  12.         StackTraceElement caller = extractFirstCaller(callerDataArray);
  13.  
  14.         stmt.setString(CALLER_FILENAME_INDEX, caller.getFileName());
  15.         stmt.setString(CALLER_CLASS_INDEX, caller.getClassName());
  16.         stmt.setString(CALLER_METHOD_INDEX, caller.getMethodName());
  17.         stmt.setString(CALLER_LINE_INDEX, Integer.toString(caller.getLineNumber()));
  18.     }

上两个方法，则是将日志所有的参数，格式化为数据库对应的格式，根据类的开始几行数据，如以下

  1.     static final int TIMESTMP_INDEX = 1;
  2.     static final int FORMATTED_MESSAGE_INDEX = 2;
  3.     static final int LOGGER_NAME_INDEX = 3;
  4.     static final int LEVEL_STRING_INDEX = 4;
  5.     static final int THREAD_NAME_INDEX = 5;
  6.     static final int REFERENCE_FLAG_INDEX = 6;
  7.     static final int ARG0_INDEX = 7;
  8.     static final int ARG1_INDEX = 8;
  9.     static final int ARG2_INDEX = 9;
  10.     static final int ARG3_INDEX = 10;
  11.     static final int CALLER_FILENAME_INDEX = 11;
  12.     static final int CALLER_CLASS_INDEX = 12;
  13.     static final int CALLER_METHOD_INDEX = 13;
  14.     static final int CALLER_LINE_INDEX = 14;
  15.     static final int EVENT_ID_INDEX = 15;

可以很明显找到这个关键的方法之一，这也为我们后面重写此类的重点。

3.3.2  数据插入以及入口方法

我们上面找到格式化数据的方法，下面则将查找插入数据库的具体操作实现方法，不难看出，我们找到以下方法内容：

  1.     @Override
  2.     public void start() {
  3.         if (dbNameResolver == null)
  4.             dbNameResolver = new DefaultDBNameResolver();
  5.         insertExceptionSQL = SQLBuilder.buildInsertExceptionSQL(dbNameResolver);
  6.         insertPropertiesSQL = SQLBuilder.buildInsertPropertiesSQL(dbNameResolver);
  7.         insertSQL = SQLBuilder.buildInsertSQL(dbNameResolver);
  8.         super.start();
  9.     }
  10.  
  11.     @Override
  12.     protected void subAppend(ILoggingEvent event, Connection connection, PreparedStatement insertStatement) throws Throwable {
  13.  
  14.         bindLoggingEventWithInsertStatement(insertStatement, event);
  15.         bindLoggingEventArgumentsWithPreparedStatement(insertStatement, event.getArgumentArray());
  16.  
  17.         // This is expensive... should we do it every time?
  18.         bindCallerDataWithPreparedStatement(insertStatement, event.getCallerData());
  19.  
  20.         int updateCount = insertStatement.executeUpdate();
  21.         if (updateCount != 1) {
  22.             addWarn("Failed to insert loggingEvent");
  23.         }
  24.     }

以上只是插入logging_event这个表内数据的方法，还有其他两个表，其插入方法在类中，可以自行查找。

不难看出，我们找到了此类中的关键方法，了解这两个方法后，有助于我们自己实现自定义DBAppender。

3.4  SQLBuilder

在上一个类中，找到了插入数据库的具体实现方法，那么还有插入数据库的SQL语句没有查到，于是在这个类SQLBuilder中，便集成了三个表的数据插入语句的格式化。具体内容如下：

  1. /**
  2.  * Logback: the reliable, generic, fast and flexible logging framework.
  3.  * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
  4.  *
  5.  * This program and the accompanying materials are dual-licensed under
  6.  * either the terms of the Eclipse Public License v1.0 as published by
  7.  * the Eclipse Foundation
  8.  *
  9.  *   or (per the licensee's choosing)
  10.  *
  11.  * under the terms of the GNU Lesser General Public License version 2.1
  12.  * as published by the Free Software Foundation.
  13.  */
  14. package ch.qos.logback.classic.db;
  15.  
  16. import ch.qos.logback.classic.db.names.*;
  17.  
  18. /**
  19.  * @author Tomasz Nurkiewicz
  20.  * @since 2010-03-16
  21.  */
  22. public class SQLBuilder {
  23.  
  24.     static String buildInsertPropertiesSQL(DBNameResolver dbNameResolver) {
  25.         StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
  26.         sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT_PROPERTY)).append(" (");
  27.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.EVENT_ID)).append(", ");
  28.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.MAPPED_KEY)).append(", ");
  29.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.MAPPED_VALUE)).append(") ");
  30.         sqlBuilder.append("VALUES (?, ?, ?)");
  31.         return sqlBuilder.toString();
  32.     }
  33.  
  34.     static String buildInsertExceptionSQL(DBNameResolver dbNameResolver) {
  35.         StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
  36.         sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT_EXCEPTION)).append(" (");
  37.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.EVENT_ID)).append(", ");
  38.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.I)).append(", ");
  39.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.TRACE_LINE)).append(") ");
  40.         sqlBuilder.append("VALUES (?, ?, ?)");
  41.         return sqlBuilder.toString();
  42.     }
  43.  
  44.     static String buildInsertSQL(DBNameResolver dbNameResolver) {
  45.         StringBuilder sqlBuilder = new StringBuilder("INSERT INTO ");
  46.         sqlBuilder.append(dbNameResolver.getTableName(TableName.LOGGING_EVENT)).append(" (");
  47.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.TIMESTMP)).append(", ");
  48.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.FORMATTED_MESSAGE)).append(", ");
  49.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.LOGGER_NAME)).append(", ");
  50.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.LEVEL_STRING)).append(", ");
  51.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.THREAD_NAME)).append(", ");
  52.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.REFERENCE_FLAG)).append(", ");
  53.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG0)).append(", ");
  54.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG1)).append(", ");
  55.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG2)).append(", ");
  56.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.ARG3)).append(", ");
  57.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_FILENAME)).append(", ");
  58.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_CLASS)).append(", ");
  59.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_METHOD)).append(", ");
  60.         sqlBuilder.append(dbNameResolver.getColumnName(ColumnName.CALLER_LINE)).append(") ");
  61.         sqlBuilder.append("VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  62.         return sqlBuilder.toString();
  63.     }
  64. }

由上不难看出其作用，生成具体的SQL语句，用于数据插入。

3.4  其他

此包内还有几个其他的类没有讲解，因为其对我们自定义重写的作用不大，就不多赘述了。

4  重写源码 

由以上源码的解析过程，我们熟悉了其工作方式和具体实现方法，以下，将开始重写源码的过程。

4.1  数据库表设计

在之前我们说过，原配置的数据库表有很多我们并不需要的信息，于是，将数据库表中不需要的表项删除，删除不需要的表，只留下一个logging_event表的内容，并加以修改。其SQL脚本如下：

  1. BEGIN;
  2. DROP TABLE IF EXISTS log_record;
  3.  
  4. COMMIT;
  5.  
  6.  
  7. BEGIN;
  8. CREATE TABLE log_record
  9. (
  10.     id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  11.     time              DATETIME(6) NOT NULL,
  12.     message           TEXT NOT NULL,
  13.     level_string      VARCHAR(254) NOT NULL,
  14.     logger_name       VARCHAR(254) NOT NULL,
  15.     thread_name       VARCHAR(254),
  16.     reference_flag    SMALLINT,
  17.     caller_filename   VARCHAR(254) NOT NULL,
  18.     caller_class      VARCHAR(254) NOT NULL,
  19.     caller_method     VARCHAR(254) NOT NULL,
  20.     caller_line       CHAR(4) NOT NULL
  21.  
  22. );
  23. COMMIT;

由以上表得知，只留下时间和日志具体位置和信息，同时删除其余两个表。

其中，原数据表中时间的格式为Long型，不便于阅读，本文将时间改为DATETIME形式，方便查询和操作。

4.2  数据库插入语句生成

因为我们只需要管理一个数据库表，本着简洁的原则，我们将names包下面的所有文件全部删除，将SQLBuilder 文件中简化为一个方法，放在MyDBAppender.java 中，方法代码如下:

  1.     private static String buildInsertSQL() {
  2.         return "INSERT INTO log_record " +
  3.                 "(time, message, level_string, logger_name, thread_name," +
  4.                 "caller_filename, caller_class, caller_method, caller_line)"+
  5.                 "VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)";
  6.     }

是不是简洁了很多，可以根据自己定义的数据库表自行修改。

4.3  数据格式化

因为我们对数据库表的修改只是删除某些表项，其具体数据格式化方法本质没变，代码如下：

  1.     private static final int TIME_INDEX = 1;
  2.     private static final int MESSAGE_INDEX = 2;
  3.     private static final int LEVEL_STRING_INDEX = 3;
  4.     private static final int LOGGER_NAME_INDEX = 4;
  5.     private static final int THREAD_NAME_INDEX = 5;
  6.     private static final int CALLER_FILENAME_INDEX = 6;
  7.     private static final int CALLER_CLASS_INDEX = 7;
  8.     private static final int CALLER_METHOD_INDEX = 8;
  9.     private static final int CALLER_LINE_INDEX = 9;
  10.  
  11.  
  12. private void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException {
  13.         stmt.setTimestamp(TIME_INDEX, new Timestamp(event.getTimeStamp()));
  14.         stmt.setString(MESSAGE_INDEX, event.getFormattedMessage());
  15.         stmt.setString(LEVEL_STRING_INDEX, event.getLevel().toString());
  16.         stmt.setString(LOGGER_NAME_INDEX, event.getLoggerName());
  17.         stmt.setString(THREAD_NAME_INDEX, event.getThreadName());
  18.     }
  19.  
  20.     private void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray) throws SQLException {
  21.         StackTraceElement caller = extractFirstCaller(callerDataArray);
  22.         stmt.setString(CALLER_FILENAME_INDEX, caller.getFileName());
  23.         stmt.setString(CALLER_CLASS_INDEX, caller.getClassName());
  24.         stmt.setString(CALLER_METHOD_INDEX, caller.getMethodName());
  25.         stmt.setString(CALLER_LINE_INDEX, Integer.toString(caller.getLineNumber()));
  26.     }

4.4  修改后代码 （MyDBAppender.java）

  1. package com.ahdy.logtest.config;
  2.  
  3. import ch.qos.logback.classic.spi.*;
  4. import ch.qos.logback.core.db.DBAppenderBase;
  5.  
  6. import java.lang.reflect.Method;
  7. import java.sql.Connection;
  8. import java.sql.PreparedStatement;
  9. import java.sql.SQLException;
  10. import java.text.SimpleDateFormat;
  11. import java.util.Date;
  12.  
  13. /**
  14.  * @Description:
  15.  * @Author: Rocty
  16.  * @Date: 2019-06-18 16:22
  17.  * @Version: 1.0
  18.  */
  19. public class MyDBAppender extends DBAppenderBase<ILoggingEvent> {
  20.  
  21.     private String insertSQL;
  22.     private static final Method GET_GENERATED_KEYS_METHOD;
  23.  
  24.     private static final int TIME_INDEX = 1;
  25.     private static final int MESSAGE_INDEX = 2;
  26.     private static final int LEVEL_STRING_INDEX = 3;
  27.     private static final int LOGGER_NAME_INDEX = 4;
  28.     private static final int THREAD_NAME_INDEX = 5;
  29.     private static final int CALLER_FILENAME_INDEX = 6;
  30.     private static final int CALLER_CLASS_INDEX = 7;
  31.     private static final int CALLER_METHOD_INDEX = 8;
  32.     private static final int CALLER_LINE_INDEX = 9;
  33.  
  34.     private static final StackTraceElement EMPTY_CALLER_DATA = CallerData.naInstance();
  35.  
  36.     static {
  37.         // PreparedStatement.getGeneratedKeys() method was added in JDK 1.4
  38.         Method getGeneratedKeysMethod;
  39.         try {
  40.             // the
  41.             getGeneratedKeysMethod = PreparedStatement.class.getMethod("getGeneratedKeys", (Class[]) null);
  42.         } catch (Exception ex) {
  43.             getGeneratedKeysMethod = null;
  44.         }
  45.         GET_GENERATED_KEYS_METHOD = getGeneratedKeysMethod;
  46.     }
  47.  
  48.     @Override
  49.     public void start() {
  50.         insertSQL = buildInsertSQL();
  51.         super.start();
  52.     }
  53.  
  54.     private static String buildInsertSQL() {
  55.         return "INSERT INTO log_record " +
  56.                 "(time, message, logger_name, level_string, thread_name," +
  57.                 "caller_filename, caller_class, caller_method, caller_line)"+
  58.                 "VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)";
  59.     }
  60.  
  61.     private void bindLoggingEventWithInsertStatement(PreparedStatement stmt, ILoggingEvent event) throws SQLException {
  62.         stmt.setTimestamp(TIME_INDEX, new Timestamp(event.getTimeStamp())); 
  63.         stmt.setString(MESSAGE_INDEX, event.getFormattedMessage());
  64.         stmt.setString(LEVEL_STRING_INDEX, event.getLevel().toString());
  65.         stmt.setString(LOGGER_NAME_INDEX, event.getLoggerName());
  66.         stmt.setString(THREAD_NAME_INDEX, event.getThreadName());
  67.     }
  68.  
  69.     private void bindCallerDataWithPreparedStatement(PreparedStatement stmt, StackTraceElement[] callerDataArray) throws SQLException {
  70.         StackTraceElement caller = extractFirstCaller(callerDataArray);
  71.         stmt.setString(CALLER_FILENAME_INDEX, caller.getFileName());
  72.         stmt.setString(CALLER_CLASS_INDEX, caller.getClassName());
  73.         stmt.setString(CALLER_METHOD_INDEX, caller.getMethodName());
  74.         stmt.setString(CALLER_LINE_INDEX, Integer.toString(caller.getLineNumber()));
  75.     }
  76.  
  77.     @Override
  78.     protected void subAppend(ILoggingEvent event, Connection connection, PreparedStatement insertStatement) throws Throwable {
  79.         bindLoggingEventWithInsertStatement(insertStatement, event);
  80.         // This is expensive... should we do it every time?
  81.         bindCallerDataWithPreparedStatement(insertStatement, event.getCallerData());
  82.         int updateCount = insertStatement.executeUpdate();
  83.         if (updateCount != 1) {
  84.             addWarn("Failed to insert loggingEvent");
  85.         }
  86.     }
  87.  
  88.     private StackTraceElement extractFirstCaller(StackTraceElement[] callerDataArray) {
  89.         StackTraceElement caller = EMPTY_CALLER_DATA;
  90.         if (hasAtLeastOneNonNullElement(callerDataArray))
  91.             caller = callerDataArray[0];
  92.         return caller;
  93.     }
  94.  
  95.     private boolean hasAtLeastOneNonNullElement(StackTraceElement[] callerDataArray) {
  96.         return callerDataArray != null && callerDataArray.length > 0 && callerDataArray[0] != null;
  97.     }
  98.  
  99.     @Override
  100.     protected Method getGeneratedKeysMethod() {
  101.         return GET_GENERATED_KEYS_METHOD;
  102.     }
  103.  
  104.     @Override
  105.     protected String getInsertSQL() {
  106.         return insertSQL;
  107.     }
  108.  
  109.     protected void secondarySubAppend(ILoggingEvent event, Connection connection, long eventId) throws Throwable {
  110.     }
  111. }

4.5  运行测试

首先，修改logback-test.xml 中的 <appender>标签：

<appender name="DB" class="com.ahdy.logtest.config.MyDBAppender">

其次，原测试文件 BlogAction.java不变，运行后控制台输出一致，数据库中数据如下图示：

至此，可以看到数据完全插入数据库中，完全实现自定义功能。结束。

5  总结

 在写这个日志模块的过程中，查了很多资料，几乎所有的文章都是千篇一律，仅有几个重写DBApepender的文章也很不清晰，无法学习。

在实在找不到资料的情况下，阅读学习源码，并重写方法实现自定义功能。一切教程文章，都比不上阅读源码来的实在，为此，写上这么一篇文章，将logback中配置的源码讲解一些，如有不清晰，还请多多包涵。在码农中，还是新人，尚在学习中。

源码：提取码：1k8c

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/312765
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号