Fork me on GitHub

Log4j日志框架

字数统计: 5.4k字   |   阅读时长≈ 26分

log4j

apache推出的一款老牌日志框架(已经放弃维护)

pom.xml

1
2
3
4
5
6

<dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

LogManager

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//只有静态属性，相当于单例，数据对所有的Logger共享
    
    
 /**
   * @deprecated This variable is for internal use only. It will
   * become package protected in future versions.
   * */
  static public final String DEFAULT_CONFIGURATION_FILE = "log4j.properties";
  
  static final String DEFAULT_XML_CONFIGURATION_FILE = "log4j.xml";  
   
  /**
   * @deprecated This variable is for internal use only. It will
   * become private in future versions.
   * */
  static final public String DEFAULT_CONFIGURATION_KEY="log4j.configuration";

  /**
   * @deprecated This variable is for internal use only. It will
   * become private in future versions.
   * */
  static final public String CONFIGURATOR_CLASS_KEY="log4j.configuratorClass";

  /**
  * @deprecated This variable is for internal use only. It will
  * become private in future versions.
  */
  public static final String DEFAULT_INIT_OVERRIDE_KEY = 
                                                 "log4j.defaultInitOverride";


  static private Object guard = null;
  static private RepositorySelector repositorySelector;   
    

static {
    // By default we use a DefaultRepositorySelector which always returns 'h'.
    
        //此对象将是获取logger的对象，这里root已经指定为new RootLogger((Level) Level.DEBUG)
    Hierarchy h = new Hierarchy(new RootLogger((Level) Level.DEBUG));
    repositorySelector = new DefaultRepositorySelector(h);

    /** Search for the properties file log4j.properties in the CLASSPATH.  */
    String override =OptionConverter.getSystemProperty(DEFAULT_INIT_OVERRIDE_KEY,
						       null);

    // if there is no default init override, then get the resource
    // specified by the user or the default config file.
    if(override == null || "false".equalsIgnoreCase(override)) {

      String configurationOptionStr = OptionConverter.getSystemProperty(
							  DEFAULT_CONFIGURATION_KEY, 
							  null);

      String configuratorClassName = OptionConverter.getSystemProperty(
                                                   CONFIGURATOR_CLASS_KEY, 
						   null);

      URL url = null;

      // if the user has not specified the log4j.configuration
      // property, we search first for the file "log4j.xml" and then
      // "log4j.properties"
      if(configurationOptionStr == null) {	
	url = Loader.getResource(DEFAULT_XML_CONFIGURATION_FILE);
	if(url == null) {
	  url = Loader.getResource(DEFAULT_CONFIGURATION_FILE);
	}
      } else {
	try {
	  url = new URL(configurationOptionStr);
	} catch (MalformedURLException ex) {
	  // so, resource is not a URL:
	  // attempt to get the resource from the class path
	  url = Loader.getResource(configurationOptionStr); 
	}	
      }
      
      // If we have a non-null url, then delegate the rest of the
      // configuration to the OptionConverter.selectAndConfigure
      // method.
      if(url != null) {
	    LogLog.debug("Using URL ["+url+"] for automatic log4j configuration.");
        try {
            OptionConverter.selectAndConfigure(url, configuratorClassName,
					   LogManager.getLoggerRepository());
        } catch (NoClassDefFoundError e) {
            LogLog.warn("Error during default initialization", e);
        }
      } else {
	    LogLog.debug("Could not find resource: ["+configurationOptionStr+"].");
      }
    } else {
        LogLog.debug("Default initialization of overridden by " + 
            DEFAULT_INIT_OVERRIDE_KEY + "property."); 
    }  
  }

RepositorySelector

1
2
3
4
5
6
7
8
9

/*
<code>LogManager</code>使用一个（而且只能使用一个）
<code>RepositorySelector</code>实现来选择
特定应用程序上下文的{@link LoggerRepository}。


<code>RepositorySelector</code>实现负责跟踪应用程序上下文。Log4j对应用程序上下文或其管理没有任何假设。
*/

LoggerRepository

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
<code>LoggerRepository</code>用于创建和检索

<code>loggers</code>。存储库中记录器之间的关系

取决于存储库，但通常情况下，记录器被安排在

命名层次结构。

除了创造的方法，一个

<code>LoggerRepository</code>可以查询现有的记录器，

可以作为与记录器相关的事件的注册表点。
*/


