package cn.yhs.learn.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.logging.*;
import org.junit.Test;

public class JULTest {
    // todo 1 快速入门
    @Test
    public void test() {
        // 1. 创建日志对象
        Logger logger = Logger.getLogger(this.getClass().getName());
        System.out.println("我是日志信息");
        // 2. 日志记录输出
        logger.info("我是日志信息");// 日志信息是红颜色的
        // 3. 通用方法日志记录输出
        logger.log(Level.INFO, "我是info级别。。。");
        // 4. 还可以通过占位符方式来输出变量
        Object name = "喻汉生";
        Object age = 18;
        logger.log(Level.INFO, "用户信息：{0}，{1}", new Object[]{name, age});
    }
    // todo 4 输出文件对象
    @Test
    public void test4() {
        // 1. 创建日志对象
        Logger logger = Logger.getLogger(this.getClass().getName());
        // 2.0 关闭系统设置
        logger.setUseParentHandlers(false);
        // 2.1 创建日志文件处理器
        FileHandler fileHandler = null;
        try {
            // 注意：会自动创建文件，但是不会创建目录
            fileHandler = new FileHandler("d:/log/jul.log");
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 2.2 创建输出格式对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        // 2.3 将输出格式对象和输出对象关联
        fileHandler.setFormatter(simpleFormatter);
        // 2.4 将输出对象和日志对象关联
        logger.addHandler(fileHandler);
        // 2.5 设置日志级别
        logger.setLevel(Level.ALL); // 设置根日志的级别
        fileHandler.setLevel(Level.ALL);
        // 3. 日志输出
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

package java.util.logging; 
/**
 *  1. java.util.logging.Level 定义了7种日志级别,7个日志级别但是默认只实现info以上的级别
 * public boolean isLoggable(Level level) {
 * if (level.intValue() < levelValue || levelValue == offValue) {
 * return false; // 2. 该方法说明只会输出当前级别和比自己级别高的日志信息
 * }
 * return true;
 * }
 * 
 * SEVERE (highest value)
 * WARNING
 * INFO
 * CONFIG
 * FINE
 * FINER
 * FINEST  (lowest value)
 * @since 1.4
 */
public class Level implements java.io.Serializable {
    // 关闭所有级别日志
    public static final Level OFF = new Level("OFF",Integer.MAX_VALUE, defaultBundle);
    public static final Level SEVERE = new Level("SEVERE",1000, defaultBundle);
    public static final Level WARNING = new Level("WARNING", 900, defaultBundle);
    public static final Level INFO = new Level("INFO", 800, defaultBundle);
    public static final Level CONFIG = new Level("CONFIG", 700, defaultBundle);
    public static final Level FINE = new Level("FINE", 500, defaultBundle);
    public static final Level FINER = new Level("FINER", 400, defaultBundle);
    public static final Level FINEST = new Level("FINEST", 300, defaultBundle);
    // 打开所有级别日志
    public static final Level ALL = new Level("ALL", Integer.MIN_VALUE, defaultBundle);
 //  ...
}

  // todo 2 日志级别
    @Test
    public void test2() {
        // 1. 获取日志对象
        Logger logger = Logger.getLogger(this.getClass().getName());
        //        logger.setLevel(Level.OFF); // 关闭日志输出
        //        logger.setLevel(Level.ALL); // 开启日志输出

        // 2. 日志级别输出，实际是哪个都是在调用通用log(Level.SEVERE, msg);
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info"); // JUL 默认是info级别,会输出info及以上级别的日志信息
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }


    // todo 3 自定义日志级别并输出到控制台
    @Test
    public void test3() {
        // 1. 创建日志记录对象，构造器私有化，使用提供的静态方法
        Logger logger = Logger.getLogger(this.getClass().getName());
        // 2.0 关闭系统默认设置
        logger.setUseParentHandlers(false);
        // 2.1 创建控制台输出对象
        ConsoleHandler consoleHandler = new ConsoleHandler();
        // 2.2 创建输出格式
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        // 2.3 将输出格式和控制台想关联
        consoleHandler.setFormatter(simpleFormatter);
        // 2.4 将控制台和当前日志对象进行想管理
        logger.addHandler(consoleHandler);
        // 2.5 设置日志级别，consoleHandler的默认级别是info
        consoleHandler.setLevel(Level.ALL);
        logger.setLevel(Level.ALL);
        // 3. 输出日志
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");

    }

  // todo 5 测试父子关系
    @Test
    public void test5() {
        Logger logger1 = Logger.getLogger("cn.yhs.learn");
        Logger logger2 = Logger.getLogger("cn.yhs");
        Logger logger3 = Logger.getLogger("cn");
        System.out.println("logger1 = " + logger1);//logger1 = java.util.logging.Logger@50134894
        System.out.println("logger2 = " + logger2);//logger2 = java.util.logging.Logger@2957fcb0
        System.out.println("logger3 = " + logger3);//logger3 = java.util.logging.Logger@1376c05c
        Logger logger1Parent = logger1.getParent();
        Logger logger2Parent = logger2.getParent();
        Logger logger3Parent = logger3.getParent();
        System.out.println("logger1Parent = " + logger1Parent);//logger1Parent = java.util.logging.Logger@2957fcb0
        System.out.println("logger2Parent = " + logger2Parent);//logger2Parent = java.util.logging.Logger@1376c05c
        System.out.println("logger3Parent = " + logger3Parent);//logger3Parent = java.util.logging.LogManager$RootLogger@51521cc1
        // 自定义设置logger2的日志级别,测试父子关系
        logger2.setUseParentHandlers(false);
        ConsoleHandler consoleHandler = new ConsoleHandler();
        SimpleFormatter simpleFormatter = new SimpleFormatter();
        consoleHandler.setFormatter(simpleFormatter);
        logger2.addHandler(consoleHandler);
        consoleHandler.setLevel(Level.ALL);
        logger2.setLevel(Level.ALL);

        System.out.println("logger1 的日志输出");
        logger1.severe("severe");
        logger1.warning("warning");
        logger1.info("info");
        logger1.config("config");
        logger1.fine("fine");
        logger1.finer("finer");
        logger1.finest("finest");

        System.out.println("logger2 的日志输出");
        logger2.severe("severe");
        logger2.warning("warning");
        logger2.info("info");
        logger2.config("config");
        logger2.fine("fine");
        logger2.finer("finer");
        logger2.finest("finest");

        System.out.println("logger3 的日志输出");
        logger3.severe("severe");
        logger3.warning("warning");
        logger3.info("info");// 只会输出INFO及以上级别
        logger3.config("config");
        logger3.fine("fine");
        logger3.finer("finer");
        logger3.finest("finest");
        /**
         * 结论：
         * ① 日子之间是存在父子关系的，按照java中的包级别来进行划分，最顶级包的父类是LogManager$RootLogger
         * ② 由于logger2自定义设置了日志输出级别，所以loggeer2及其子类（logger1）会输出指定级别的日志，而logger3是logger2的父类，由于
         * 没有设置日志级别，默认是INFO。
         */
    }

 // todo 加载自定义日志文件，配置日志级别和输出格式
    @Test
    public void test6() throws IOException {
        // 1.读取配置文件
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("logging.properties");
        // 2. 获取日志管理器对象,单例的
        LogManager logManager = LogManager.getLogManager();
        // 3. 通过日志管理器对象加载配置文件
        logManager.readConfiguration(inputStream);
        // 4. 打印日志
        Logger logger = Logger.getLogger(this.getClass().getName());
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info"); // JUL 默认是info级别,会输出info及以上级别的日志信息
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

    @Test
    public void test7() throws IOException {
        /**
         * # 自定义日志格式
         * #cn.yhs.learn.test.handlers = java.util.logging.ConsoleHandler
         * #cn.yhs.learn.test.level = CONFIG
         * #cn.yhs.learn.test.useParentHandlers = false
         */
        // 1.读取配置文件
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("logging.properties");
        // 2. 获取日志管理器对象,单例的
        LogManager logManager = LogManager.getLogManager();
        // 3. 通过日志管理器对象加载配置文件
        logManager.readConfiguration(inputStream);
        // 4. 打印日志
//        Logger logger = Logger.getLogger(this.getClass().getName());
        Logger logger = Logger.getLogger("cn.yhs.learn.test");
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }
}

/*
    # 在log4j.properties  配置文件中，定义输出格式
    # log4j 采用类似 C 语言的 printf 函数的打印格式格式化日志信息，具体的占位符及其含义如下：
    %m 输出代码中指定的日志信息
    %p 输出优先级，及 DEBUG、INFO 等
    %n 换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"）
    %r 输出自应用启动到输出该 log 信息耗费的毫秒数
    %c 输出打印语句所属的类的全名
    %t 输出产生该日志的线程全名
    %d 输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{yyyy年MM月dd日HH:mm:ss}
    %l 输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如：Test.main(Test.java:10)
    %F 输出日志消息产生时所在的文件名称
    %L 输出代码中的行号
    %% 输出一个 "%" 字符
    # 可以在 % 与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式。如：
    %5c 输出category名称，最小宽度是5，category<5，默认的情况下右对齐
    %-5c 输出category名称，最小宽度是5，category<5，"-"号指定左对齐,会有空格
    %.5c 输出category名称，最大宽度是5，category>5，就会将左边多出的字符截掉，<5不会有空格
    %20.30c category名称<20补空格，并且右对齐，>30字符，就从左边交远销出的字符截掉
*/

/*
*每个Logger都被了一个日志级别（log level），用来控制日志信息的输出。日志级别从高到低分为：
    fatal 指出每个严重的错误事件将会导致应用程序的退出。
    error 指出虽然发生错误事件，但仍然不影响系统的继续运行。
    warn 表明会出现潜在的错误情形。
    info 一般和在粗粒度级别上，强调应用程序的运行全程。
    debug 一般用于细粒度级别上，对调试应用程序非常有帮助。
    trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程。
* 还有两个特殊的级别：
    OFF，可用来关闭日志记录。
    ALL，启用所有消息的日志记录。
注：一般只使用4个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUG
*/

    // todo log4j 入门案例,使用初始化配置信息
    @Test
    public void test() {
        /**
         * log4j:WARN No appenders could be found for logger (cn.yhs.learn.test.Log4JTest).
         * log4j:WARN Please initialize the log4j system properly.
         * log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
         */
        // 0. 初始化配置信息,(没有使用配置文件log4j.properties)，不然不会打印信息，会提示进行配置
       BasicConfigurator.configure();
        /**
         * log4j: Trying to find [log4j.xml] using context classloader sun.misc.Launcher$AppClassLoader@18b4aac2.
         * log4j: Trying to find [log4j.xml] using sun.misc.Launcher$AppClassLoader@18b4aac2 class loader.
         * log4j: Trying to find [log4j.xml] using ClassLoader.getSystemResource().
         * log4j: Trying to find [log4j.properties] using context classloader sun.misc.Launcher$AppClassLoader@18b4aac2.
         * log4j: Trying to find [log4j.properties] using sun.misc.Launcher$AppClassLoader@18b4aac2 class loader.
         * log4j: Trying to find [log4j.properties] using ClassLoader.getSystemResource().
         * log4j: Could not find resource: [null].
         */
        // 开启 log4j 内置的日志记录
        LogLog.setInternalDebugging(true);

        // 1. 获取日志对象
        Logger logger = Logger.getLogger(this.getClass());
        // 2. 日志记录输出
        logger.fatal("fatal");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");// 默认的debug级别，会打印debug及以上级别的信息
        logger.trace("trace");
    }

    @Test // 使用配置文件控制台输出
    public void test2() {
        // 0. 开启 log4j 内置的日志记录
        LogLog.setInternalDebugging(true);
        // 1. 获取日志对象
        Logger logger = Logger.getLogger(this.getClass());
        // 2. 日志记录输出
        logger.fatal("fatal");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");// 默认的debug级别
        logger.trace("trace");
    }
/* 结果分析
log4j: Trying to find [log4j.xml] using context classloader sun.misc.Launcher$AppClassLoader@18b4aac2.
log4j: Trying to find [log4j.xml] using sun.misc.Launcher$AppClassLoader@18b4aac2 class loader.
log4j: Trying to find [log4j.xml] using ClassLoader.getSystemResource().
log4j: Trying to find [log4j.properties] using context classloader sun.misc.Launcher$AppClassLoader@18b4aac2.
log4j: Using URL [file:/C:/Users/1/IdeaProjects/java-log/log4j-log/target/classes/log4j.properties] for automatic log4j configuration.
log4j: Reading configuration from URL file:/C:/Users/1/IdeaProjects/java-log/log4j-log/target/classes/log4j.properties
log4j: Parsing for [root] with value=[trace,console].
log4j: Level token is [trace].
log4j: Category root set to TRACE
log4j: Parsing appender named "console".
log4j: Parsing layout options for "console".
log4j: Setting property [conversionPattern] to [%r [%t] [%p] %l  - %m%n].
log4j: End of parsing for "console".
log4j: Parsed "console" options.
log4j: Finished configuring.
0 [main] [FATAL] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:73)  - fatal
2 [main] [ERROR] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:74)  - error
2 [main] [WARN] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:75)  - warn
3 [main] [INFO] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:76)  - info
3 [main] [DEBUG] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:77)  - debug
3 [main] [TRACE] cn.yhs.learn.test.Log4JTest.test2(Log4JTest.java:78)  - trace
*/

 @Test // 使用配置文件输出到数据库
    public void test3() {
        // 0. 开启 log4j 内置的日志记录
         LogLog.setInternalDebugging(true);
        // 1. 获取日志对象
        Logger logger = Logger.getLogger(this.getClass());

        // 2. 日志记录输出
        for (int i = 0; i < 100; i++) {
            logger.fatal("fatal" + i);
            logger.error("error" + i);
            logger.warn("warn" + i);
            logger.info("info" + i);
            logger.debug("debug" + i);// 默认的debug级别
            logger.trace("trace" + i);
        }
    }

// 只支持4种实现，要想再添加其他实现必须修改源代码（弊端）
private static final String[] classesToDiscover =new String[]{
    "org.apache.commons.logging.impl.Log4JLogger", // log4j实现
	"org.apache.commons.logging.impl.Jdk14Logger", // jdk自带的实现 -> jul
	"org.apache.commons.logging.impl.Jdk13LumberjackLogger",
	"org.apache.commons.logging.impl.SimpleLog" // 配套简单的实现
};

for(int i = 0; i < classesToDiscover.length && result == null; ++i) {
	result = this.createLogFromClass(classesToDiscover[i], logCategory,true);
}

    // todo 1 jcl入门，默认使用jdk的日志
    @Test
    public void test1() {
        Log log = LogFactory.getLog(this.getClass());
        log.info("info......");
        // 默认使用的是jdk自带的日志
    }
/*
六月 04, 2020 7:47:01 下午 cn.yhs.learn.test.JCLTest test1
信息: info......
*/

    // todo 2 jcl入门，使用log4j
    @Test
    public void test2() {
        Log log = LogFactory.getLog(this.getClass());
        log.info("info......");
        //导入log4j的jar包之后就使用log4j的格式
    }
/*
0 [main] [INFO] cn.yhs.learn.test.JCLTest.test2(JCLTest.java:24)  - info......
*/

/*
# 1. 使用SLF4J框架，可以在部署时迁移到所需的日志记录框架。
# 2. SLF4J提供了对所有流行的日志框架的绑定，例如log4j，JUL，Simple logging和NOP。因此可以在部署时切换到任何这些流行的框架。
# 3. 无论使用哪种绑定，SLF4J都支持参数化日志记录消息。由于SLF4J将应用程序和日志记录框架分离，因此可以轻松编写独立于日志记录框架的应用程序。而无需担心用于编写应用程序的日志记录框架。
# 4. SLF4J提供了一个简单的Java工具，称为迁移器。使用此工具，可以迁移现有项目，这些项目使用日志(如Jakarta Commons Logging(JCL)或log4j或Java.util.logging(JUL))到SLF4J。
*/

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

public class Sif4jTest {
    // 1. 定义日志对象，注意这里导入的是 org.slf4j.Logger;
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);
    // todo 1 入门案例，没有任何绑定
    @Test
    public void test1() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info");
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}

// 会有提示信息，日志没有任何输出信息
/*
    SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
    SLF4J: Defaulting to no-operation (NOP) logger implementation
    SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
*/

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

public class Sif4jTest {
    // 1. 定义日志对象，注意这里导入的是 org.slf4j.Logger;
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);
    // todo 2入门案例，绑定日志关闭jar
    @Test
    public void test2() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info");
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}

// 关闭日志输出，没有任何日志信息

