java logging 学习笔记

what is log?
A Logger object is used to log messages for a specific system or application component.


why we need log?
problems diagnosis.


how we use log?
1.components and structure.（not contain security related class）
|--Logger:The main entity on which applications make logging calls.
|--Name rule:using dot-separated names and should normally be based on the package name or class name of the logged component, such as "java.awt"
|--invoke Logger.getLogger() to create an entity.(familiar with factory pattern)
|--The namespace is hierarchical and is managed by the LogManager. 
|--anonymous Loggers for access control.
|--Inheritation:level,handler,resourse bundle name.
|--LogManager:There is a global LogManager object that keeps track of global logging information.
|--Single pattern:Logmanager.getLogManager()
|--LogRecord: Used to pass logging requests.(message)
|--Handler:Exports LogRecord objects to a variety of destinations
|--Subclasses
|--StreamHandler
|--ConsoleHandler
|--FileHandler
|--"/" 本地路径名分隔符
|--"%t" 系统临时目录
|--"%h" "user.home" 系统属性的值
|--"%g" 区分循环日志的生成号
|--"%u" 解决冲突的唯一号码
|--"%%" 转换为单个百分数符号"%"
|--SocketHandler
|--MemoryHandler
|--ErrorManager:attached to Handlers to process any error that occurs on a Handler during Logging.
|--Level:Defines a set of standard logging levels that can be used to control logging output.
|-- (off)->finest->finer->fine->config->info->warning->sever->(all)
|--Filtter:Provides fine-grained control over what gets logged,
|--Formatter:Provides support for formatting LogRecord objects.(localization) 
|--SimpleFormatter
|--XMLFormatter
|--(configuration file)
|--LoggingPermission:Security


|--Control flow
|--Application  --> Logger(levle,Filtter) -(LogRecord)->  Handler(Level,Filtter)  - (Formatter)    -> destination.
just like: 约稿 --> 作者（审阅、校对）    - （作品）  -> （出版商）（审阅、校对） -（装订） -> 出版成书


2.Common API
|--Logger
|--Constructor(logger)
|--Logger.getLogger(String name)
|--Logger.getGlobal() --> name is Logger.GLOBAL_LOGGER_NAME
|--Logger.getAnonymousLogger() --> the log is anonymous and can't find in LogManager.
|--Configuration
|--logger.setUseParentHandlers(boolean b)
|--logger.setLevel(Level l)
|--logger.setFilter(Filter f)
|--logger.isLoggable(Level l)
|--logger.addHandler(Handler h)
|--logger.removeHandler(Handler h)
|--Method
|--logger.xxx(String msd)
|--logger.log(Level l,String msg,Throwable e)
|--logger.logp(Level l,String sourceClass,String sourceMethod,String msg)
|--LogManager
|--Constructor(logManager):LogManager.getLogManager()
|--Configuration
|--logManager.addLoger(String name);
|--logManager.getLoger(String name) -->return null if not find the logger with specific name.
|--logManager.getLoggerNames(); return a Enumeration<String> contain all logger.
|--Handler(subclass)
|--Filtter(interface)


3.Think
|--inherited relationship is depend on dot-separation structure
null
|-- a
|-- a.b
|--a.b.c
|-- a.bb
|--a.bb.c

|--filtter is better than level.(nonlinear vs linear)

4.Demo