//logger的仓库

Logger

1
2
3
4
5
6

继承 Category
/*

这是log4j包中的中心类。除了配置之外，大多数日志记录操作都是通过这个类完成的。
*/
Category
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Category implements AppenderAttachable
/*

这个类已经被弃用并被{@link logger}<em>子类所取代</em>


它将一直保留到2003年年中，以保持向后兼容性。

<code>Logger</code>是Category的一个子类，即它扩展Category。换句话说，记录器是一个类别。因此，可以对类别执行的所有操作都可以在记录器上执行。在内部，每当log4j被要求生成一个Category对象时，它将生成一个Logger对象。log4j1.2不会生成Category对象，只会生成Logger实例。为了保持向后兼容性，以前接受category对象的方法仍然继续接受category对象。

例如，下面这些都是合法的，将按预期工作。
<pre>
    &nbsp;&nbsp;&nbsp;// Deprecated form:
    &nbsp;&nbsp;&nbsp;Category cat = Category.getInstance("foo.bar")
   
    &nbsp;&nbsp;&nbsp;// Preferred form for retrieving loggers:
    &nbsp;&nbsp;&nbsp;Logger logger = Logger.getLogger("foo.bar")
   </pre>
第一种形式已弃用，应避免使用。

完全没有必要使用或引用<code>Category</code>类。</b>只要可能，请避免引用或使用它。

关于这门课的介绍，请参阅简短的手册。
 有关更详细的讨论，请参阅标题为“准备log4j 1.3”的文档。
*/
AppenderAttachable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

/*
用于 把appenders附加到 自己的实例 的接口


appender就是jul 的Handler
*/

/**
     Add an appender.
   */
  public
  void addAppender(Appender newAppender);

  /**
     Get all previously added appenders as an Enumeration.  */
  public
  Enumeration getAllAppenders();

  /**
     Get an appender by name.
   */
  public
  Appender getAppender(String name);

  
  /**
     Returns <code>true</code> if the specified appender is in list of
     attached attached, <code>false</code> otherwise.

     @since 1.2 */
  public 
  boolean isAttached(Appender appender);

  /**
     Remove all previously added appenders.
  */
  void removeAllAppenders();


  /**
     Remove the appender passed as parameter from the list of appenders.
  */
   void removeAppender(Appender appender);


 /**
    Remove the appender with the name passed as parameter from the
    list of appenders.  
  */
 void
 removeAppender(String name);   
}

数据统一由Logmanager进行管理

但是Logmanager 就不好扩展了，于是 集成一个 LogRepository 来管理logger和其他appender， LogManager只提供算法， 但还是不是特别扩展，于是抽出一个策略接口 RepositorySelector，用它来具体获取 要使用那个LogRepository ，（工厂模式，策略模式，模板方法，）

对于这种管理 一个主要对象的模式， 聚合一个策略接口是一种很好的选择

Layout

1
2
3


//扩展这个抽象类来创建您自己的日志布局格式。

AppenderSkeleton

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

//包中其他附件的抽象超类。
//这个类提供了常见功能的代码，例如支持阈值过滤和支持常规过滤器。

public abstract class AppenderSkeleton implements Appender, OptionHandler

    
    /** The layout variable does not need to be set if the appender
      implementation has its own layout. */
  protected Layout layout;

  /** Appenders are named. */
  protected String name;

  /**
     There is no level threshold filtering by default.  */
  protected Priority threshold;

  /** 
      It is assumed and enforced that errorHandler is never null.
  */
  protected ErrorHandler errorHandler = new OnlyOnceErrorHandler();

  /** The first filter in the filter chain. Set to <code>null</code>
      initially. */
  protected Filter headFilter;
  /** The last filter in the filter chain. */
  protected Filter tailFilter;

  /**
     Is this appender closed? 
   */
  protected boolean closed = false;
OptionHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//基于字符串的接口，用于配置程序包组件。



void activateOptions();
 //激活以前通过调用选项设置器设置的选项。
 //这允许推迟选项的激活，直到设置了所有选项。对于具有相关选项的组件来说，这是必需的，直到所有选项都设置好为止。
    /* <p>例如，FileAppender具有{@linkorg.apache.log4j.FileAppender\setFile File}和{@linkorg.apache.log4j.FileAppender\setAppend Append}这两个选项在设置另一个选项之前都不明确。  */

   Activate the options that were previously set with calls to option setters.
