Notas personales de Spring Boot desde 0 para aprender 3 - log

1. Información general

En cuanto al registro, existen muchos marcos de registro y ninguno de ellos está unificado. Entre ellos, el registro también se divide en dos partes, divididas enFachada de troncosconImplementación de registros

• La fachada de troncos es una capa de abstracción para troncos, ¿qué es exactamente? Yo tampoco estoy tan seguro
• La realización de registros es lo nuevo de escribir código y la realización concreta de la cosa.

Estos son los marcos principales. Si los usa, debe usar una fachada de registro y luego usar un registro para lograrlo.
Spring, que debe usarse junto con los dos, usa JCL
SpringBoot selecciona SLF4j y logback;

2. Uso de SLF4j

En el desarrollo futuro, la llamada del método de registro no debe llamar directamente a la clase de implementación del registro, sino llamar al método en la capa de abstracción del registro;
uso simple de SLF4J

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

public class HelloWorld {
    
    
  public static void main(String[] args) {
    
    
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

Logger es una clase de registro LoggerFactory.getLogger(类名)y el parámetro es el nombre de clase de una clase, generalmente类.class

Sin embargo, lo que estamos usando es SLF4Jque esto es solo una herramienta, y lo que realmente queremos usar eslogback

3. Modo adaptador

Solo entiendo cómo usar esto. Realmente no lo entiendo. Después de usar slf4j, se puede convertir en frascos de otras capas de abstracción de registros con slf4j, y luego se pueden generar elementos de otras capas de abstracción como JCL. El marco también puede usar slf4

4. Problemas heredados

Por ejemplo, estoy usando slf4j + logback, pero Spring (commons-logging), Hibernate (jboss-logging), MyBatis (uno nuevo), cada uno es diferente, y un proyecto puede introducir más Cada marco, en este caso, el El registro utilizado por cada cuadro es diferente, ¿no hace frío?
Que no cunda el pánico, Spring Boot nos resuelve
este problema . Significa, por ejemplo, que el marco A usa SLF4J y el marco B usa LOG4J. Los datos entre los dos no se pueden leer. Luego, Spring Boot Importa un paquete, SLF4J-LOG4J.jarla función de este El paquete es convertir SLF4J a LOG4J, por lo que también se pueden usar otros marcos

Cómo unificar todos los registros del sistema en slf4j;

1. Excluya primero otros marcos de registro en el sistema;(Eliminar otros marcos de registro)

2. Reemplace el marco de registro original con un paquete intermedio;(Spring boot se escribe y se usa directamente)

3. Importamos otras implementaciones de slf4j(El formato usa SLF4J)

5. Relación de registro de arranque de primavera

En la parte pom.xmlinferior derecha-Diagramas-Mostrar dependencias, puede ver la relación entre el registro con una vista de la forma

6. Registrar la configuración predeterminada

• Spring boot nos ayudó a configurar el registro predeterminado, pero también podemos modificarlo
• El registro tiene 5 niveles, de menor a mayor, respectivamente.trace < debug < info < warn < error
• ¿Qué significa grado? Es decir, si elige un nivel, el registro registrará该等级以及该等级之上的记录
• El nivel predeterminado seleccionado por Spring Boot es información, lo que significa que se pueden mostrar registros de información, advertencias y niveles de error.

1) Da un ejemplo

//单元测试
@SpringBootTest
class SpringBootFastApplicationTests {
    
    
	//记录器
    Logger logger = LoggerFactory.getLogger(this.getClass());

    @Test
    void contextLoads() {
    
    
        logger.trace("这是trace日志");
        logger.debug("这是debug日志...");
        //SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别
        logger.info("这是info日志...");
        logger.warn("这是warn日志...");
        logger.error("这是error日志...");
    }
}

Salida directa

2) Cambiar el nivel de registro

application.propertiesAgregar
formato de parámetro :logging.level.包名（一般是com.包名）=设置等级

logging.level.com.qiang=trace

3) Guarde el archivo de registro

Puede exportar el registro a un archivo .log para
application.propertiesagregar parámetros.
Hay varios formatos de parámetros de importación

1. Genere archivos de registro en la carpeta actual:logging.file.name=文件名.log
2. Genere archivos de registro en la ruta especificada:logging.file.name=绝对路径/文件名.log
3. Cree una carpeta y un archivo de registro en el directorio actual: generado logging.file.path=spring/logen la carpeta actualspring / log / spring.log, El nombre del registro .log generado es spring.log
4. Cree una carpeta y un archivo de registro en el directorio especificado:logging.file.path=E:/spring/log

4) formato de salida

