一、日志

1.日志的作用

记录程序的运行过程，便于分析

2.为什么要使用日志工具, 而不是直接打印或写到本地文件中?

不方便 代码写的多, 效果还不好

3.现在市面上常用的日志工具

jdk-logging

log4j :  commons-logging 是规范  lo4j是实现

logback : slf4j 是规范 logback是实现

4.日志划分不同等级的原因是什么?

目的是为了让我们在不同的情况下使用不同的方法，然后在配置文件中可以方便的设置要输入的内容

5.需要记得标签

appender : 定义输出的目的地

encoder : 定义日志的格式

rollingPolicy : 定义滚动策略

filter : 过滤日志级别

logger : 定义日志的范围

root : 一个特殊的logger

二、Java自带的工具Logger

1.示例代码

public static void main(String[] args) {

    //获取日志类

    Logger logger = Logger.getGlobal();

    //7个级别

    logger.severe("严重信息");

    logger.warning("警告信息");

    logger.info("普通信息");

    logger.config("参数信息");

    logger.fine("详细的");

    logger.finer("更详细的");

    logger.finest("极其详细的");

}

输出结果

二月 06, 2020 6:25:24 下午 com.loong.TestDemo main

严重: 严重信息

二月 06, 2020 6:25:24 下午 com.loong.TestDemo main

警告: 警告信息

二月 06, 2020 6:25:24 下午 com.loong.TestDemo main

信息: 普通信息

注意事项

    这里我们会发现,我们的代码中有七行日志, 但是结果中只有3个.

原因 :

    级别的顺序是 off > SEEVERE > WARNING > INFO > CONFIG > FINE > FINER > FINEST > all 

    java的配置中有关于日志的默认级别设定, 默认是INFO, 只有INFO和比INFO级别大的才能输出.

三、Log4j(实现)+Commons-Logging(一种规范)

1.导入依赖

项目中添加 Log4j和Commons-Logging的依赖

<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->

<dependencies>

    <dependency>

        <groupId>commons-logging</groupId>

        <artifactId>commons-logging</artifactId>

        <version>1.2</version>

    </dependency>

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->

    <dependency>

        <groupId>log4j</groupId>

        <artifactId>log4j</artifactId>

        <version>1.2.17</version>

    </dependency>

</dependencies>

2.基本使用

基本API

package com.qianfeng;

import org.apache.log4j.Logger;

public class MyService2 {

    Logger logger = Logger.getLogger(MyService2.class);

    public void function(){

        logger.trace("详细信息");

        logger.debug("测试信息");//1

        logger.info("普通信息");//1

        logger.warn("警告信息");

        logger.error("错误信息");//1

        logger.fatal("严重错误");

    }

}

3.配置信息

定义配置文件log4j.xml

%M 输出所在类的方法名

%m 我们要写的信息

配置文件

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

<!DOCTYPE log4j:configuration PUBLIC "-//LOGGER"

        "http://org/apache/log4j/xml/log4j.dtd">

<log4j:configuration>

    <!-- org.apache.log4j.ConsoleAppender 输出到控制台 -->

    <!--appender : 配置输出目的地-->

    <appender name="myConsole" class="org.apache.log4j.ConsoleAppender">

        <!--输出格式-->

        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern"

                  value="%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n"/>  //%m 我们要写的信息

        </layout>

    </appender>

<!-- 输出到文件 -->

<appender name="myFile1" class="org.apache.log4j.RollingFileAppender">//时间滚动模式

        <param name="File" value="d:/log/hello.log"/><!--文件位置-->

        <param name="Append" value="true"/><!--是否选择追加-->

        <param name="MaxFileSize" value="1kb"/><!--文件最大字节数-->

        <param name="MaxBackupIndex" value="2" /><!--新文件数量-->

        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern" value="%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n" />

        </layout>

    </appender>

    <!-- 输出到文件 -->

  <appender name="myFile2" class="org.apache.log4j.DailyRollingFileAppender">//日期时间滚动模式

        <param name="File" value="d:/log/hello2.log"/><!--文件位置-->

        <param name="DatePattern" value="yyyy-MM-dd-HH-mm"/><!--新文件名称-->

        <param name="Append" value="true"/><!--是否选择追加-->

        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern"

                  value="%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n"/>

        </layout>

    </appender>

    <!-- 根logger的设置-->

    <root>

        <!--优先级设置，all < trace < debug < info < warn < error < fatal < off -->

        <priority value="all"/>

        <appender-ref ref="myConsole"/>

        <appender-ref ref="myFile"/>

        <appender-ref ref="myFile2"/>

    </root>

