JAVA主流日志框架梳理学习及使用

已于 2023-12-19 08:49:25 修改
阅读量1.4k 收藏 21
点赞数 17
文章标签： java 学习 单元测试
于 2023-12-18 22:52:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43450920/article/details/135051292
版权

前言：目前市面上有挺多JAVA的日志框架，比如JUL(JDK自带的日志框架),Log4j,Logback,Log4j2等，有人可能有疑问说还有slf4j，不过slf4j不是一种日志框架的具体实现，而是一种日志门面（日志门面可以理解为是一种统一的接口，只是为了规范日志，没有具体的实现；可以类比USB接口，对于USB接口有好多个厂商，这多个厂商生产出来的USB头都是一样的，使得我们用起来就很方便，slf4j其实也是一样）。虽然市面上有很多日志框架，但是笔者之前只是能够简单的使用日志框架，而且使用时总感觉似懂非懂，对目前市面上的日志框架并没有一个整体且系统的了解。因此，笔者利用周末这两天系统的学习了一下目前市面上的框架，也就有了这篇文章，希望这篇文章能够帮助大家对JAVA日志框架有个清晰的认识。

笔者这篇文件是对该视频内容的提炼，需要的可以自行观看。如果想快速了解日志的重点内容，那么可以继续往下看。
视频链接

一、市面上主要日志简介

目前市面上主要的日志框架有：JUL(JDK自带的日志框架),Log4j,Logback,Log4j2。
日志门面：slf4j，log4j2也是一种日志门面，不过因为其实现了丰富的日志功能，所以不把其当做一种日志门面了
日志框架（门面）出现的先后顺序：JUL,Log4j在slf4j门面技术出现之前，logback,Log4j2在slf4j门面技术出现之后。因为JUL,Log4j在slf4j出现之前就有了，所以这两个日志的实现并没有遵循slf4j的规范（不过可以通过导入适配器的依赖来使用）。因为Log4j2是对Log4j的升级，JUL功能比较弱（不过因为是JDK自带的日志实现，不需要导入依赖，使用起来比较方便），所以本文只介绍Logback和Log4j2。
主流日志使用方式：slf4j+Logback、slf4j+Log4j2

使用方式：配置文件。

在使用各种库时，第一步都是导入对应的依赖，日志框架也是一样。此外，对于记录的日志会有不同的日志级别，日志显示（或写入文件）的条件就是当前日志级别大于所设置的日志级别时才会打印，如果不设置日志级别，系统会有默认的日志级别。

日志级别由高到低： error > warn>info>debug>trace(这个日志级别是针对slf4j门面的日志级别，各种日志框架的日志级别都大同小异)

二、slf4j+Logback使用

2.1 导入依赖

在导入依赖时我们需要导入slf4j的依赖(slf4j-api)和logback的依赖，因为依赖的传递性，logback-classic的依赖中包含了slf4j-api的依赖，所以我们在实际的使用中只需要导入logback-classic的依赖即可：
依赖情况
依赖

 <dependency>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-classic</artifactId>
     <version>1.2.3</version>
 </dependency>

2.2 使用方式

对于日志，我们分别测试下面这几种情况：

2.2.1不使用配置文件
2.2.2使用配置文件

2.2.2.1输出到控制台
2.2.2.2输出到文件
2.2.2.3输出到文件（对文件拆分）

2.2.1 不使用配置文件

项目结构
在这里插入图片描述
执行右面的test01输出如下：
在这里插入图片描述
如上图所示，当不添加配置文件时，默认的输出格式如上所示。只有trace日志级别的日志没有输出，所以logback系统默认的日志级别是debug级别。

日志级别的值

/**
 * The <code>OFF</code> is used to turn off logging.
 */
public static final Level OFF = new Level(OFF_INT, "OFF");

/**
 * The <code>ERROR</code> level designates error events which may or not
 * be fatal to the application.
 */
public static final Level ERROR = new Level(ERROR_INT, "ERROR");

/**
 * The <code>WARN</code> level designates potentially harmful situations.
 */
public static final Level WARN = new Level(WARN_INT, "WARN");

/**
 * The <code>INFO</code> level designates informational messages
 * highlighting overall progress of the application.
 */
public static final Level INFO = new Level(INFO_INT, "INFO");

/**
 * The <code>DEBUG</code> level designates informational events of lower
 * importance.
 */
public static final Level DEBUG = new Level(DEBUG_INT, "DEBUG");