El formato de la consola y los archivos de registro guardados son ambos predeterminados
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

% d significa la fecha y la hora,
% hilo significa el nombre del hilo,
% -5 nivel: el nivel se muestra desde la izquierda con 5 caracteres de ancho
% logger {50} significa que el nombre del registrador tiene un máximo de 50 caracteres, de lo contrario está dividido por periodos.
% msg: mensaje de registro,
% n es un carácter de nueva línea

tal como

2020-07-13 14: 46: 26.330 ERROR 12340 - [principal] cqsSpringBootFastApplicationTests: Este es el registro de errores ...

• El formato de la salida del registro en la consola:logging.pattern.console= 格式
• Especifique el formato de la salida del registro en el archivo:logging.pattern.file= 格式

Archivo spring.log guardado:

2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== Starting SpringBootFastApplicationTests on DESKTOP-J69KO73 with PID 1936 (started by master in D:\idea\spring-boot-fast)
2020-07-13 === [main] === DEBUG === c.q.springbootfast.SpringBootFastApplicationTests ==== Running with Spring Boot v2.3.1.RELEASE, Spring v5.2.7.RELEASE
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== The following profiles are active: dev
2020-07-13 === [main] === INFO  === o.s.scheduling.concurrent.ThreadPoolTaskExecutor ==== Initializing ExecutorService 'applicationTaskExecutor'
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== Started SpringBootFastApplicationTests in 4.15 seconds (JVM running for 6.675)
2020-07-13 === [main] === TRACE === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是trace日志
2020-07-13 === [main] === DEBUG === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是debug日志...
2020-07-13 === [main] === INFO  === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是info日志...
2020-07-13 === [main] === WARN  === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是warn日志...
2020-07-13 === [main] === ERROR === c.q.springbootfast.SpringBootFastApplicationTests ==== 这是error日志...
2020-07-13 === [SpringContextShutdownHook] === INFO  === o.s.scheduling.concurrent.ThreadPoolTaskExecutor ==== Shutting down ExecutorService 'applicationTaskExecutor'

7, ubicación designada

También puedes application.propertiesmodificar los parámetros del log uno a uno en el archivo, pero al igual que la configuración del capítulo anterior, se application.propertiesconfigura globalmente , es mejor separar y configurar mejor las cosas de configuración.

Las reglas para colocar archivos en cada marco de registro, los archivos se colocan en el recurso:

usamos logback para el arranque de primavera, tomemos esto para explicar

Simplemente créelo en recursos logback.xml, el sistema cargará automáticamente la configuración de registro dentro

Sin embargo, esta forma de escritura no es recomendable, porque esta no puede iniciar la función de perfil, que es lo que realiza diferentes asignaciones en diferentes entornos. Para
usar la función de perfil, el nombre del archivo debe ser logback-spring.xml, por ejemplo, escribir en él.

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。
debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 -->
    <property name="LOG_HOME" value="/app/log" />
    <!-- 定义日志文件名称 -->
    <property name="appName" value="atguigu-springboot"></property>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式：
			%d表示日期时间，
			%thread表示线程名，
			%-5level：级别从左显示5个字符宽度
			%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
			%msg：日志消息，
			%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${appName}.log</file>
        <!--
        当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名
        TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
            %i：当文件大小超过maxFileSize时，按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--
            可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动，
            且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，
            那些为了归档而创建的目录也会被删除。
            -->
            <MaxHistory>365</MaxHistory>
            <!--
            当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式： -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!--
		logger主要用于存放日志对象，也可以定义日志类型、级别
		name：表示匹配的logger类型前缀，也就是包的前半部分
		level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERROR
		additivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，
		false：表示只用当前logger的appender-ref，true：
		表示当前logger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="com.atguigu" level="debug" />
    <!-- Spring framework logger -->
    <logger name="org.springframework" level="debug" additivity="false"></logger>



    <!--
    root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应，
    要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。
    -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration>

No puedo escribir archivos xml. . . Pero lo principal es aprender a pensar, mira aquí.

<layout class="ch.qos.logback.classic.PatternLayout">
    <springProfile name="dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
    </springProfile>
    <springProfile name="!dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
    </springProfile>
</layout>

El significado aquí es que cuando el entorno de configuración del perfil es dev, el registro de la consola generará ese formato. Cuando el entorno de configuración del perfil no es dev, el registro de salida de la consola estará en otro formato.

Originalmente era así. Cuando no se agrega el archivo xml

, el entorno del perfil se establece en dev en yml o propiedades, y se vuelve así.

Cuando el entorno de configuración no es dev, se vuelve así.