#如果选项结构需要，派生的附加器应该重写此方法。
       
       /*
  PropertySetter下   
       public
  void setProperties(Properties properties, String prefix) {
    ...中间代码省略
    activate();
  }
        public
  void activate() {
    if (obj instanceof OptionHandler) {
      ((OptionHandler) obj).activateOptions();
    }
  }
       */
       
        parseAppenderFilters里面也会调用
Appender
1
2
3
//为您自己的输出日志语句的策略实现这个接口。
/** 如果appender实现有自己的布局，则不需要设置layout变量。 */
protected Layout layout;

获取logger

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 模式的logger工厂是DefaultCategoryFactory
 public
  Hierarchy(Logger root) {
    ht = new Hashtable();
    listeners = new Vector(1);
    this.root = root;
    // Enable all level levels by default.
    setThreshold(Level.ALL);
    this.root.setHierarchy(this);
    rendererMap = new RendererMap();
    defaultFactory = new DefaultCategoryFactory();
  }

 public
  Logger getLogger(String name) {
    return getLogger(name, defaultFactory);
  }

public Logger getLogger(String name, LoggerFactory factory) {
        //System.out.println("getInstance("+name+") called.");
    //CategoryKey是字符串的包装器，在早期的JVM中，它显然加速了哈希表的查找。
    //其实就是做了个缓存，提前生成好hash，用属性存起来
    /*
      CategoryKey(String name) {
    this.name = name;
    hashCache = name.hashCode();
  }
    */
        CategoryKey key = new CategoryKey(name);
        // 同步以防止写入冲突。只有当变量赋值是非原子的时（在getChainedLevel方法中）才可能发生读取冲突。
        Logger logger;

    // Hashtable ht; 用来记录 缓存的key
        synchronized (ht) {
            
            Object o = ht.get(key);
            if (o == null) {
                //不存在创建一个logger
                logger = factory.makeNewLoggerInstance(name);
                //设置所在的 仓库是 this
                logger.setHierarchy(this);
                //放入缓存
                ht.put(key, logger);
                //更新父子关系
                updateParents(logger);
                return logger;
            } else if (o instanceof Logger) {
                return (Logger) o;
            } else if (o instanceof ProvisionNode) {
                //System.out.println("("+name+") ht.get(this) returned ProvisionNode");
                //如果是预创建节点，那就新创建一个logger
                logger = factory.makeNewLoggerInstance(name);
                logger.setHierarchy(this);
                //替换
                ht.put(key, logger);
                //更新父子关系
                updateChildren((ProvisionNode) o, logger);
            
                updateParents(logger);
                return logger;
            } else {
                // It should be impossible to arrive here
                return null;  // but let's keep the compiler happy.
            }
        }
    }

父子关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 final
    private void updateParents(Logger cat) {
        String name = cat.name;
        int length = name.length();
        boolean parentFound = false;

        //System.out.println("UpdateParents called for " + name);

        // if name = "w.x.y.z", loop thourgh "w.x.y", "w.x" and "w", but not "w.x.y.z"
     //上面这个例子很明确，按点隔开
        for (int i = name.lastIndexOf('.', length - 1); i >= 0;
             i = name.lastIndexOf('.', i - 1)) {
            String substr = name.substring(0, i);

            //System.out.println("Updating parent : " + substr);
            CategoryKey key = new CategoryKey(substr); // simple constructor
            Object o = ht.get(key);
            // Create a provision node for a future parent.
            if (o == null) {
                //System.out.println("No parent "+substr+" found. Creating ProvisionNode.");
                //不存在父级就先 创建一个ProvisionNode 存起来
                ProvisionNode pn = new ProvisionNode(cat);
                ht.put(key, pn);
            } else if (o instanceof Category) {
                //存在父级 就把 父级指针指向  o
                parentFound = true;
                cat.parent = (Category) o;
                //System.out.println("Linking " + cat.name + " -> " + ((Category) o).name);
                break; // no need to update the ancestors of the closest ancestor
            } else if (o instanceof ProvisionNode) {
                //如果不存在父级，但是存在父级预创节点， 此时addElement
                ((ProvisionNode) o).addElement(cat);
            } else {
                Exception e = new IllegalStateException("unexpected object type " +
                        o.getClass() + " in ht.");
                e.printStackTrace();
            }
        }
        // If we could not find any existing parents, then link with root.
        if (!parentFound)
            //没有父级的时候，父级就是root
            cat.parent = root;
    }