/**
 * The <code>TRACE</code> level designates informational events of very low
 * importance.
 */
public static final Level TRACE = new Level(TRACE_INT, "TRACE");

/**
 * The <code>ALL</code> is used to turn on all logging.
 */
public static final Level ALL = new Level(ALL_INT, "ALL");

//对应的具体值
public static final int OFF_INT = Integer.MAX_VALUE;
public static final int ERROR_INT = 40000;
public static final int WARN_INT = 30000;
public static final int INFO_INT = 20000;
public static final int DEBUG_INT = 10000;
public static final int TRACE_INT = 5000;
public static final int ALL_INT = Integer.MIN_VALUE;

2.2.2 使用配置文件

2.2.1 输出到控制台

配置文件名：logback.xml
内容

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

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

看这个配置文件，我们可以看到所有的内容都包含在configuration标签中，configuration标签内部定义了property,appender,root标签，其中property标签是定义配置文件内的变量，方便我们使用（即在后面直接引用该变量就行）。其中appender标签和root标签是需要我们重点关注的内容。
我们知道日志一般可以输出到控制台或者文件中，对于具体输出到控制台还是输出到文件中就是通过appender来控制的。因此，我们可以通过appender标签来定义一个变量。其中，appender标签的name属性就是变量名，class属性就是变量的类型。appender标签内的target标签不太重要，设置的具体值等同于Java中的System.out和System.err。appender标签内的encoder标签其实是定义日志的输出格式，我们看到的日志一般都会包括日志级别，线程名称，时间，文件全类名，消息等信息，就是通过该标签控制。所以这些是appender标签的核心内容。

虽然appender标签定义了具体的appender变量，但决定是否使用该变量时通过下面的root标签来控制的，我们可以看到root标签有个level属性，我们将该属性值设置为ALL,则表示所有的日志级别都会显示。root标签下的appender-ref属性则是决定具体使用哪个appender变量。可以看到appender-ref标签的ref属性值为consoleAppender，说明使用了变量名为consoleAppender的appender输出器。
执行效果如下：
在这里插入图片描述
可以看到，所有的日志信息全都输出了（同样执行的test01()方法）。此外，日志显示为红色，这其实就是System.err设置的效果。而且我们可以看到输出的日志具有特定的格式，即[INFO ] 2023-12-18 08:26:32.869 com.xlb.LogBackDemo test01 main 14：info 信息含义为日志级别 时间 当前类全限定名 当前执行日志的方法 线程名 行号：消息体。这种输出格式即是我们通过encoder标签下的pattern标签定义的。格式化的含义具体如下：

%-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
%d{yyyy-MM-dd HH:mm:ss.SSS} 日期
%c 当前类全限定名
%M 当前执行日志的方法
%L 行号
%thread 线程名称
%m或者%msg 信息
%n 换行
2.2.2.2 输出到文件

我们上面是将日志成功输出到了控制台，下面我们将日志输出到文件，大致过程和上面类似。
修改后的配置文件如下：

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

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

实际上我们就只修改了这三个地方
在这里插入图片描述

最上面指定了日志文件的输出路径的变量（指定位置为当前项目下的log文件夹），中间添加了一个输出到文件的appender，增加了file标签，在其内部定义了日志文件的输出路径，下面在root标签中指定了我们新添加的appender。
输出结果如下：
在这里插入图片描述
在这里插入图片描述
可以看到，控制台没有日志输出，但是文件中有日志输出。

2.2.2.3 输出到控制台和文件

修改后的配置如下

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

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

在这里插入图片描述
可以看到，对于新的配置文件我们只是增加了上面一行，即在root标签中同时也使用了控制台的appender。
输出结果如下
在这里插入图片描述
在这里插入图片描述
可以看到，日志记录输出到了控制台和文件中，而且文件中的日志是追加的方式记录的（可以查看日志的时间来看当前的日志记录）。
从这个案例我们可以知道，日志可以指定多个appender，指定多个appender只需要增加对应的appender引用即可。

2.2.2.3 输出到文件（对文件拆分）

如果日志文件一直追加，那么日志文件就可能变得非常大，不方便日志管理，或者有时候同类型的日志需要归档，所以我们需要对日志文件进行拆分管理，对文件拆分管理方式如下。
修改配置文件

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <file>${logDir}\roll_logback.log</file>

        <!--        指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>

    </appender>

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

在这里插入图片描述
对于日志规则的拆分，如上所示，同样只需要修改这两处。

