日志框架学习【松思园】

最新推荐文章于 2024-05-25 19:50:28 发布
最新推荐文章于 2024-05-25 19:50:28 发布
阅读量195 收藏
点赞数
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25050537/article/details/114257705
版权

一、日志的作用和目的

日志用于记录系统的操作事件的文件集合，可分为事件日志和消息日志，对于我们处理历史数据、诊断问题的追踪以及理解系统的活动等有着重要的作用。

二、日志分类

日志门面： JCL 、slf4j

日志实现：JUL、logback、log4j、log4j2

2.1 JUL

全称 java util logging 是java的原生日志框架。

<!--**JUL 日志包的引用**-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

JavaJULTest.class

public class JavaJULTest {

	@Test
	public void testJUL() {
		// 1.获取日志记录器对象
		Logger logger = Logger.getLogger("JavaJULTest");
		// 2.日志记录输出
		logger.info("hello jul");
		// 3.通用方法进行日志记录
		logger.log(Level.INFO, "=====hello jul");
		// 4.通过占位符，传输变量
		String name = "test";
		Integer age = 12;
		logger.log(Level.INFO, "hello {0}{1}", new Object[]{name, age});
	}

}

日志的级别：
SEVERE（最高值）
WARNING
INFO
CONFIG
FINE
FINER
FINEST（最低值）
还有一个级别 OFF，可用来关闭日志记录，使用级别 ALL 启用所有消息的日志记录。
logger默认的级别是INFO，比INFO更低的日志将不显示。

使用自定义的日志配置文件：logging.properties

# 输出到文件和控制台
handlers= java.util.logging.FileHandler,java.util.logging.ConsoleHandler

# root日志输出级别 level
.level= INFO

# 控制台输出级别和格式
java.util.logging.ConsoleHandler.level = FINER
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# 文件输出级别和地址
java.util.logging.FileHandler.level=CONFIG
java.util.logging.FileHandler.pattern = C:\\Users\\\13965\\TestProperties.txt
#限制文件的大小（50000字节）
java.util.logging.FileHandler.limit = 50000
#过滤，总共保存1个文件,接着覆盖
java.util.logging.FileHandler.count = 1
#XMLFormatter是以xml样式输出，SimpleFormatter是以普通样式输出
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
#指定是否应该将 FileHandler 追加到任何现有文件上（false会覆盖，但默认为false）。
java.util.logging.FileHandler.append=true

自定义类加载器：LogManager.class

public class LogManager {
	// 初始化LogManager
	static {
		ClassLoader cl = LogManager.class.getClassLoader();
		InputStream inputStream = null;
		if (cl != null) {
			inputStream = cl.getResourceAsStream("logging.properties");
		} else {
			inputStream = ClassLoader
					.getSystemResourceAsStream("logging.properties");
		}
		java.util.logging.LogManager logManager = java.util.logging.LogManager
				.getLogManager();
		try {
			// 重新初始化日志属性并重新读取日志配置。
			logManager.readConfiguration(inputStream);
		} catch (SecurityException e) {
			System.err.println(e);
		} catch (IOException e) {
			System.err.println(e);
		}
	}

	/**
	 * 获取日志对象
	 * @param clazz
	 * @return
	 */
	public static Logger getLogger(Class clazz) {
		Logger logger = Logger
				.getLogger(clazz.getName());
		return logger;
	}
}

测试方法：

// 加载自定义的配置类
	@Test
	public void testLogiProperties() {
		//	读取配置文件
		Logger logger = LogManager.getLogger(JavaJULTest.class);
		logger.info("sssssssssssssssssssssssssssssss");
	}

2.2 Log4j

是apache下的一款开源日志框架，可以控制日志信息输出的位置，格式，级别，更灵活的控制日志的输出过程。

pom引入依赖

<dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13-beta-1</version>
        </dependency>

Log4jTest.class

public class Log4jTest {

	@Test
	public void testLog4j() {
		// 初始化配置信息
		BasicConfigurator.configure();
		// 获取日志记录器对象
		Logger logger = Logger.getLogger(Log4jTest.class);
		//	日志记录输出
		logger.info("demo------------------");
	}
}