final
  private
  void updateChildren(ProvisionNode pn, Logger logger) {
    //System.out.println("updateChildren called for " + logger.name);
    final int last = pn.size();

    for(int i = 0; i < last; i++) {
      Logger l = (Logger) pn.elementAt(i);
      //System.out.println("Updating child " +p.name);

      // Unless this child already points to a correct (lower) parent,
      // make cat.parent point to l.parent and l.parent to cat.
      if(!l.parent.name.startsWith(logger.name)) {
	logger.parent = l.parent;
	l.parent = logger;
      }
    }
  }

记录操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 public
  void error(Object message) {
    if(repository.isDisabled(Level.ERROR_INT))  //判断阈值是否超过指定级别
      return;
     //获取当前logger的可用级别来进行
    if(Level.ERROR.isGreaterOrEqual(this.getEffectiveLevel()))
      forcedLog(FQCN, Level.ERROR, message, null);
  }



protected
  void forcedLog(String fqcn, Priority level, Object message, Throwable t) {
    //把消息包装成一个 日志事件，使用观察者模式的方式 来处理 事件
    callAppenders(new LoggingEvent(fqcn, this, level, message, t));
  }


 public
  void callAppenders(LoggingEvent event) {
    int writes = 0;

    for(Category c = this; c != null; c=c.parent) {
      // Protected against simultaneous call to addAppender, removeAppender,...
      synchronized(c) {
        if(c.aai != null) {
          writes += c.aai.appendLoopOnAppenders(event);
        }
          
       //  protected boolean additive = true;其实就是 JUL的useparentHandler       
        if(!c.additive) {
          break;
        }
      }
    }

    if(writes == 0) {
      repository.emitNoAppenderWarning(this);
    }
  }

/*
public class AppenderAttachableImpl implements AppenderAttachable {
  
  /** Array of appenders. */
  protected Vector  appenderList;

*/
  AppenderAttachableImpl aai; // 他一个具有能够添加和管理Appender的实现



public
  int appendLoopOnAppenders(LoggingEvent event) {
    int size = 0;
    Appender appender;

    if(appenderList != null) {
      size = appenderList.size();
      for(int i = 0; i < size; i++) {
	appender = (Appender) appenderList.elementAt(i);
	appender.doAppend(event);
      }
    }    
    return size;
  }





 public
  synchronized 
  void doAppend(LoggingEvent event) {
     //appender处理
    if(closed) {
      LogLog.error("Attempted to append to closed appender named ["+name+"].");
      return;
    }
    //appender的级别判断
    if(!isAsSevereAsThreshold(event.getLevel())) {
      return;
    }

    Filter f = this.headFilter;
    
    FILTER_LOOP:
    //过滤变成一个链表，获取头
    while(f != null) {
        //处理得到返回值
      switch(f.decide(event)) {
      case Filter.DENY: return; //这是拒绝，直接返回
      case Filter.ACCEPT: break FILTER_LOOP; //跳出循环
      case Filter.NEUTRAL: f = f.getNext(); //获取下一个filter，进行处理
      }
    }
    
     //最后appender处理
    this.append(event);    
  }

使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


 @Test
    public void test5() {

        Logger logger = Logger.getLogger("aa");

        //创建一个Layout(formatter)，

        SimpleLayout layout=new SimpleLayout();
        //创建appender（handler）
        ConsoleAppender appender=new ConsoleAppender(layout,ConsoleAppender.SYSTEM_ERR);
        //设置handler的级别
        appender.setThreshold(Level.INFO);

        //设置logger的级别
        logger.setLevel(Level.ALL);

        //附加appender到logger对象
        logger.addAppender(appender);
        
        //这里由于根logger没有appender，所以不需要管 继承和不继承
        logger.error("aaa");

    }


使用继承
   @Test
    public void test5() {

        /*   static
  public
  void configure() {
    Logger root = Logger.getRootLogger();
    root.addAppender(new ConsoleAppender(
           new PatternLayout(PatternLayout.TTCC_CONVERSION_PATTERN)));
  }
  */
        BasicConfigurator.configure();

        Logger logger = Logger.getLogger("aa");
        //设置logger的级别
        logger.setLevel(Level.ALL);

        logger.error("aaa");

    }