因为设置了日志文件的大小为1KB，所以我们使用for循环来追加操作，达到拆分文件的目的，演示如下：

代码：

@Test
    public void test02(){
        Logger logger = LoggerFactory.getLogger(LogBackDemo.class);

        for (int i = 0; i < 200; i++) {
            logger.trace("trace 信息");
            logger.debug("debug 信息");
            logger.info("info 信息");
            logger.warn("warn 信息");
            logger.error("error 信息");
        }
    }

输出：
在这里插入图片描述
在这里插入图片描述
可以看到日志文件按照我们设置的格式进行了拆分。

2.2.2.4 输出为html格式

除了上面几种格式，还可以将logback输出为html的格式，只需要下面这样设置即可：

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <file>${logDir}\roll_logback.log</file>

        <!--        指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>

    </appender>

<!--    html格式-->
    <appender name="htmlAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\myHtmllog.html</file>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>${pattern}</pattern>
            </layout>
        </encoder>
    </appender>

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

在这里插入图片描述
同样改动很小，输出如下（使用test01）：
在这里插入图片描述
可以看到有个html文件。
浏览器打开该html日志文件展示如下：
在这里插入图片描述
可以看到自动为我们添加了特定的样式，使得日志以表格的形式展示。

2.2.2.5 过滤器

实际使用时，可能每个appender我们想设置的日志级别都不同，那么此时我们就需要一个过滤器，该过滤器也是通过设置日志级别来控制是否输出当前appender的日志。

配置如下

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!--    过滤器-->
    <appender name="consoleFilterAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!--        配置过滤器(等于配置的级别才会输出)-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--            设置日志的输出级别-->
            <level>INFO</level>
            <!--            高于level中设置的级别，则打印日志-->
            <onMatch>ACCEPT</onMatch>
            <!--            低于level中设置的级别，则不打印-->
            <onMismatch>DENY</onMismatch>
        </filter>

<!--        &lt;!&ndash;        配置临界值过滤器(输出大于等于level的日志)&ndash;&gt;-->
<!--        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">-->
<!--            &lt;!&ndash;            设置日志的输出级别&ndash;&gt;-->
<!--            <level>INFO</level>-->
<!--        </filter>-->
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <file>${logDir}\roll_logback.log</file>

        <!--        指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>

    </appender>

<!--    html格式-->
    <appender name="htmlAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\myHtmllog.html</file>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>${pattern}</pattern>
            </layout>
        </encoder>
    </appender>

    <root level="ALL">
        <appender-ref ref="consoleFilterAppender"/>
    </root>

</configuration>

在这里插入图片描述
在这里插入图片描述
在consoleAppender里设置了INFO级别的日志级别，不过root标签下的日志级别是ALL，我们看下输出：
在这里插入图片描述
可以看到只输出了INFO级别的日志，即我们在日志中配的INFO级别。下面我们看一下另一种过滤器：

<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
   <!--            设置日志的输出级别-->
    <level>INFO</level>
</filter>

将上面的过滤器换成这个（ThresholdFilter），我们再看下输出：
在这里插入图片描述
可以看到大于等于INFO级别的日志都进行了输出。从上面的输出可以看出这两种过滤器的差别。

2.2.2.6 异步日志

因为日志和业务逻辑无关，日志只是便于我们处理问题。所以在项目中一般都会使用异步日志，来提升业务逻辑的处理速度。异步日志的使用如下：

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    
    <!--    过滤器-->
    <appender name="consoleFilterAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!--        配置过滤器(等于配置的级别才会输出)-->
<!--        <filter class="ch.qos.logback.classic.filter.LevelFilter">-->
<!--            &lt;!&ndash;            设置日志的输出级别&ndash;&gt;-->
<!--            <level>INFO</level>-->
<!--            &lt;!&ndash;            高于level中设置的级别，则打印日志&ndash;&gt;-->
<!--            <onMatch>ACCEPT</onMatch>-->
<!--            &lt;!&ndash;            低于level中设置的级别，则不打印&ndash;&gt;-->
<!--            <onMismatch>DENY</onMismatch>-->
<!--        </filter>-->

<!--        &lt;!&ndash;        配置临界值过滤器(输出大于等于level的日志)&ndash;&gt;-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <!--            设置日志的输出级别-->
            <level>INFO</level>
        </filter>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <file>${logDir}\roll_logback.log</file>

        <!--        指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>

    </appender>