import java.io.IOException;
import java.util.Enumeration;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Filter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class loggerDemo1
{
    protected Logger loggerXX = Logger.getLogger(loggerDemo1.class.getName() + "XX");

    public loggerDemo1()
    {
        //get logger manager and check whether has logger.
        LogManager logManager = LogManager.getLogManager();
        System.out.println("have specific logger? " + (logManager.getLogger(loggerDemo1.class.getName()) != null) + "\n");

        System.out.println("-------------------------------------------------------------------------------------\n");

        //create an anonymous logger 
        Logger anlogger = Logger.getAnonymousLogger();
        System.out.println("anonymous logger name:" + anlogger.getName() + "\n");

        Enumeration<String> registeredLogger = logManager.getLoggerNames();
        while (registeredLogger.hasMoreElements())
        {
            System.out.println("registered logger : " + registeredLogger.nextElement());
        }

        System.out.println("-------------------------------------------------------------------------------------\n");

        //create logger and get detail.
        final Logger logger = Logger.getLogger(loggerDemo1.class.getName());
        System.out.println("logger name: " + logger.getName());
        System.out.println("logger parent name: " + logger.getParent().getName());
        System.out.println("logger parent detail: " + logger.getParent() + "\n");
        System.out.println("have specific logger? " + (logManager.getLogger(loggerDemo1.class.getName()) != null) + "\n");

        System.out.println("-------------------------------------------------------------------------------------\n");

        registeredLogger = logManager.getLoggerNames();
        while (registeredLogger.hasMoreElements())
        {
            System.out.println("registered logger : " + registeredLogger.nextElement());
        }

        System.out.println("-------------------------------------------------------------------------------------\n");
        logger.setUseParentHandlers(false);

        //set logger level and filter
        logger.setLevel(Level.FINEST);
        logger.setFilter(new Filter()
        {
            public boolean isLoggable(LogRecord record)
            {
                return (record.getLevel().intValue() >= Level.FINER.intValue()) ? true : false;
            }
        });

        Handler conslHandler, fileHandler = null;

        //set handler level and filter
        conslHandler = new ConsoleHandler();
        conslHandler.setLevel(Level.FINE);
        conslHandler.setFilter(new Filter()
        {
            public boolean isLoggable(LogRecord record)
            {
                return (record.getLevel().intValue() >= Level.CONFIG.intValue()) ? true : false;
            }
        });
        logger.addHandler(conslHandler);

        try
        {
            fileHandler = new FileHandler("log.xml");
            //fileHandler = new FileHandler("log%g.xml", 100, 4, false);
            fileHandler.setLevel(Level.ALL);
            fileHandler.setFilter(new Filter()
            {
                public boolean isLoggable(LogRecord record)
                {
                    return (record.getLevel().intValue() < Level.SEVERE.intValue() && record.getLevel().intValue() > Level.FINER.intValue()) ? true : false;
                }
            });
            logger.addHandler(fileHandler);
        }
        catch (SecurityException e)
        {
            logger.log(Level.SEVERE, e.toString(), e);
        }
        catch (IOException e)
        {
            logger.log(Level.SEVERE, e.toString(), e);
        }
        logout(logger);
    }

    private void logout(Logger log)
    {
        log.severe("severe msg");
        log.warning("warning msg");
        log.info("info msg");
        log.config("config msg");
        log.fine("fine msg");
        log.finer("finer msg");
        log.finest("finest msg");
    }

    public static void main(String[] args)
    {
        new loggerDemo1();
        new loggerDemo2();

    }
}


class loggerDemo2 extends loggerDemo1
{
    private Logger logger1 = Logger.getLogger(loggerDemo2.class.getSimpleName());
    private Logger logger2 = Logger.getLogger(loggerDemo1.class.getName() + "." + loggerDemo2.class.getSimpleName());
    private Logger logger3 = Logger.getLogger(super.loggerXX.getName() + "." + loggerDemo2.class.getSimpleName());

    public loggerDemo2()
    {
        System.out.println("-------------------------------------------------------------------------------------\n");
        //TODO : logger1.setUseParentHandlers(true);
        logger1.info("\ni'm logger1:" + logger1.getName() + "\nmy parent is:" + logger1.getParent().getName() + "\n");
        logger1.info("\ni'm logger2:" + logger2.getName() + "\nmy parent is:" + logger2.getParent().getName() + "\n");
        logger1.info("\ni'm logger3:" + logger3.getName() + "\nmy parent is:" + logger3.getParent().getName() + "\n");

        System.out.println("-------------------------------------------------------------------------------------\n");
        Enumeration<String> registeredLogger = LogManager.getLogManager().getLoggerNames();
        while (registeredLogger.hasMoreElements())
        {
            System.out.println("registered logger : " + registeredLogger.nextElement());
        }

        //TODO : logger2.info("lallalaa");

    }
}