日志级别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/**
   * 跟踪级别整数值。
   * @since 1.2.12
   */
 public static final int TRACE_INT = 5000;

 /**
   <code>OFF</code>具有最高的可能等级，用于关闭日志记录。  */
 final static public Level OFF = new Level(OFF_INT, "OFF", 0);

 /**
    <code>FATAL</code>级别指定可能导致应用程序中止的非常严重的错误事件。
  */
 final static public Level FATAL = new Level(FATAL_INT, "FATAL", 0);

 /**
    <code>ERROR</code>级别指定可能仍允许应用程序继续运行的错误事件。  */
 final static public Level ERROR = new Level(ERROR_INT, "ERROR", 3);

 /**
   <code>WARN</code>级别表示潜在的有害情况。
 */
 final static public Level WARN  = new Level(WARN_INT, "WARN",  4);

 /**
    <code>INFO</code>级别指定在粗粒度级别突出显示应用程序进度的信息性消息。  */
 final static public Level INFO  = new Level(INFO_INT, "INFO",  6);

 /**
    <code>DEBUG</code>级别指定对调试应用程序最有用的细粒度信息事件。  */
 final static public Level DEBUG = new Level(DEBUG_INT, "DEBUG", 7);

 /**
   * <code>TRACE</code>级别指定比<code>DEBUG</code级别更细粒度的信息事件。
  *  @since 1.2.12
   */
 public static final Level TRACE = new Level(TRACE_INT, "TRACE", 7);


 /**
    <code>ALL</code>具有尽可能低的等级，旨在打开所有日志记录。 */
 final static public Level ALL = new Level(ALL_INT, "ALL", 7);




@Test
   public void test5() {
       BasicConfigurator.configure();

       Logger logger = Logger.getLogger("aa");
       //设置logger的级别
       logger.setLevel(Level.ALL);

       logger.fatal("fatal");//严重错误，一般造成系统奔溃并终止运行
       logger.error("error");//错误信息，不会影响系统运行
       logger.warn("warn");//可能存在的潜在危险
       logger.info("info");//数据状态，网络连接，IO操作，数据库操作等
       logger.debug("debug");//调试信息，记录一些变量
       logger.trace("trace");

   }

组件

loggers

日志记录器

appenders

日志处理（输出）器

1
2
3
4
5
ConsoleAppender //日志输出到控制台
FileAppender   //日志输出到文件
DalyRollingFileAppender //日志输出到，并且每天输出到一个新文件
RollingFileAppender//输出到文件，可以指定文件尺寸，超过其大小则输出到新文件
JDBCAppender    //日志输出到数据库
layout

日志格式化器 