<!--    html格式-->
    <appender name="htmlAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\myHtmllog.html</file>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>${pattern}</pattern>
            </layout>
        </encoder>
    </appender>

    <!--    引入异步日志-->
    <appender name="asyncAppender" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="consoleAppender"/>
    </appender>
    
    <root level="ALL">
        <appender-ref ref="asyncAppender"/>
    </root>

</configuration>

在这里插入图片描述
可以看到，使用异步日志很简单，我们只需要如上定义，最终日志输出来的就是异步日志，注意异步日志里面引用我们定义好的输出到控制台的consoleAppender。
下面我们看下输出：

@Test
    public void test03(){
        Logger logger = LoggerFactory.getLogger(LogBackDemo.class);

        for (int i = 0; i < 200; i++) {
            logger.trace("trace 信息");
            logger.debug("debug 信息");
            logger.info("info 信息");
            logger.warn("warn 信息");
            logger.error("error 信息");
        }

        for (int i = 0; i < 200; i++) {
            System.out.println("======================");
        }
    }

在这里插入图片描述
我们可以看到输出的日志时穿插执行的，即可以证明日志时异步输出的。

2.2.2.7 自定义日志

我们在上面使用的日志其实都是rootLogger，我们应该记得在XML文件最后定义了root标签，这个定义的其实就是rootLogger,rootLogger是日志框架自带的，是所有日志的父级日志。什么是父级日志？对于市面上的所有日志框架，其实是有父子关系的，不过这种父子关系不是通过继承实现，而是通过包路径来体现的。如果包路径越具体，说明其越是儿子。例如：三个包com.aaa.bbb.ccc，和com.aaa.bbb和com.aaa中，com.aaa是com.aaa.bbb与com.aaa.bbb.ccc的父级日志，com.aaa.bbb是com.aaa.bbb.ccc的父级日志。对于父级日志的设置可以对子级日志生效；所以如果想一次生效多个日志，那么可以对父级进行设置。而rootLogger就是所有包的父级日志。那这个日志包路径什么时候指定的呢？我们可以看下面这一行代码：

Logger logger = LoggerFactory.getLogger(LogBackDemo.class);

可以看到，上面参数列表中我们传入了类，java内部通过反射机制可以获得该类的全路径；因为这个方法进行了重载，所以也可以直接指定全路径名。
想要引入自定义日志，需要下面这样配置
自定义日志引入

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

<configuration>

    <!--
            %-10level 日志级别（设置10个字符，字符不够空格补齐，左对齐）
            %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %c 当前类全限定名
            %M 当前执行日志的方法
            %L 行号
            %thread 线程名称
            %m或者%msg 信息
            %n 换行
            -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n"/>
    <property name="logDir" value="F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOGBACK_StudyV2\\log"/>

    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!--    过滤器-->
    <appender name="consoleFilterAppender" class="ch.qos.logback.core.ConsoleAppender">
        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!--        配置过滤器(等于配置的级别才会输出)-->
<!--        <filter class="ch.qos.logback.classic.filter.LevelFilter">-->
<!--            &lt;!&ndash;            设置日志的输出级别&ndash;&gt;-->
<!--            <level>INFO</level>-->
<!--            &lt;!&ndash;            高于level中设置的级别，则打印日志&ndash;&gt;-->
<!--            <onMatch>ACCEPT</onMatch>-->
<!--            &lt;!&ndash;            低于level中设置的级别，则不打印&ndash;&gt;-->
<!--            <onMismatch>DENY</onMismatch>-->
<!--        </filter>-->

<!--        &lt;!&ndash;        配置临界值过滤器(输出大于等于level的日志)&ndash;&gt;-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <!--            设置日志的输出级别-->
            <level>INFO</level>
        </filter>
    </appender>

    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\mylog.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <file>${logDir}\roll_logback.log</file>

        <!--        指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
        </rollingPolicy>

    </appender>

<!--    html格式-->
    <appender name="htmlAppender" class="ch.qos.logback.core.FileAppender">
        <file>${logDir}\myHtmllog.html</file>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>${pattern}</pattern>
            </layout>
        </encoder>
    </appender>

    <!--    引入异步日志-->
    <appender name="asyncAppender" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="consoleAppender"/>
    </appender>

    <root level="ALL">
        <appender-ref ref="consoleAppender"/>
    </root>

    <!--    自定义日志-->
    <logger name="com.xlb" level="info" additivity="false">
        <appender-ref ref="consoleAppender"/>
    </logger>

</configuration>