    // 1. 定义日志对象，注意这里导入的是 org.slf4j.Logger;
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);  
	// todo 3 使用内置的简单实现，默认打印info级别
    @Test
    public void test3() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); // 简单实现默认打印info及以上级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }

//  使用内置的简单实现，默认打印info级别
/*
    [main] ERROR cn.yhs.learn.test.Sif4jTest - error
    [main] WARN cn.yhs.learn.test.Sif4jTest - warn
    [main] INFO cn.yhs.learn.test.Sif4jTest - info
*/

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

public class Sif4jTest {

 // 1. 定义日志对象
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);
  
// todo 2 入门案例，使用logback的实现
    @Test
    public void test2() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); 
        LOGGER.debug("debug");// logback默认打印debug及以上级别
        LOGGER.trace("trace");
    }

/*
    13:10:13.360 [main] ERROR cn.yhs.learn.test.Sif4jTest - error
    13:10:13.374 [main] WARN cn.yhs.learn.test.Sif4jTest - warn
    13:10:13.374 [main] INFO cn.yhs.learn.test.Sif4jTest - info
    13:10:13.374 [main] DEBUG cn.yhs.learn.test.Sif4jTest - debug
*/

 // 1. 定义日志对象
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);

    // todo 5 绑定log4j，打印级别跟随配置文件来定
    @Test
    public void test5() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); //jcl默认打印info及以上级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }

/*
    0 [main] [ERROR] cn.yhs.learn.test.Sif4jTest.test5(Sif4jTest.java:15)  - error
    0 [main] [WARN] cn.yhs.learn.test.Sif4jTest.test5(Sif4jTest.java:16)  - warn
    0 [main] [INFO] cn.yhs.learn.test.Sif4jTest.test5(Sif4jTest.java:17)  - info
    0 [main] [DEBUG] cn.yhs.learn.test.Sif4jTest.test5(Sif4jTest.java:18)  - debug
    0 [main] [TRACE] cn.yhs.learn.test.Sif4jTest.test5(Sif4jTest.java:19)  - trace
*/

    // 1. 定义日志对象
    private static final Logger LOGGER = LoggerFactory.getLogger(Sif4jTest.class);

    // todo 4 绑定jul，默认打印info级别
    @Test
    public void test4() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); //jcl默认打印info及以上级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }

/*
    六月 05, 2020 11:41:24 上午 cn.yhs.learn.test.Sif4jTest test4
    严重: error
    六月 05, 2020 11:41:24 上午 cn.yhs.learn.test.Sif4jTest test4
    警告: warn
    六月 05, 2020 11:41:24 上午 cn.yhs.learn.test.Sif4jTest test4
    信息: info
*/

package cn.yhs.learn.test;

import org.apache.log4j.Logger; // 这里不用修改源代码，虽然log4j的jar包注释了
import org.junit.Test;

public class BridgingTest {
    //  桥接器的使用
    private final static Logger LOGGER = Logger.getLogger(BridgingTest.class);
    @Test
    public void test1() {
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); 
        LOGGER.debug("debug"); // logback默认是debug的级别
        LOGGER.trace("trace");
    }
}
// logback打印
/*
    13:01:07.105 [main] ERROR cn.yhs.learn.test.BridgingTest - error
    13:01:07.115 [main] WARN cn.yhs.learn.test.BridgingTest - warn
    13:01:07.115 [main] INFO cn.yhs.learn.test.BridgingTest - info
    13:01:07.115 [main] DEBUG cn.yhs.learn.test.BridgingTest - debug
*/