1
2
3
HtmlLayout //格式化成html表格形式
SimpleLayout //简单的日志格式化，打印的日志格式为 （info message）     
PatternLayout// 最强大的格式化器，可以根据自定义格式输出日志，如果没有指定，则使用默认的转化格式

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
static {
        // By default we use a DefaultRepositorySelector which always returns 'h'.
       //初始化根logger
        Hierarchy h = new Hierarchy(new RootLogger((Level) Level.DEBUG));
        repositorySelector = new DefaultRepositorySelector(h);

        /** 在CLASSPATH中搜索属性文件log4j.properties。  */
        /** Search for the properties file log4j.properties in the CLASSPATH.  */
    	//如果由默认配置覆盖，请设置环境属性log4j.defaultInitOverride为true，或者其他
        String override = OptionConverter.getSystemProperty(DEFAULT_INIT_OVERRIDE_KEY,
                null);

        // 如果没有默认的init覆盖，则获取用户指定的资源或默认配置文件。
        if (override == null || "false".equalsIgnoreCase(override)) {

            //指定 的自定义配置文件位置 ，就是设置log4j.configuration系统属性
            String configurationOptionStr = OptionConverter.getSystemProperty(
                    DEFAULT_CONFIGURATION_KEY,
                    null);
			//指定配置类 log4j.configuratorClass
            String configuratorClassName = OptionConverter.getSystemProperty(
                    CONFIGURATOR_CLASS_KEY,
                    null);

            URL url = null;

            // 如果用户没有指定log4j.configuration属性，我们首先搜索文件“log4j.xml”，然后搜索“log4j.properties”
            if (configurationOptionStr == null) {
                //加载 log4j.xml配置
                url = Loader.getResource(DEFAULT_XML_CONFIGURATION_FILE);
                if (url == null) {
                    //加载 log4j.properties配置
                    url = Loader.getResource(DEFAULT_CONFIGURATION_FILE);
                }
            } else {
                try {
                    url = new URL(configurationOptionStr);
                } catch (MalformedURLException ex) {
                    // 因此，resource不是URL：尝试从类路径获取资源
                    url = Loader.getResource(configurationOptionStr);
                }
            }

            // 如果我们有一个非空的url，那么将配置的其余部分委托给选项转换器。选择并配置方法。
            if (url != null) {
                LogLog.debug("Using URL [" + url + "] for automatic log4j configuration.");
                try {
                    OptionConverter.selectAndConfigure(url, configuratorClassName,
                            LogManager.getLoggerRepository());
                } catch (NoClassDefFoundError e) {
                    LogLog.warn("Error during default initialization", e);
                }
            } else {
                LogLog.debug("Could not find resource: [" + configurationOptionStr + "].");
            }
        } else {
            LogLog.debug("Default initialization of overridden by " +
                    DEFAULT_INIT_OVERRIDE_KEY + "property.");
        }
    }



 static
    public void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) {
        Configurator configurator = null;
        String filename = url.getFile();

        if (clazz == null && filename != null && filename.endsWith(".xml")) {
            clazz = "org.apache.log4j.xml.DOMConfigurator";
        }

        if (clazz != null) {
            LogLog.debug("Preferred configurator class: " + clazz);
            configurator = (Configurator) instantiateByClassName(clazz,
                    Configurator.class,
                    null);
            if (configurator == null) {
                LogLog.error("Could not instantiate configurator [" + clazz + "].");
                return;
            }
        } else {
            //获取配置器
            configurator = new PropertyConfigurator();
        }
		//进行配置
        configurator.doConfigure(url, hierarchy);
    }




public void doConfigure(Properties properties, LoggerRepository hierarchy) {
        repository = hierarchy;
        String value = properties.getProperty(LogLog.DEBUG_KEY);
        if (value == null) {
            value = properties.getProperty("log4j.configDebug");
            if (value != null)
                LogLog.warn("[log4j.configDebug] is deprecated. Use [log4j.debug] instead.");
        }

        if (value != null) {
            LogLog.setInternalDebugging(OptionConverter.toBoolean(value, true));
        }

        //
        //   if log4j.reset=true then
        //        reset hierarchy
        String reset = properties.getProperty(RESET_KEY);
        if (reset != null && OptionConverter.toBoolean(reset, false)) {
            hierarchy.resetConfiguration();
        }

        String thresholdStr = OptionConverter.findAndSubst(THRESHOLD_PREFIX,
                properties);
        if (thresholdStr != null) {
            hierarchy.setThreshold(OptionConverter.toLevel(thresholdStr,
                    (Level) Level.ALL));
            LogLog.debug("Hierarchy threshold set to [" + hierarchy.getThreshold() + "].");
        }

    	//处理根logger
        configureRootCategory(properties, hierarchy);
    	//处理logger工厂
        configureLoggerFactory(properties);
    	//处理logger和appender和layout和filter
        parseCatsAndRenderers(properties, hierarchy);

        LogLog.debug("Finished configuring.");
        // We don't want to hold references to appenders preventing their
        // garbage collection.
        registry.clear();
    }
解析logger
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


void parseCategory(Properties props, Logger logger, String optionKey,
                      String loggerName, String value) {

       LogLog.debug("Parsing for [" + loggerName + "] with value=[" + value + "].");
       // We must skip over ',' but not white space
      //按,号分割
       StringTokenizer st = new StringTokenizer(value, ",");

       // If value is not in the form ", appender.." or "", then we should set
       // the level of the loggeregory.

       if (!(value.startsWith(",") || value.equals(""))) {

           // just to be on the safe side...
           if (!st.hasMoreTokens())
               return;
		//第一个值必须为 级别
           String levelStr = st.nextToken();
           LogLog.debug("Level token is [" + levelStr + "].");

           // If the level value is inherited, set category level value to
           // null. We also check that the user has not specified inherited for the
           // root category.
           if (INHERITED.equalsIgnoreCase(levelStr) ||
                   NULL.equalsIgnoreCase(levelStr)) {
               if (loggerName.equals(INTERNAL_ROOT_NAME)) {
                   LogLog.warn("The root logger cannot be set to null.");
               } else {
                   logger.setLevel(null);
               }
           } else {
               logger.setLevel(OptionConverter.toLevel(levelStr, (Level) Level.DEBUG));
           }
           LogLog.debug("Category " + loggerName + " set to " + logger.getLevel());
       }

       // Begin by removing all existing appenders.
       logger.removeAllAppenders();

       Appender appender;
       String appenderName;
       while (st.hasMoreTokens()) {
           //然后才是对应的appender
           appenderName = st.nextToken().trim();
           if (appenderName == null || appenderName.equals(","))
               continue;
           LogLog.debug("Parsing appender named \"" + appenderName + "\".");
           appender = parseAppender(props, appenderName);
           if (appender != null) {
               logger.addAppender(appender);
           }
       }
   }