在这里插入图片描述
输出如下（使用test01）
在这里插入图片描述
可以看到输出了INFO,WARN,ERROR日志级别的日志。如果我们既有父级目录，又有子级目录，以子级日志目录设置的日志级别为准，如下我将父级日志设置成INFO级别，将子级日志设置成ALL级别，并且去掉additivity=false属性，显示如下：
在这里插入图片描述
可以看到同样的日志输出了两份，下面加上additivity=false再看下输出：
在这里插入图片描述
可以看到日志输出只有一份，并且是以子级日志级别为准的。

三、slf4j+Log4j2使用

slf4j+Log4j2日志的使用和slf4j+logback的使用大同小异

3.1 导入依赖

<dependencies>
   <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j2-impl</artifactId>
        <version>2.19.0</version>
    </dependency>

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.19.0</version>
    </dependency>
</dependencies>

测试类：

package com.xlb;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LOG4J2Demo {
    @Test
    public void test01(){
        Logger logger = LoggerFactory.getLogger(LOG4J2Demo.class);

        logger.trace("trace 信息");
        logger.debug("debug 信息");
        logger.info("info 信息");
        logger.warn("warn 信息");
        logger.error("error 信息");
    }
}

3.2.1 不使用配置文件

在这里插入图片描述
可以看到只输出了ERROR级别的日志，因此log4j2的日志的默认日志级别为error级别。

3.2.2 使用配置文件

3.2.2.1 输出到控制台
<?xml version="1.0" encoding="UTF-8" ?>

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
        </Console>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>

默认输出
在这里插入图片描述

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

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>

格式化输出
在这里插入图片描述

3.2.2.2 输出到文件

我们上面是将日志成功输出到了控制台，下面我们将日志输出到文件，大致过程和上面类似。
修改配置文件如下：

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

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="fileAppender"/>
        </Root>
    </Loggers>
</Configuration>
3.2.2.3 输出到控制台和文件
<?xml version="1.0" encoding="UTF-8" ?>

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
            <AppenderRef ref="fileAppender"/>
        </Root>
    </Loggers>
</Configuration>
3.2.2.4 输出到文件（对文件拆分）
<?xml version="1.0" encoding="UTF-8" ?>

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>

        <!--
        fileName:日志文件名
        $${date:yyyy-MM-dd}:表示以日期为文件夹对日志文件进行归档
-->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">

            <Policies>
                <!--                在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!--                按照文件的大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--                按照时间节点进行拆分，拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="rollingFile"/>
        </Root>
    </Loggers>
</Configuration>
3.2.2.5 自定义日志
<?xml version="1.0" encoding="UTF-8" ?>

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>

        <!--
        fileName:日志文件名
        $${date:yyyy-MM-dd}:表示以日期为文件夹对日志文件进行归档
-->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">

            <Policies>
                <!--                在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!--                按照文件的大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--                按照时间节点进行拆分，拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
    </Appenders>

    <Loggers>
        <!--        自定义Logger-->
        <Logger name="com.xlb" level="INFO"
                     includeLocation="false" additivity="false">
            <!--            将控制台输出的consoleAppender，设置为异步打印-->
            <AppenderRef ref="consoleAppender"/>
        </Logger>

        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
        </Root>

    </Loggers>
</Configuration>
3.2.2.5 异步日志
3.2.2.6.1 xml中配置异步日志
<?xml version="1.0" encoding="UTF-8" ?>

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>

        <!--
        fileName:日志文件名
        $${date:yyyy-MM-dd}:表示以日期为文件夹对日志文件进行归档
-->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">

            <Policies>
                <!--                在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!--                按照文件的大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--                按照时间节点进行拆分，拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>

        <!--        异步日志-->
        <Async name="myAsync">
            <AppenderRef ref="consoleAppender"/>
        </Async>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="rollingFile"/>
        </Root>
    </Loggers>
</Configuration>
3.2.2.6.2 全局异步日志

全局日志需要在properties文件中指明，xml文件中不需要特殊声明异步日志(文件名为log4j2.component.properties)

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

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

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>

        <!--
        fileName:日志文件名
        $${date:yyyy-MM-dd}:表示以日期为文件夹对日志文件进行归档
-->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">

            <Policies>
                <!--                在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!--                按照文件的大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--                按照时间节点进行拆分，拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>

        <!--        异步日志-->
<!--        <Async name="myAsync">-->
<!--            <AppenderRef ref="consoleAppender"/>-->
<!--        </Async>-->
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>