log4j的日志级别（由高到低）：

  • fatal： 重大错误，这种级别可以直接停止程序了。
  • error： 错误信息。用的也比较多。
  • warn： 有些信息不是错误信息，但是也要给程序员的一些提示。
  • info： 输出感兴趣的或者重要的信息，这个用的最多。
  • debug： 调试，一般就只用这个作为最低级别，trace压根不用。
  • trace： 是追踪。

自定义配置文件 log4j.properties

# 指定 RootLogger 顶级父元素默认配置信息,输出的地方包括，控制台+文件
log4j.rootLogger =trace,console,fileAppender,dailyRollingFile

# 配置输出到控制台
log4j.appender.console = org.apache.log4j.ConsoleAppender
# 配置输出格式
log4j.appender.console.layout= org.apache.log4j.PatternLayout
# 指定消息内容的格式
log4j.appender.console.layout.ConversionPattern =%p %r %c %t %F %l %d{yyyy-MM-dd HH:mm:ss} %m%n

# %m    输出代码中指定的日志信息
# %p    输出优先级，及debug、info等
# %n    换行符
# %r    输出自应用启动到输出该log信息耗费的毫秒数
# %c    输出打印语句所属的类的全名
# %t    输出产生该日志的线程全名
# %d    输出服务器当前时间，可指定格式，如 %d{yyyy年MM月dd日 HH:mm:ss}
# %l    输出日志时间发生的位置，包括类名、线程、及在代码中的行数
# %F    输出日志消息产生时所在的文件名称
# %L    输出代码中的行号
# %%    输出一个 “%” 字符

### 配置输出到文件 ###
log4j.appender.fileAppender = org.apache.log4j.FileAppender
log4j.appender.fileAppender.layout = org.apache.log4j.PatternLayout
log4j.appender.fileAppender.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
log4j.appender.fileAppender.File = C:/Users/13965/Log4jTestProperties.log
log4j.appender.fileAppender.encoding=UTF-8
#文件的拆分规则
log4j.appender.dailyRollingFile = org.apache.log4j.DailyRollingFileAppender

2.3 JCL

全称为 Jakarta Commons Loggin 是apache 提供的一个通用日志api。它为所有的java日志实现一个统一的接口，自身也提供一个日志实现，但是功能非常的薄弱。他有两个基本的抽象类： Log（基本记录器） 和 LogFactory（负责创建Log实例）
在这里插入图片描述
pom依赖：

 <!--jcl-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

JCLTestDemo.class

public class JCLTestDemo {

	@Test
	public void testJCLMethod() {
		Log log = LogFactory.getLog(JCLTestDemo.class);
		log.info("=============jcl==========");
	}

}

3 日志门面

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给Java日志访问提供一套标准、规范的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j和logback等，当然 slf4j 中内置了日志功能较为简单的实现，但一般用的比较少，都是结合第三方日志框架进行使用比如 slf4j+logback / log4j2。他提供了两大功能：日志框架的绑定 和 日志框架的桥接

在这里插入图片描述日志框架的出现历史顺序：
log4j >> JUL >> JCL(日志门面) >> slf4j（日志门面） >> logback >> log4j2

3.1 slf4j

pom.xml 依赖

<!-- slf4j 日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!--slf4j 内置的简单实现-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>

Slf4jDemo.class

public class Slf4jDemo {

	public static final Logger logger = LoggerFactory.getLogger(Slf4jDemo.class);

	@Test
	public void slf4jMethod() {
		logger.error("error...........");
		logger.warn("warn...........");
		logger.info("info...........");
		logger.debug("debug...........");
		logger.trace("trace...........");
		//	占位符
		String name = "demo+++";
		Integer age = 12;
		logger.info("===test:{}{}", name, age);
		try {
			int num = 1 / 0;
		} catch (Exception e) {
			logger.info("存在异常：", e);
		}
	}

}

上面我们用的是他内置的 simple 简单框架，下面我们来绑定第三方日志框架。
注意：如果同时绑定内置的简单日志框架和第三方的日志框架，slf4j默认会使用 内置的简单框架；

绑定 logback 日志框架：

<dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>5.3</version>
        </dependency>

另外，在绑定 log4j 和 JUL框架时要加适配器。
使用 slf4j 的日志绑定流程：
在这里插入图片描述

