java日志打印

最新推荐文章于 2024-07-23 10:25:46 发布
最新推荐文章于 2024-07-23 10:25:46 发布
阅读量166 收藏
点赞数
文章标签： java 单元测试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43654975/article/details/135208784
版权

日志记录概述

日志框架（也叫日志实现）用来有效方便的记录日志信息。

市面流行的日志框架：

  • JUL：java原生日志框架，在java.util.logging包下

  • Log4j： Apache基金会的开源项目，Springboot1.4后不再支持log4j

  • Logback：由Log4j之父做的另一个开源项目，可靠、通用且灵活的java日志框架，使用最多

  • Log4j2：Log4j官方的第二版本，与logback相似，具有插件式结构、配置文件优化等特性，异步功能强大

市面流行的日志门面:

  • JCL
  • SLF4j

日志框架和日志门面出现顺序：

log4j–>JUL–>JCL–>slf4j -->logback -->log4j2

日志门面和日志框架的区别：

每一种日志框架都有自己单独的 API，要使用对应的框架就要使用对应的 API，这就大大的增加了应用程序代码对于日志框架的耦合性。我们使用了日志门面技术之后，对于应用程序来说，无论底层的日志框架如何改变，应用程序不需要修改任意一行代码，就可以直接上线了。

日志门面-SLF4j

门面模式（外观模式）

门面模式（Facade Pattern)，也称之为外观模式，其核心为：外部与一个子系统的通信必须通过一个统一的外观对象进行，使得子系统更易于使用。外观模式主要是体现了 Java 中的一种好的封装性。更简单的说，就是对外提供的接口要尽可能的简单。

日志门面

前面介绍的几种日志框架，每一种日志框架都有自己单独的 API，要使用对应的框架就要使用其对应的 API，这就大大的增加应用程序代码对于日志框架的耦合性。为了解决这个问题，就是在日志框架和应用程序之间架设一个沟通的桥梁，对于应用程序来说，无论底层的日志框架如何变，都不需要有任何感知。只要门面服务做的足够好，随意换另外一个日志框架，应用程序不需要修改任意一行代码，就可以直接上线。

SLF4j简介

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给 Java 日志访问提供一套标准、规范的 API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如 log4j 和 logback 等。当然 slf4j 自己也提供了功能较为简单的实现，但是一般很少用到。对于一般的 Java 项目而言，日志框架会选择 slf4i-api 作为门面，配上具体的实现框架（log4j、logback 等），中间使用桥接器完成桥接。所以我们可以得出 SLF4j最重要的两个功能就是对于日志框架的绑定以及日志框架的桥接。

官方网站：https://www.slf4j.org/

SLF4j桥接技术

通常，我们依赖的某些组件依赖于SLF4j以外的日志 API。我们可能还假设这些组件在不久的将来不会切换到SLF4j。为了处理这种情况，SLF4j附带了几个桥接模块，这些模块会将对 log4j，JCL 和 java.util.logging API 的调用重定向为行为，就好像是对 SLF4j API进行的操作一样。

SLF4j实战

案例1（使用slf4j-simple）
  1. 引入依赖：

  1. 测试

案例2

案例3

案例4

案例5（使用logback）

导入logback

如打印台出现如下信息，表示出现多个日志实现