按照上面这种方式声明的也是异步日志

3.2.2.6.3 混合异步日志

混合异步日志需要引入这个依赖，否则会报错

<!--        混合异步日志用-->
 <dependency>
     <groupId>com.lmax</groupId>
     <artifactId>disruptor</artifactId>
     <version>3.4.3</version>
 </dependency>

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

<Configuration>
    <properties>
        <property name="logDir">F:\\CODE\\JAVA\\LogStudyV2\\LogStudy\\LOG4J2_StudyV2\\log</property>
        <property name="pattern">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n</property>
    </properties>

    <Appenders>
<!--        输出到控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <patternLayout pattern="${pattern}"/>
        </Console>

        <!--        输出到文件-->
        <File name="fileAppender" fileName='${logDir}\\log4j2.log'>
            <!--            配置日志文件格式-->
            <patternLayout pattern="${pattern}"/>
        </File>

        <!--
        fileName:日志文件名
        $${date:yyyy-MM-dd}:表示以日期为文件夹对日志文件进行归档
-->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">

            <Policies>
                <!--                在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!--                按照文件的大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--                按照时间节点进行拆分，拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>

        <!--        异步日志-->
<!--        <Async name="myAsync">-->
<!--            <AppenderRef ref="consoleAppender"/>-->
<!--        </Async>-->
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="consoleAppender"/>
        </Root>
        <!--        自定义Logger，让自定义的logger为异步logger
            includeLocation=false表示取出日志中的行号信息（记录日志的行号会使得日志记录的非常慢！）
-->
        <AsyncLogger name="com.xlb" level="trace"
                     includeLocation="false" additivity="false">
            <!--            将控制台输出的consoleAppender，设置为异步打印-->
            <AppenderRef ref="consoleAppender"/>
        </AsyncLogger>
    </Loggers>
</Configuration>

总结：上面介绍大致介绍了市面上这两款日志的使用流程，其实日志的使用基本上就是看如何对配置文件进行配置，配置文件配置好后就可以很方便的使用日志进行记录。其实市面上虽然有好几种日志框架，不过其实现的基本思想都差不多，即有下面几点共性：

1.都会分为不同的日志级别

1.1高于当前设置的日志级别就会打印
1.2低于当前设置的日志级别就不打印
2.都设置有输出处理器
2.1输出到控制台
2.2 输出到文件
2.3拆分文件
…

3格式化输出：类似于[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %thread %L：%m%n
4异步日志
5日志父子级关系
6自定义日志

希望这篇文章对日志的使用有所帮助，希望能够一键三连呀~

如果想对日志有更深的理解，可以看下这门b站上的课程，这个可能前面20集左右是一个大佬现场直播手撸一个日志框架（没有借助IDE，在vim中一点点敲出来的，很强！！！），不过课程是使用C++讲解的，有兴趣的可以听一下，保证听完对日志会有一个更加深刻的认识！
手撸日志框架

Bug.Remove()
关注
  • 17
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 586
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 683
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 707
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1221
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1232
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1104
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1069
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
最新发布
Aishangyuwen的博客
07-22 818
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 751
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 667
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
javaScrip的学习（一）
weixin_65450681的博客
07-19 1266
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 533
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1037
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 246
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
码农生涯问题杂记
qq_38189542的博客
07-18 179
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 958
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
达梦数据库 CASE_SENSITIVE参数的理解
qq_44669390的博客
07-19 908
CASE_SENSITIVE
java的基本参数类型和引用参数类型在传递的时候是否会影响实际参数呢?
Lele0456789的博客
07-19 157
/基本数据类型在传递真实的参数时,传递的是真实的数据,形参的改变,不影响实际参数的值。System.out.println("调用change方法前"+number);System.out.println("调用change方法后"+number);//传递引用数据类型的时候,传递的是地址值,形参的改变,影响实际参数的值。
Java的集合框架（Collection Framework）中的Iterator接口详解
m0_49013185的博客
07-22 501
在Java中，将Iterator定义为接口是一种设计上的选择，目的是提供一个统一的迭代机制，使不同类型的集合都能以一致的方式进行遍历。以下是将Iterator以下是IteratorE next();将Iterator定义为接口的主要目的是提供一个统一、灵活且可扩展的迭代机制。通过这种方式，Java集合框架能够支持多种类型的集合，并且客户端代码能够以一致的方式使用这些集合。这种设计不仅简化了集合的使用，还提高了代码的可维护性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bug.Remove()

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值