解析appender
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
Appender parseAppender(Properties props, String appenderName) {
        Appender appender = registryGet(appenderName);
        if ((appender != null)) {
            LogLog.debug("Appender \"" + appenderName + "\" was already parsed.");
            return appender;
        }
      //APPENDER_PREFIX=log4j.appender.
        // Appender was not previously initialized.
        String prefix = APPENDER_PREFIX + appenderName;
        String layoutPrefix = prefix + ".layout";

        appender = (Appender) OptionConverter.instantiateByKey(props, prefix,
                org.apache.log4j.Appender.class,
                null);
        if (appender == null) {
            LogLog.error(
                    "Could not instantiate appender named \"" + appenderName + "\".");
            return null;
        }
        appender.setName(appenderName);

        if (appender instanceof OptionHandler) {
            if (appender.requiresLayout()) {
               // 处理layout
                Layout layout = (Layout) OptionConverter.instantiateByKey(props,
                        layoutPrefix,
                        Layout.class,
                        null);
                if (layout != null) {
                    appender.setLayout(layout);
                    LogLog.debug("Parsing layout options for \"" + appenderName + "\".");
                    //configureOptionHandler(layout, layoutPrefix + ".", props);
                    PropertySetter.setProperties(layout, props, layoutPrefix + ".");
                    LogLog.debug("End of parsing for \"" + appenderName + "\".");
                }
            }
            final String errorHandlerPrefix = prefix + ".errorhandler";
            String errorHandlerClass = OptionConverter.findAndSubst(errorHandlerPrefix, props);
            if (errorHandlerClass != null) {
                //处理 errorhandler
                ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByKey(props,
                        errorHandlerPrefix,
                        ErrorHandler.class,
                        null);
                if (eh != null) {
                    appender.setErrorHandler(eh);
                    LogLog.debug("Parsing errorhandler options for \"" + appenderName + "\".");
                    parseErrorHandler(eh, errorHandlerPrefix, props, repository);
                    final Properties edited = new Properties();
                    final String[] keys = new String[]{
                            errorHandlerPrefix + "." + ROOT_REF,
                            errorHandlerPrefix + "." + LOGGER_REF,
                            errorHandlerPrefix + "." + APPENDER_REF_TAG
                    };
                    for (Iterator iter = props.entrySet().iterator(); iter.hasNext(); ) {
                        Map.Entry entry = (Map.Entry) iter.next();
                        int i = 0;
                        for (; i < keys.length; i++) {
                            if (keys[i].equals(entry.getKey())) break;
                        }
                        if (i == keys.length) {
                            edited.put(entry.getKey(), entry.getValue());
                        }
                    }
                    PropertySetter.setProperties(eh, edited, errorHandlerPrefix + ".");
                    LogLog.debug("End of errorhandler parsing for \"" + appenderName + "\".");
                }

            }
            //configureOptionHandler((OptionHandler) appender, prefix + ".", props);
            PropertySetter.setProperties(appender, props, prefix + ".");
            LogLog.debug("Parsed \"" + appenderName + "\" options.");
        }
    //处理过滤器
        parseAppenderFilters(props, appenderName, appender);
        registryPut(appender);
        return appender;
    }



---------------layout处理---------------
     //通过反射 拿到方法进行注入
       Method setter = prop.getWriteMethod();

      setter.invoke(obj, new Object[]  { arg });

log4j.appender.myAppender.layout.conversionPattern=%r [%t] %p %c %x - %m%n

Log4j内置Loglog

1
2
3
4
5
6
7
8