SLF4J: Class path contains multiple SLF4J bindings. //出现多个日志实现
SLF4J: Found binding in [jar:file:/Users/lichunyu/Library/LiTool/apache-maven-3.6.3/repository/ch/qos/logback/logback-classic/1.2.11/logback-classic-1.2.11.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/Users/lichunyu/Library/LiTool/apache-maven-3.6.3/repository/org/slf4j/slf4j-simple/1.7.36/slf4j-simple-1.7.36.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [ch.qos.logback.classic.util.ContextSelectorStaticBinder] //实际使用的日志实现是logback

导入logback后，slf4j会自动使用logback来进行日志打印，用法和上面的案例相同，无需修改。

注意：如果导入多个日志实现的依赖，默认是使用先导入的日志实现。

案例6（使用nop）

导入nop依赖

导入nop依赖后，会禁止所有日志的打印，前提是nop的依赖在其他日志实现依赖的上面。

案例7（使用log4j）

导入依赖：

案例8（使用JUL）

导入依赖

总结

slf4j运行原理

案例9（将log4j替换为slf4j+logback）

使用log4j记录日志：

需求：

实施步骤：

  1. 删除log4j依赖，导入slf4j依赖和logback依赖

  2. 导入桥接器依赖

桥接器解决的是项目中日志的重构问题，当前系统中存在之前的日志API，可以通过桥接转换到s1f4j的实现。注意：引入桥接器依赖之前要先删掉log4j的依赖

  1. 引入桥接器依赖后，不改变项目源代码的情况下，可以成功编译，经过测试，成功将log4j替换为slf4j+logback

注意：

  • 在桥接器加入之后，适配器就没有必要加入了

  • 桥接器和适配器不能同时导入依赖

  • 桥接器如果配置在适配器的上方，则运行报错，不能同时出现

  • 桥接器如果配置在适配器的下方，则不会执行桥接器，没有任何的意义

桥接器原理

日志实现-Log4j2

Log4j2简介

Apache Log4j2 是对 Log4j 的升级，它比其前身 Log4j 1.x 提供了重大改进，并提供了Logback 中可用的许多改进，同时修复了 Logback 架构中的一些问题。被誉为是目前最优秀的Java 日志框架。

Log4j2特性

  • 性能提升
    Log4j2 包含基于 LMAX Disruptor 库的下一代异步记录器。在多线程场景中，异步记录器的吞吐量比 Log4j1.x 和 Logback 高18 倍，延迟低。

  • 自动重新加载配置
    与 Logback一样，Log4j2 可以在修改时自动重新加载其配置。与 Logback 不同，它会在重新配置发生时不会丢失日志事件。

  • 高级过滤
    与 Logback 一样，Log4j2 支持基于 Log 事件中的上下文数据，标记，正则表达式和其他组件进行过滤。此外，过滤器还可以与记录器关联。与 Logback 不同，Log4j2 可以在任何这些情况下使用通用的 Filter 类。

  • 插件架构
    Log4j2 使用插件模式配置组件。因此，您无需编写代码来创建和配置 Appender, Layout,Pattern Converter 等。在配置了的情况下，Log4j2自动识别插件并使用它们。

  • 无垃圾机制
    在稳态日志记录期间，Log4j2 在独立应用程序中是无垃圾的，在 Web 应用程序中是低垃圾。这减少了垃圾收集器的压力，并且可以提供更好的应性能。

目前市面上最主流的日志门面就是 SLF4J，虽然 Log4j2 也是日志门面，因为它的日志实现功能非常强大，性能优越，所以我们一般情况下还是将 Log4i2 看作是日志的实现。SLF4i + Log4i2 的组合，是市场上最强大的日志功能实现方式，绝对是未来的主流趋势。

Log4j2实战

案例1（单纯使用log4j2）
  1. 导入依赖：

  1. 测试：

案例2（使用log4j2配置文件 ）

  1. 创建配置文件

    <?xml version="1.0" encoding="UTF-8" ?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">
    <!--配置Appender 控制台-->
    <Appenders>
      <!--配置控制台-->
        <Console name="consoleAppender" target="SYSTEM_ERR"></Console>
    </Appenders>
    <!--配置logger-->
    <Loggers>
        <!--配置rootlogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>

  2. 测试

package boot;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;

public class MyTest {

    @Test
    public void test01(){
        Logger logger = LogManager.getLogger(MyTest.class);
        logger.fatal("fatal信息");
        logger.error("error信息");
        logger.warn("warn信息");
        logger.info("info信息");
        logger.debug("debug信息");
        logger.trace("trace信息");
    }
}
案例3（slf4j+log4j2）

  1. 导入依赖

  1. 测试
    @Test
    public void test02(){
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
       	//logger.fatal("fatal信息"); slf4j没有fatal日志级别
        logger.error("error信息");
        logger.warn("warn信息");
        logger.info("info信息");
        logger.debug("debug信息");
        logger.trace("trace信息");
    }
案例4（日志输出到文件）
  1. 配置文件：
<?xml version="1.0" encoding="UTF-8" ?>
<Configuration xmlns="http://logging.apache.org/log4j/2.0/config">
    <Properties>
        <Property name="logDir">/Users/xxx/Downloads/</Property>
    </Properties>
    <!--配置Appender-->
    <Appenders>
        <!--配置控制台输出-->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <!--配置控制台输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </Console>

        <!--配置日志文件输出-->
        <File name="fileAppender" fileName="${logDir}/log4j2.log">
            <!--配置日志文件输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </File>
    </Appenders>

    <!--配置logger-->
    <Loggers>
        <!--配置rootlogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender"/>
            <AppenderRef ref="fileAppender"/>
        </Root>
    </Loggers>
</Configuration>
  1. 测试
    @Test
    public void test02(){
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
       	//logger.fatal("fatal信息"); slf4j没有fatal日志级别
        logger.error("error信息");
        logger.warn("warn信息");
        logger.info("info信息");
        logger.debug("debug信息");
        logger.trace("trace信息");
    }
案例4（日志拆分）
  1. 配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<Configuration>

    <!--配置全局属性，供其他标签使用,通过${name}的形式取值-->
    <Properties>
        <Property name="logDir">/Users/xxx/Downloads/</Property>
    </Properties>

    <!--配置Appender-->
    <Appenders>
        <!--配置控制台输出-->
        <!--
            输出目标的配置，
            System.out：以黑色字体（默认）
            System.err：红色字体
        -->
        <Console name="consoleAppender" target="SYSTEM_ERR">
            <!--配置控制台输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </Console>

        <!--配置日志文件输出-->
        <File name="fileAppender" fileName="${logDir}/log4j2.log">
            <!--配置日志文件输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </File>

        <!--按照指定规则来拆分日志文件-->
        <!--
            1. fileName: 日志文件的名字
            2. filePattern: 日志文件拆分后文件的命名规则
            3. $${date:yyyy-MM-dd}: 根据日期当天，创建一个文件夹
                例如：
                    2021-01-01这个文件卖中，记录当天的所有日志信息（拆分出来的日志放在这个文件夹中）
                    2021-01-02这个文件夹中，记录当天的所有日志信息（拆分出来的日志放在这个文件夹中）
            4. rollog-%d{yyyy-MM-dd-HH-mm}-%i.1og: 日志文件命名的规则: ％i表示序号，从0开始，目的是为了让每一份文件名字不会重复
        -->
        <RollingFile name="rollingFile" fileName="${logDir}/rollog.log"
                     filePattern="${logDir}/$${date:yyyy-MM-dd}/rollog-%d{yyyy-MM-dd-HH-mm}-%i.log">
            <!-- 日志消息格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"/>
            <!--拆分策略-->
            <Policies>
                <!-- 在系统启动时，触发拆分规则，产生一个日志文件-->
                <OnStartupTriggeringPolicy/>
                <!-- 按文件大小进行拆分-->
                <SizeBasedTriggeringPolicy size="10KB"/>
                <!--按照时间节点进行拆分,拆分规则就是filePattern-->
                <TimeBasedTriggeringPolicy/>
            </Policies>

            <!--在同一目录下，文件的个数限制，如果超出了设置的数值，则根据时间进行覆盖，新的覆盖旧的-->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
    </Appenders>

    <!--配置logger-->
    <Loggers>
        <!--配置rootlogger, root => rootLogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender"/>
<!--            <AppenderRef ref="fileAppender"/>-->
            <AppenderRef ref="rollingFile"/>
        </Root>
    </Loggers>
</Configuration>
  1. 测试
    @Test
    public void test02(){
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
        for (int i = 0; i < 2000; i++) {
            logger.error("error信息");
            logger.warn("warn信息");
            logger.info("info信息");
            logger.debug("debug信息");
            logger.trace("trace信息");
        }
    }

Log4j2异步日志

异步日志是 log4j2 最大的特色，其性能的提升主要也是从异步日志中受益。Log4j2 提供了两种实现日志的方式，一个是通过 AsyncAppender，一个是通过 AsyncLogger，分别对应前面我们说的 Appender 组件和 Logger 组件。注意这是两种不同的实现方式，在设计和源码上都是不同的体现。

AsyncAppender 方式

是通过引用别的 Appender 来实现的，当有日志事件到达时，会开启另外一个线程来处理它们。需要注意的是，如果在 Appender 的时候出现异常，对应用来说是无法感知的。AsyncAppender 应该在它引用的Appender 之后配置，默认使用java.util.concurrent.ArrayBlockingQueue 实现而不需要其它外部的类库。当使用此 Appender 的时候，在多线程的环境下需要注意，阻塞队列容易受到锁争用的影响，这可能会对性能产生影响。这时候，我们应该考虑使用无锁的异步记录器（AsyncLogger）。

AsyncLogger 方式

AsyncLogger 才是 log4j2 实现异步最重要的功能体现，也是官方推荐的异步方式。它可以使得调用 Logger.log返回的更快。

你可以有两种选择：全局异步和混合异步。

全局异步：所有的日志都异步的记录，在配置文件上不用做任何改动，只需要在jvm启动的时候增加一个参数即可实现。
混合异步：你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活。虽然 Log4j2 提供以一套异常处理机制，可以覆盖大部分的状态，但是还是会有一小部分的特殊情况是无法完全处理的，比如我们如果是记录审计日志（特殊情况之一），那么官方就推荐使用同步日志的方式，而对于其他的一些仅仅是记录一个程序日志的地方，使用异步日志将大幅提升性能，减少对应用本身的影响。混合异步的方式需要通过修改配置文件来实现，使用 AsyncLogger 标记配置。

异步日志实现实例
案例1（AsyncAppender）
  1. 添加异步日志依赖

​ 经测试，springboot中不需要引入该依赖

  1. 在Appenders标签中，对于异步进行配置，使用Async标签

  2. rootlogger引用Async

<?xml version="1.0" encoding="UTF-8" ?>
<Configuration>
    <!--配置Appender-->
    <Appenders>
        <!--配置控制台输出-->
        <Console name="consoleAppender" target="SYSTEM_OUT">
            <!--配置控制台输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </Console>

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

    <!--配置logger-->
    <Loggers>
        <!--配置rootlogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="myAsync"/>
        </Root>
    </Loggers>
</Configuration>

测试

    @Test
    public void test03(){
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
        //日志记录
        for (int i = 0; i < 2000; i++) {
            logger.error("error信息");
            logger.warn("warn信息");
            logger.info("info信息");
            logger.debug("debug信息");
            logger.trace("trace信息");
        }
        //业务逻辑
        for (int i = 0; i < 1000; i++) {
            System.out.println("-------------------");
        }
    }
案例2（AsyncLogger-全局异步日志）

AsyncLogger的全局异步日志不需要在配置文件上不用做任何的改动，只需要导入异步日志依赖，然后在类路径resources下添加一个名为log4j2.component.properties的文件，然后在文件中输入:Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

  1. 导入依赖

image-20231220223424565

  1. 新建log4j2.component.properties文件或添加jvm参数-DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
  2. 配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<Configuration>
    <!--配置Appender-->
    <Appenders>
        <!--配置控制台输出-->
        <Console name="consoleAppender" target="SYSTEM_OUT">
            <!--配置控制台输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </Console>
    </Appenders>

    <!--配置logger-->
    <Loggers>
        <!--配置rootlogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>
  1. 测试
    @Test
    public void test03(){
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
        //日志记录
        for (int i = 0; i < 2000; i++) {
            logger.error("error信息");
            logger.warn("warn信息");
            logger.info("info信息");
            logger.debug("debug信息");
            logger.trace("trace信息");
        }
        //业务逻辑
        for (int i = 0; i < 1000; i++) {
            System.out.println("-------------------");
        }
    }
案例3（AsyncLogger-混合异步日志）

混合异步日志可以在应用中同时使用同步日志和异步日志，这使得日志的配置及输出会更加的灵活。

  1. 导入依赖
<dependency>
  <groupId>com.lmax</groupId>
  <artifactId>disruptor</artifactId>
  <version>3.4.2</version>
</dependency>
  1. 配置AsyncLogger组件
<?xml version="1.0" encoding="UTF-8" ?>
<Configuration>
    <!--配置Appender-->
    <Appenders>
        <!--配置控制台输出-->
        <Console name="consoleAppender" target="SYSTEM_OUT">
            <!--配置控制台输出格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t [%p] %c (%F:%L) %msg%n"></PatternLayout>
        </Console>
    </Appenders>

    <!--配置logger-->
    <Loggers>
        <!-- 自定义logger，让自定义的logger为异步logger -->
        <!--
            name="com.day01" 表示只有在com.day01包下/子包下的类才会异步记录日志
            includeLocation="false" 表示去除日志记录中的行号信息，这个行号信息非常的影响日志记录的效率（生产中都不加这个行号）,严重的时候可能记录的比同步的日志效率还有低
            additivity="false" 表示不继承rootlogger
        -->
        <AsyncLogger name="com.day01" level="trace"
                     includeLocation="false" additivity="false">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender" />
        </AsyncLogger>

        <!--配置rootlogger-->
        <Root level="trace">
            <!--引用Appender-->
            <AppenderRef ref="consoleAppender"/>
        </Root>
    </Loggers>
</Configuration>
  1. 测试
package com.day01.testlog;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.slf4j.LoggerFactory;

public class MyTest {
		@Test
    public void test03() {
        //因为MyTest.class在com.day01.testlog包下，所以会异步记录
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
        //日志记录
        for (int i = 0; i < 2000; i++) {
            logger.error("error信息");
            logger.warn("warn信息");
            logger.info("info信息");
            logger.debug("debug信息");
            logger.trace("trace信息");
        }
        //业务逻辑
        for (int i = 0; i < 1000; i++) {
            System.out.println("-------------------");
        }
    }
}

package com.day02.testlog;

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

public class MyTest {
    @Test
    public void test03() {
      	//因为MyTest.class在com.day02.testlog包下，所以不会异步记录
        org.slf4j.Logger logger = LoggerFactory.getLogger(MyTest.class);
        //日志记录
        for (int i = 0; i < 2000; i++) {
            logger.error("error信息");
            logger.warn("warn信息");
            logger.info("info信息");
            logger.debug("debug信息");
            logger.trace("trace信息");
        }
        //业务逻辑
        for (int i = 0; i < 1000; i++) {
            System.out.println("-------------------");
        }
    }
}

注意：

AsyncAppender、AsyncLogger不要同时出现，效果不会叠加，如果同时出现，那么会以AsyncAppender为主
AsyncLogger的全局异步和混合异步也不要同时出现，如果同时出现，那么会以全局异步为主

Springboot日志记录

SpringBoot 默认就是使用 SLF4J 作为日志门面，Logback 作为日志实现来记录日志。

springboot导入spring-boot-starter-web依赖后会默认导入日志相关的依赖

实战

案例1（springboot默认日志）

案例2（测试log4j2桥接器）

案例3（application.yml中进行日志配置）
  1. 在配置文件application中配置日志级别和打印格式

  1. 测试

案例4（输出到文件）

案例5（日志拆分）

日志拆分等高级功能需要在日志的配置文件中单独配置

案例6（集成log4j2）

  1. 排除依赖

  1. 引入依赖

image-20231221012224161

a coding ape
关注
java开发日志打印
11-23
日志打印日志打印日志打印日志打印日志打印日志打印日志打印日志打印
Java 程序如何正确地打印日志？
good7ob的博客
04-21 5104
本文介绍了 Java 程序如何正确地打印日志。正确地打印日志可以帮助我们快速定位问题，并提高代码的可维护性和可读性。在打印日志时，我们需要选择合适的日志框架、日志级别和日志格式，并避免使用 System.out.println() 的方式来输出调试信息。希望本文对大家有所帮助。
Java中日志的打印
最新发布
m0_64445738的博客
07-23 134
在util下创FileUtil类。在util下创建LogUtil。
java程序正确的打印日志
一个不知退路的码农
01-13 3067
什么是日志 简单的说，日志就是记录程序的运行轨迹，方便查找关键信息，也方便快速定位解决问题。 我们 Java 程序员在开发项目时都是依赖 Eclipse/ Idea 等开发工具的 Debug 调试功能来跟踪解决 Bug，在开发环境可以这么做，但项目发布到了测试、生产环境呢？你有可能会说可以使用远程调试，但实际并不能允许让你这么做。 所以，日志的作用就是在测试、生产环境没有 Debug 调试工具时开发、测试人员定位问题的手段。日志打得好，就能根据日志的轨迹快速定位并解决线上问题，反之，日志输出不好不能定位
java打印日志的几种方式
Android framework
02-07 1749
java打印日志的几种方式
java 打印日志的几种方式
qq_20236937的博客
01-02 3435
日志门面：只提供日志相关的接口定义，即相应的 API，而不提供具体的接口实现。日志门面在使用时，可以动态或者静态地指定具体的日志框架实现，解除了接口和实现的耦合，使用户可以灵活地选择日志的具体实现框架。在上文中已经提及，目前常用的日志框架有 Log4j，Log4j 2，Commons Logging，Slf4j，Logback，JUL。日志系统：与日志门面相对，它提供了具体的日志接口实现，应用程序通过它执行日志打印的功能。log4j、log4j2、Logback是一个日志框架，slf4j是日志框架接口，
java 日志打印+持久化
02-28
java 日志打印+持久化
浅谈java日志格式化
08-26
浅谈Java日志格式化 在软件开发中，日志是一个非常重要的数据，特别是在程序发生异常时，日志可以提供非常有价值的信息。但是，并不是打印的日志越多越好，我们需要的是有用的日志。下面我们来讨论一下Java日志格式...
java启动jar包将日志打印到文本的简单操作
08-18
Java 启动 jar 包将日志打印到文本的简单操作 在 Java 中，日志的使用是非常重要的，它可以帮助我们记录运行信息、错误信息和存储运行记录。今天，我们将介绍如何在 Java 中启动 jar 包将日志打印到文本的简单操作...
Log4j
qq_43310689的博客
10-13 617
文章目录一、Log4j1、Log4j入门简介学习2、入门实例2.1、新建项目2.2、添加属性文件2.3、设置日志内容2.4、输出结果3、Log4j基本使用方法4、定义配置文件在配置文件中使用Log4j在代码中使用Log4j 一、Log4j 日志是应用软件中不可缺少的部分，Apache的开源项目log4j是一个功能强大的日志组件,提供方便的日志记录。在apache网站：jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。 1、Log4j入门简介学习 Log4j是Apac
打印日志（JAVA）
m0_69134284的博客
04-03 1556
SLF4J是⻔⾯模式的典型应⽤，⻔⾯模式（Facade Pattern）⼜称为外观模式, 提供了⼀个统⼀的接⼝, ⽤来访问⼦系统中的⼀群接⼝. 其主要特征是定义了⼀个⾼层接⼝, 让⼦系统更容易使⽤。SLF4J不同于其他⽇志框架, 它不是⼀个真正的⽇志实现, ⽽是⼀个抽象层, 对⽇志框架制定的⼀种规范, 标准, 接⼝. 所有SLF4J并不能独⽴使⽤, 需要和具体的⽇志框架配合使用。（2）提⾼了灵活性, 简化了客⼾端对⼦系统的使⽤难度, 客⼾端⽆需关⼼⼦系统的具体实现⽅式, ⽽只需要和⻔⾯对象交互即可.
java打印日志
积累与备忘
09-22 2193
前言 大家好，我是程序员田螺。日志是快速定位问题的好帮手，是撕逼和甩锅的利器！打印好日志非常重要。今天我们来聊聊日志打印的15个好建议~ 1. 选择恰当的日志级别 常见的日志级别有5种，分别是error、warn、info、debug、trace。日常开发中，我们需要选择恰当的日志级别，不要反手就是打印info哈~ error：错误日志，指比较严重的错误，对正常业务有影响，需要运维配置监控的； warn：警告日志，一般的错误，对业务影响不大，但是需要开发关注； info：信息日志，记录排查问题的关键
系统开发系列 之Java中打印日志的几种方式
langxiaolin的博客
11-05 3901
项目同时导入log4j 和commons-logging的jar 包， 不需要配置commons-logging.properties ，只需要在classpath中配置 log4j.properties就可以使用log4j的方式记录日志。org.apache.commons.logging.impl.SimpleLog　common-logging自带日志实现类。org.apache.commons.logging.impl.NoOpLog　common-logging自带日志实现类。
java日志打印使用指南
程序员丰极
01-17 3117
一、简介 日志打印是java代码开发中不可缺少的重要一步。 日志可以排查问题，可以搜集数据 二、常用日志框架 比较常用的日志框架就是logback, 一些老项目会使用log4j，他们用的都是slf4j-api统一接口。 (1) 使用log4j log4j使用： 1. slf4j-api-1.5.11.jar 2. slf4j-log4j12-1.5.11.jar 3. log4j-1.2.15.jar 4. log4j.properties 代码中 import org.slf4j.Logger;
java：打印日志log
weixin_45730125的博客
07-21 3467
java：打印日志
java如何用LOG打印日志并输出信息到文件中
热门推荐
zuihongyan518的博客
08-11 4万+
使用log4j.jar。log4j 是apache 提供的记录日志的jar 档。 下载地址：http://logging.apache.org/log4j/1.2/download.html 除了这个包外，还需要另一个jar包：.commons-logging.jar 下载地址：https://download.csdn.net/download/zuihongyan518/10597130...
JAVA打印日志规范实践
今天又是充满希望的一天
12-03 1268
JAVA日志打印规范实践
Java 程序如何正确地打日志
不正经的大叔
07-09 2万+
什么是日志简单的说，日志就是记录程序的运行轨迹，方便查找关键信息，也方便快速定位解决问题。我们 Java 程序员在开发项目时都是依赖 Eclipse/ Idea 等开发工具的 Debug 调试功能来跟踪解决 Bug，在开发环境可以这么做，但项目发布到了测试、生产环境呢？你有可能会说可以使用远程调试，但实际并不能允许让你这么做。所以，日志的作用就是在测试、生产环境没有 Debug 调试工具时开发、测...
JAVA如何打印日志
05-31
在Java中，打印日志一般使用日志框架，比如常用的Log4j、Logback、Java Logging等。以下是使用Java Logging打印日志的示例代码： ```java import java.util.logging.Logger; public class MyClass { private static final Logger LOGGER = Logger.getLogger(MyClass.class.getName()); public void myMethod() { LOGGER.info("This is an information message"); LOGGER.warning("This is a warning message"); LOGGER.severe("This is a severe message"); } } ``` 在上面的代码中，我们首先通过Logger.getLogger()方法获取Logger对象，然后使用该对象的info()、warning()、severe()等方法打印不同级别的日志信息。在执行程序时，可以通过配置日志级别的方式控制日志的输出。例如，在Java Logging中，可以通过在配置文件中设置级别来控制输出，如下所示： ``` handlers= java.util.logging.ConsoleHandler .level= INFO java.util.logging.ConsoleHandler.level = INFO ``` 上面的配置文件表示只输出级别为INFO及以上的日志信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值