springboot项目中使用日志

一、日志相关博客

logback:   https://blog.csdn.net/samjustin1/article/details/81005333

java日志的级别：  https://blog.csdn.net/qq_29580525/article/details/79482020

二、需要记住的日志级别

   虽然Java中有八个日志级别，但是常用的就四个，从高到低是  error、warn、info、debug，选定了某一个作为日志级别，高级别的日志会打出。默认情况下，info级别以上的信息会被打印到控制台，springboot默认的级别也是info。

三、springboot日志配置

1、  默认情况下，不需要对日志做任何配置就可以使用，springboot使用logback作为日志的实现，使用Apache  conmons logging 作为日志接口，代码默认是：

public  class   hello（）{

  private  Log log=LogFactory.getLog(hello.class);

} 

2、配置文件 application.properties

logging.level.root=info

#org包下的日志级别

logging.level.org=info

#这个包下的日志级别设为debug

logging.level.com.yourcorp=debug

#springboot默认会打出文件，但是没有输出日志到文件，需要配置

logging.file=my.log

#指定日志文件的文件夹

logging.path=C:\opt

3、当日志文件到达10MB的时候，springboot会默认自动生成一个新的文件

4、springboot支持多种日志框架，log4j/logback/java util logging,等，建议使用默认的logback。

5、可以在resources目录下使用logback.xml或者logback-spring.xml来对logback进行更详细的配置

6、使用springaop注解记录访问每个方法的操作日志

https://blog.csdn.net/weixin_35852328/article/details/81533907

 

三、日志的演变过程

（1）使用JDK自带的 JDK Logging  使用不广泛

Java标准库内置了日志包java.util.logging，可以直接用

使用方法：

public class Hello {
    public static void main(String[] args) {
        Logger logger = Logger.getGlobal();
        logger.info("start process...");
        logger.warning("memory is running out...");
        logger.fine("ignored.");
        logger.severe("process will be terminated...");
    }
}

 

        Logger logger = Logger.getLogger(Main.class.getName());
        logger.info("Start process...");
        try {
            "".getBytes("invalidCharsetName");
        } catch (UnsupportedEncodingException e) {
            // TODO: 使用logger.severe()打印异常
        }
        logger.info("Process end.");

 

（2） 使用使用Commons Logging  Apache创建了Commons Logging第三方日志库，具体实现日志库Log4j

第一步：加入Commons Logging的第三方工具库

第二步：通过LogFactory获取Log类的实例

第三步：使用Log实例的方法打日志

示例代码：

public class Main {
    public static void main(String[] args) {
        Log log = LogFactory.getLog(Main.class);
        log.info("start...");
        log.warn("end.");
    }
}

默认使用方式：在方法的外面类里面直接定义一个全局log变量或者静态变量

// 在静态方法中引用Log:
public class Main {
    static final Log log = LogFactory.getLog(Main.class);

    static void foo() {
        log.info("foo");
    }
}

// 在实例方法中引用Log:
public class Person {
    protected final Log log = LogFactory.getLog(getClass());

    void foo() {
        log.info("foo");
    }
}

注意到实例变量log的获取方式是LogFactory.getLog(getClass())，虽然也可以用LogFactory.getLog(Person.class)，但是前一种方式有个非常大的好处，就是子类可以直接使用该log实例

Commons Logging 日志接口，使用log4j

log4j是一种非常流行的日志框架，最新版本是2.x。

新建log4j2.xml的文件放到classpath下就可以让Log4j读取配置文件并按照我们的配置来输出日志

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
	<Properties>
        <!-- 定义日志格式 -->
		<Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property>
        <!-- 定义文件名变量 -->
		<Property name="file.err.filename">log/err.log</Property>
		<Property name="file.err.pattern">log/err.%i.log.gz</Property>
	</Properties>
    <!-- 定义Appender，即目的地 -->
	<Appenders>
        <!-- 定义输出到屏幕 -->
		<Console name="console" target="SYSTEM_OUT">
            <!-- 日志格式引用上面定义的log.pattern -->
			<PatternLayout pattern="${log.pattern}" />
		</Console>
        <!-- 定义输出到文件,文件名引用上面定义的file.err.filename -->
		<RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}">
			<PatternLayout pattern="${log.pattern}" />
			<Policies>
                <!-- 根据文件大小自动切割日志 -->
				<SizeBasedTriggeringPolicy size="1 MB" />
			</Policies>
            <!-- 保留最近10份 -->
			<DefaultRolloverStrategy max="10" />
		</RollingFile>
	</Appenders>
	<Loggers>
		<Root level="info">
            <!-- 对info级别的日志，输出到console -->
			<AppenderRef ref="console" level="info" />
            <!-- 对error级别的日志，输出到err，即上面定义的RollingFile -->
			<AppenderRef ref="err" level="error" />
		</Root>
	</Loggers>
</Configuration>

（3）使用SLF4J和Logback

Commons Logging 和log4j是一对好基友，Commons Logging是日志接口，log4j是日志系统

而slf4j和logback是另一对基友，slf4j是日志接口，logback是日志系统

使用方式：

第一步：加入slf4j和logback

第二步：配置logback.xml

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

	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
		</encoder>
	</appender>

	<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
		<encoder>
			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
			<charset>utf-8</charset>
		</encoder>
		<file>log/output.log</file>
		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
			<fileNamePattern>log/output.log.%i</fileNamePattern>
		</rollingPolicy>
		<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
			<MaxFileSize>1MB</MaxFileSize>
		</triggeringPolicy>
	</appender>

	<root level="INFO">
		<appender-ref ref="CONSOLE" />
		<appender-ref ref="FILE" />
	</root>
</configuration>

第三步：使用

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class Main {
    final Logger logger = LoggerFactory.getLogger(getClass());
}

 

commons和slf4j的对比：

 参考链接：https://www.liaoxuefeng.com/wiki/1252599548343744/1264739155914176