//记录log4j内部启动或者执行的日志

//全局控制（warning，info,error，debug）等
  private static boolean quietMode = false;//true 是关闭

//控制debug
  protected static boolean debugEnabled = false; //true启动

Layout语法说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

%m  //输出代码中指定的日志信息
%p  //输出日志是什么级别 及DEBUG，INFO等
%n  //换行符
%r  //输出自应用启动到输出该log 信息所耗费的毫秒数
%c  //输出打印语句所属的类的全名
%t  //输出产生该日志的线程全名
%d  //输出当前服务器时间，默认是时间戳可以%d(yyyy年MM月dd日 HH:mm:ss)    
%l  //输出日志发生的位置，包括类名，线程，及代码行数
%f  //输出日志消息产生时所在的文件名称
%L  //输出代码中的行号
%%  //输出一个 % 字符    

    
%5p 中间加数字代表 此日志级别要站5个字符 右对齐
%-5p    中间加数字代表 此日志级别要站5个字符，左对齐

FileAppender

1
2
3
4
5
6
7
8
9
10
11
12

#继承 WriterAppender
 #new PropertySetter(obj).setProperties(properties, prefix);这里可以看到是通过set方法进行属性注入的

log4j.rootLogger= all,file

#前一级file表示appender的名字，后一级的file表示 FileAppender的setFile方法
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.file=F:/test/test.log
log4j.appender.file.Encoding=utf-8
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.conversionPattern= %d(yyyy-MM-dd HH:mm:ss.SSS) [%t] [%6p] %l %x - %m%n
RollingFileAppender
1
2
3
4
5
6
7
8
9
10

#继承 FileAppender


#maxBackupIndex：设置要保留的最大备份文件数。MaxBackupIndex</b>选项决定在删除最早的备份文件之前保留了多少个备份文件。此选项采用正整数值。如果设置为零，则没有备份文件，当日志文件达到<code>MaxFileSize</code>时，日志文件将被截断。

#maximumFileSize: 设置在将输出文件回滚到备份文件之前允许达到的最大大小。此方法与{@link#setMaxFileSize}等效，只是它是区分接受<code>long</code>参数的setter和JavaBeans Introspector使用<code>String</code>参数的setter所必需的。


#maxFileSize: 设置在将输出文件回滚到备份文件之前允许达到的最大大小。在配置文件中，<b>MaxFileSize</b>选项采用0-2^63范围内的长整数。您可以用后缀“KB”、“MB”或“GB”来指定值，这样整数就可以分别用千字节、兆字节或千兆字节来表示。例如，值“10KB”将被解释为10240。
ExternallyRolledFileAppender
1
2
3
4
5
#继承 RollingFileAppender

#port：<b>port</b>[属性用于设置侦听外部滚动消息的端口。

主要用于往外部系统写日志，底层low，就是每次开一个线程处理socket
DailyRollingFileAppender
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
继承FileAppender
/*


*/
datePattern: 就是最后按日期来命名日志文件的 时间格式
    
    
    
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=F:/test/test
log4j.appender.file.Encoding=utf-8
log4j.appender.file.datePattern='.'yyyy-MM-dd=HH=mm=ss'.log'
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.conversionPattern= %d(yyyy-MM-dd HH:mm:ss.SSS) [%t] [%6p] %l %x - %m%n

JDBCAppender

1
2
3
4
5
6
7
8
9

log4j.appender.jdbcAppender=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.jdbcAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.jdbcAppender.user= root
log4j.appender.jdbcAppender.password=123456
log4j.appender.jdbcAppender.uRL=jdbc:mysql://localhost:3306/test
log4j.appender.jdbcAppender.driver=com.mysql.jdbc.Driver
log4j.appender.jdbcAppender.sql=insert into log(project_name,create_date,level,logger,file_name,thread_name,line,all_logger,message) \
  values('test','%d(yyyy-MM-dd HH:mm:ss)','%p','%c','%f','%t','%L','%l','%m' )

自定义logger

1
2
3
4
5
6
7

#LOGGER_PREFIX   = "log4j.logger.";
log4j.logger.aa= all,myAppender

log4j.appender.myAppender=org.apache.log4j.ConsoleAppender
log4j.appender.myAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.myAppender.layout.conversionPattern= %d(yyyy-MM-dd HH:mm:ss.SSS) [%t] [%6p] %l %x - %m%n
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家