slf4j 日志开关，通过引入该开关，可以关闭slf4j对日志框架的绑定，也就是不使用日志框架。

	<!--slf4j 日志开关-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
        </dependency>

3.2 logback 日志框架

logback是由log4j创始人设计的另一个开源日志框架，性能要优于log4j。
主要包含三个模块：
logback-core：其他两个模块的基础模块
logback-classic：是log4j的一个改良版本，同时它完整实现了 slf4j API
logback-access：访问模块与Servlet 容器集成提供通过 http 来访问日志的功能。
使用 slf4j + logback 实现

logback 的配置：
以此会读取以下类型的配置文件：
logback.groovy
logback-test.xml
logback.xml

这里配置的是：logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 最好使用绝对路径 -->
    <property name="LOG_HOME" value="C:/files/open_platform_log"/>

    <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %5level [%10thread] [%X{request-id}] %40.40logger{40} [%10method,%line] : %msg%n"/>

    <!--控制台日志输出-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="UTF-8">
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <appender name="SYS_INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <append>true</append>
        <!--过滤器,只打INFO级别的日志-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/info/open-info-%d{yyyy-MM-dd}.log</fileNamePattern>
            <!--保留最近365日的日志，最大日志保存10GB，如果超过则删除旧日志-->
            <maxHistory>365</maxHistory>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>

        <encoder charset="UTF-8">
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <appender name="SYS_ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <append>true</append>
        <!--过滤器,只打ERROR级别的日志-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/error/open-error-%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>12</maxHistory>
        </rollingPolicy>

        <encoder charset="UTF-8">
            <pattern>${log.pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--info和error分开打印-->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="SYS_INFO"/>
        <appender-ref ref="SYS_ERROR"/>
        <appender-ref ref="LOGSTASH"/>
    </root>

</configuration>

3.3 log4j2 日志框架

log4j2 是对Log4j的升级版参考了logback的一些设计理念，并修复了一些问题，因此有一定的提升：

  • 异常处理：在logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异常处理机制。
  • 性能提升：log4j2 相对于 logback 和 log4j 都具有很明显的性能提升。
  • 自动重载配置：参考了 logback 的设计，提供了自动刷新参数配置，最实用的就是我们在生成上可以动态的修改日志的级别而不需要重启应用。
  • 无垃圾机制：log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的 jvm gc。

log4j2 + slf4j 使用：

pom的jar导入：

<!-- slf4j 日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!--log4j2 日志实现-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!--适配器log4j2-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.4.1</version>
        </dependency>

配置文件 log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- status 日志框架本身的输出日志级别  monitotInterval 不低于5秒-->
<Configuration status="debug" monitotInterval="5">
    <!--集中配置属性进行管理-->
    <properties>
        <property name="LOG_HOME">/logs</property>
        <property name="ERROR_LOG_FILE_NAME">error</property>
    </properties>
    <!--日志处理-->
    <appenders>
        <!--控制台输出-->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="-%d %-5p (%F:%L) - %m%n" />
        </Console>
        <RollingRandomAccessFile name="ErrorLog"
                                 fileName="logs/${ERROR_LOG_FILE_NAME}.log"
                                 filePattern="logs/${ERROR_LOG_FILE_NAME}.log.%d{yyyy-MM-dd}.gz">
            <PatternLayout
                    pattern="%d %-5p (%F:%L) - %m%n"/>
            <Policies>
                <SizeBasedTriggeringPolicy size="1KB"/>
            </Policies>
        </RollingRandomAccessFile>
    </appenders>
    <loggers>
        <root level="info">
            <appender-ref ref="ErrorLog"></appender-ref>
        </root>
    </loggers>
</Configuration>

Slf4j2TestDemo.class

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

public class Slf4j2TestDemo {
	private static final Logger logger = LoggerFactory.getLogger(Slf4j2TestDemo.class);

	@Test
	public void slf4j2Method() {
		//	日志记录输出
		logger.info("demo------------------");
		logger.debug("debug------------------");
		logger.error("error------------------");
	}

}

log4j2 异步日志
Log4j 2中记录日志的方式有同步日志和异步日志两种方式，其中异步日志又可分为使用AsyncAppender和使用AsyncLogger(最优的选择)两种方式。
【同步日志】：当输出日志时，必须等待日志输出语句执行完毕后，才能执行后面的业务逻辑语句。
【异步日志】：日志输出语句与业务逻辑语句并不是在同一个线程中运行，而是有专门的线程用于进行日志输出操作，处理业务逻辑的主线程不用等待即可执行后续业务逻辑。

log4j2 使用异步日志，要引用jar包：

<!--log4j2 异步日志-->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.4</version>
        </dependency>

全局异步：所有的日志都异步记录，在配置文件上不用做任何的改动，只需要添加一个 log4j2.component.properties 配置：

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

混合异步：可以在应用中同时使用同步日志和异步日志，使得日志的配置方式更加的灵活。

（1）全局日志：
在 log4j2.xml 中添加：
在这里插入图片描述
(2) 混合异步：要先把全局异步的配置给关闭，然后在 log4j2.xml 中添加配置：
在这里插入图片描述
注意：
1、如果使用异步日志，AsyncAppender、AsyncLogger 和全局日志，不要同时使用，否则性能可能会降低。
2、设置 includeLocation=false，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢。

三、springboot 中使用 sfl4j +log4j2

松思园
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文弄懂Java日志框架
十八岁讨厌编程的博客
07-10 1625
本文涉及日志的概念、日志门面、JUL日志框架、Log4J日志框架、JCL日志门面、SLF4J日志门面、LogBack日志框架、Log4J2日志框架、SpringBoot中的日志使用等内容。
SpringBoot学习笔记（三）整合Logback日志框架
小鲁蛋的博客
03-06 2418
通过日志查看程序的运行过程，运行信息，异常信息等。
Log 日志框架
最新发布
weixin_37896883的博客
05-25 366
日志框架 日志是由一个抽象层+实现层的组合来搭建的 日志框架的比较 slf4 是对所有日志框架制定的一种规范、标准、接口，并不是一个框架的具体的实现 日志实现(log4j、logback、log4j2) log4j是apache实现的一个开源日志组件 logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架，是slf4j的原生实现 log4j2是log4j 1.x和logback的改进版，据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4
日志（常用的日志框架）
qq_42709715的博客
06-07 1202
Log4j是Apache的一个Java的日志库，通过使用Log4j，我们可以控制日志信息输送的目的地（控制台、文件、数据库等）；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。...
深入理解 SpringBoot 日志框架：从入门到高级应用——（一）日志框架原理
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
06-12 1158
深入理解 SpringBoot 日志框架：从入门到高级应用——（一）日志框架原理
博客摘录 Java中的日志框架总结
liudachu的博客
04-27 972
日志框架 Java中现有的日志框架： 日志门面：JCL（Jakarta Common Logging）、SLF 日志实现：JUL（Java Util Logging）、log4j、logback、log4j2 logback 比 log4j 功能更加强大，性能更加好；log4j2 与 logback 功能相似，但前者的性能更好 1、JUL 1.1 JUL介绍 JUL：全称 Java Util Logging，它是 Java 原生的日志框架，使用时不需要引入第三方类库，相对其它日志框架使用方便、学习简单，
北圣思园Hibernate源代码及课件
11-29
【标题】"北圣思园Hibernate源代码及课件"是一个专门针对Java开发框架Hibernate的教育资源，由知名教育机构北圣思园提供。这个资源包含了详细的源代码实例和配套的课件，旨在帮助学习者深入理解和掌握Hibernate在...
AutoCAD设计图纸园博会寄思园中心公园展区规划设计施工图-dwg源格式.zip
11-27
《AutoCAD设计在园博会上的应用——以“寄思园”中心公园展区为例》 AutoCAD，全称为Autodesk Computer Aided Design，是一款由Autodesk公司开发的专业计算机辅助设计软件，广泛应用于土木工程、建筑地产、毕业设计...
java 学习笔记
08-03
5. **集合框架**：Java集合框架包括接口（如List、Set、Map）和实现（如ArrayList、LinkedList、HashSet、HashMap等），它们用于存储和操作对象数组。理解这些集合类的特性及其使用场景是高效编程的关键。 6. **...
张龙老师java课件
04-04
【Java基础知识】 ...张龙老师的课程旨在让学习者对Java有全面而深入的理解，通过实例和清晰的解释，使复杂的概念变得易于掌握。这些课程资料对于初学者和希望提升Java技能的开发者来说都是宝贵的资源。
ESRI.ArcGIS.Diagrammer.Setup.102.20130828
06-13
ArcGIS.Diagrammer安装包，博客里有解决版本不匹配的方法。ArcGIS Diagrammer 是GIS专业人员用来创建、...版权声明：本文为CSDN博主「积思园」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
Java日志框架 -- LOG4J（Log4j入门案例、日志级别、Log4j组件（Loggers、Appenders、Layouts）、配置文件、内置日志记录、自定义Logger）
天行健 君子以自强不息，地势坤 君子以厚德载物。
06-12 4833
Log4j是Apache下的一款开源的日志框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程。方便项目的调试。官方网站： http://logging.apache.org/log4j/1.2/ Log4jTest.java 出现这个的原因是因为我们没有正确的初始化 一般只使用4个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUGLog4J 主要
日志框架总结
qq_35366466的博客
03-03 2302
1、常见的日志框架有很多，如：JCL、SLF4J、Jboss-logging、JUL、log4j、log4j2、logback等。 常用日志框架类别： log4j： Apache log4j是一个基于java 的日志记录工具 log4j2：Apache log4j2 是apache开发的一款log4j的升级产品 Commons logging，一套java日志接口 slf4j：一套java日志门面，本身并无日志的实现 logback：一组日志组件的实现 JUL（java Util loggin
日志系统——框架设计
zcxmjw的博客
08-13 385
本文主要是讲解一下日志系统模块的设计，方便我们后续的实现
java日志框架学习总结
u010439466的博客
04-14 646
日志体系 一直有一个疑惑，日志为什么会有那么多的框架，到今天为止，心里终于有个比较明确的答案了。在这里我把我所理解的日志体系整理描述一下，自己总结一下，也希望对大家学习能有所帮助。 日志框架的分类 个人理解，日志框架可分为两类： 门面型日志框架： jakartaCommonsLoggingImpl(jcl), Simple Logging Facade for Java (SLF4J) 记...
日志框架学习
sss2951的博客
01-08 297
为何使用日志框架：实现定制化（分等级、文件重定位）、标准化日志输出。 目前最常用框架：slf4j，其是一套日志接口，用以解耦代码使用与具体日志框架，使得我们可以随意更换具体日志框架实现，而不必改动日志代码。 具体实现：logback、log4j等 前人介绍： https://blog.csdn.net/xn_28/article/details/62350938 https://www....
MyBatis——日志
weixin_33795833的博客
09-01 372
Logging   Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具： SLF4J Apache Commons Logging Log4j 2 Log4j JDK logging 具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按上文列举的顺序查找）。 如果一个都未找到，日志功能就会被禁用。 不少应用服务器的clas...
[笔记]Java日志框架学习
zhaole524的专栏
04-22 167
java日志框架 概览： slf4j + JCL JUL log4j logback log4j2 springboot集成
springboot与日志框架学习记录
wmh1152151276的博客
03-15 668
日志的作用 主要作用包括： 1、出问题后定位当时问题 2、显示程序当前运行状态 我们知道市面上有很多的开源日志框架如 slf4j, logback, log4j, JCL(Apache Common Logging), JUL(JDK自带的java.util.logging)等 这么多日志框架我们该怎么选择呢？ 其实上面的日志框架中有些是 日志框架的抽象层 相当于门面 它不包含日志的具体实现 比如...
日志框架介绍及使用
xulong5000的专栏
03-26 1146
一：日志简介 日志用于记录系统中硬件、软件、系统、进程和应用运行时的信息，同时可以监控系统中发生的各种事件。我们可以通过它来检查错误发生的原因，解决用户投诉的问题，找到攻击者留下的攻击痕迹。日志既可以用来生成监控图，也可以用来发出警报。 按照产生的来源，日志可以分为系统日志、容器日志和应用日志等； 按照应用目标的不同，日志可以分为性能日志、安全日志等； 按照级别的不同，日志可以分为调试日志、信息日志、警告日志和错误 日志等 。 我们在业务系统开发中，一般使用的日志框架有 Commons loggi

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值