Notas pessoais de Spring Boot de 0 a aprender 3 - log

1. Visão Geral

Quanto ao registro, existem muitos frameworks de registro, e nenhum deles é unificado. Entre eles, o diário de bordo também é dividido em duas partes, divididas emFachada de torascomImplementação de log

• A fachada de log é uma camada de abstração para logs. O que exatamente é isso? Eu também não tenho tanta certeza
• A realização de log é a nova coisa da digitação de código, e a realização concreta da coisa

Essas são as estruturas principais. Se você usá-las, precisará usar uma fachada de log e, em seguida, usar um log para conseguir.
Spring, que deve ser usado em conjunto com os dois, usa JCL
SpringBoot seleciona SLF4j e logback;

2. Uso de SLF4j

No desenvolvimento futuro, a chamada do método de registro não deve chamar diretamente a classe de implementação de registro, mas chamar o método na camada de abstração de registro;
uso SLF4J simples

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 é uma classe de registro, LoggerFactory.getLogger(类名)e o parâmetro é o nome da classe de uma classe, geralmente类.class

No entanto, o que estamos usando é SLF4Jque esta é apenas uma ferramenta, e o que realmente queremos élogback

3. Modo adaptador

Apenas entendo como usar isso. Eu realmente não entendo. Depois que o slf4j é usado, ele pode ser convertido em jars de outras camadas de abstração de log com slf4j e, em seguida, coisas de outras camadas de abstração, como JCL, podem ser geradas. A estrutura também pode usar slf4

4. Problemas legados

Por exemplo, estou usando slf4j + logback, mas Spring (commons-logging), Hibernate (jboss-logging), MyBatis (um novo), cada um é diferente, e um projeto pode apresentar mais Cada quadro, neste caso, o o log usado por cada quadro é diferente, não está frio?
Não entre em pânico, a bota de mola resolve
esse quadro para nós . Isso significa que, por exemplo, o quadro A usa SLF4J e o quadro B usa LOG4J. Os dados entre os dois não podem ser lidos. Então, a bota de mola Importar um pacote, SLF4J-LOG4J.jara função deste pacote é converter SLF4J em LOG4J, para que outras estruturas também possam ser usadas

Como unificar todos os logs do sistema para slf4j;

1. Exclua outras estruturas de log no sistema primeiro;(Remova outras estruturas de log)

2. Substitua a estrutura de log original por um pacote intermediário;(Spring boot é escrito e usado diretamente)

3. Importamos outras implementações de slf4j(O formato usa SLF4J)

5. Relacionamento do log de inicialização do Spring

Na parte pom.xmlinferior direita-Diagramas-Mostrar Dependências, você pode ver a relação entre o log com uma visão do caminho

6. Configuração padrão de log

• Spring boot nos ajudou a configurar o log padrão, mas também podemos modificá-lo
• O registro tem 5 níveis, de baixo a alto, respectivamentetrace < debug < info < warn < error
• O que significa nota? Ou seja, se você escolher um nível, o log irá registrar该等级以及该等级之上的记录
• O nível padrão selecionado pelo spring boot é info, o que significa que registros de informações, avisos e níveis de erro podem ser exibidos

1) Dê um exemplo

//单元测试
@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日志...");
    }
}

Saída direta

2) Altere o nível de registro

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

logging.level.com.qiang=trace

3) Salve o arquivo de log

Você pode exportar o log para um arquivo .log para
application.propertiesadicionar parâmetros.
Existem vários formatos de parâmetros de importação

1. Gere arquivos de registro na pasta atual:logging.file.name=文件名.log
2. Gere arquivos de registro no caminho especificado:logging.file.name=绝对路径/文件名.log
3. Crie uma pasta e um arquivo de log no diretório atual :, gerado logging.file.path=spring/logna pasta atualspring / log / spring.log, O nome do log .log gerado é spring.log
4. Crie uma pasta e um arquivo de registro no diretório especificado:logging.file.path=E:/spring/log

4) Formato de saída

O formato do console e os arquivos de registro salvos são ambos por padrão
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

% d significa a data e hora,
% thread significa o nome do thread,
% -5level: o nível é exibido da esquerda com 5 caracteres de largura
% logger {50} significa que o nome do logger tem no máximo 50 caracteres, caso contrário, é dividido por períodos.
% msg: mensagem de log,
% n é um caractere de nova linha

tal como

2020-07-13 14: 46: 26.330 ERRO 12340 - [main] cqsSpringBootFastApplicationTests: Este é o log de erros ...

• O formato da saída do registro no console:logging.pattern.console= 格式
• Especifique o formato da saída do registro no arquivo:logging.pattern.file= 格式

Arquivo spring.log salvo:

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, colocação designada

Você também pode application.propertiesmodificar os parâmetros de log um por um no arquivo, mas como a configuração no capítulo anterior, ele application.propertiesé configurado globalmente.É melhor separar e configurar melhor as coisas de configuração.

As regras para colocar arquivos em cada estrutura de registro, os arquivos são colocados sob o recurso:

usamos o logback para o Spring Boot, vamos explicar

Basta criá-lo em recursos logback.xml, o sistema irá carregar automaticamente as configurações de log dentro

No entanto, esta forma de escrita não é recomendada, pois não pode iniciar a função de perfil, que é a única coisa que realiza diferentes atribuições em diferentes ambientes. Para
usar a função de perfil, o nome do arquivo deve ser logback-spring.xml, por exemplo, escrever nele

<?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>

Não consigo escrever arquivos xml. . . Mas o principal é aprender a pensar, veja aqui

<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>

O significado aqui é que, quando o ambiente de configuração de perfil é dev, o log do console produzirá esse formato. Quando o ambiente de configuração de perfil não for dev, o log de saída do console terá outro formato.

Era originalmente assim. Quando o arquivo xml não é adicionado

, o ambiente de perfil é definido como dev em yml ou propriedades, e fica assim.

Quando o ambiente de configuração não é dev, ele se torna assim.