</log4j:configuration>

四、SLF4j(一种规范) + Logback(实现)

1. 导入依赖

项目中导入依赖

<!-- Logback依赖，还会传递 slf4j 和 logback-core -->

<dependency>

    <groupId>ch.qos.logback</groupId>

    <artifactId>logback-classic</artifactId>

    <version>1.2.3</version>

</dependency>

2. 基本使用

Logback+SLF4J 基本API

import org.junit.Test;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import sun.rmi.runtime.Log;

public class HelloLog {

    // 需要输出日志的类，可以创建一个log属性

    Logger log = LoggerFactory.getLogger(HelloLog.class);

    @Test

    public void test1(){

        System.out.println(log.getClass());

        log.trace("hello trace");

        log.debug("hello debug");

        log.info("hello info");

        log.warn("hello warn");

        log.error("hello error");

        // 注意，logback中没有fatal日志

    }

}

3 .配置信息

配置文件

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

<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->

<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。

默认的时间间隔为1分钟。 -->

<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->

<configuration  scan="true" scanPeriod="60 seconds" debug="true">

    <!-- 定义变量，可通过 ${log.path}和${CONSOLE_LOG_PATTERN} 得到变量值 -->

    <property name="log.path" value="D:/log" />

    <property name="CONSOLE_LOG_PATTERN"

              value="%d{yyyy-MM-dd HH:mm:ss.SSS} |-[%-5p] in %logger.%M[line-%L] -%m%n"/>

    <!-- 输出到控制台 -->

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">

        <!-- Threshold=即最低日志级别，此appender输出大于等于对应级别的日志

            (当然还要满足root中定义的最低级别)

        -->

        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">

            <level>debug</level>

        </filter>

        <encoder>

            <!-- 日志格式(引用变量) -->

            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>

            <!-- 设置字符集 -->

            <charset>UTF-8</charset>

        </encoder>

    </appender>

    <!-- 追加到文件中 -->

    <appender name="file" class="ch.qos.logback.core.FileAppender">

        <file>${log.path}/hello2.log</file>

        <encoder>

            <pattern>${CONSOLE_LOG_PATTERN}</pattern>

        </encoder>

    </appender>

    <!-- 滚动追加到文件中 -->

    <appender name="file2" class="ch.qos.logback.core.rolling.RollingFileAppender">

        <!-- 正在记录的日志文件的路径及文件名 -->

        <file>${log.path}/hello.log</file>

        <!--日志文件输出格式-->

        <encoder>

            <pattern>${CONSOLE_LOG_PATTERN}</pattern>

            <charset>UTF-8</charset> <!-- 设置字符集 -->

        </encoder>

        <!-- 日志记录器的滚动策略，按日期，按大小记录

            文件超过最大尺寸后，会新建文件，然后新的日志文件中继续写入

            如果日期变更，也会新建文件，然后在新的日志文件中写入当天日志

        -->

        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

            <!-- 新建文件后，原日志改名为如下  %i=文件序号，从0开始 -->

            <fileNamePattern>${log.path}/hello-%d{yyyy-MM-dd}.%i.log</fileNamePattern>

            <!-- 每个日志文件的最大体量 -->

            <timeBasedFileNamingAndTriggeringPolicy

                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">

                <maxFileSize>8kb</maxFileSize>

            </timeBasedFileNamingAndTriggeringPolicy>

            <!-- 日志文件保留天数，1=则只保留昨天的归档日志文件 ,不设置则保留所有日志-->

            <maxHistory>1</maxHistory>

        </rollingPolicy>

    </appender>

    <root level="trace">

        <appender-ref ref="CONSOLE"/>

        <appender-ref ref="file"/>

        <appender-ref ref="file2"/>

    </root>

</configuration>

总结

1、日志的作用

    记录程序的运行过程, 便于分析

2、为什么要使用日志工具, 而不是直接打印或写到本地文件中?

    不方便 代码写的多, 效果还不好

3、现在市面上常用的日志工具

    jdk-logging

    log4j :  commons-logging 是规范  lo4j是实现

    logback : slf4j 是规范 logback是实现

4、需要记得标签

    appender : 定义输出的目的地

    encoder : 定义日志的格式

    rollingPolicy : 定义滚动策略

    filter : 过滤日志级别

    logger : 定义日志的范围

    root : 一个特殊的logger