即获取Logger实例->判断Logger实例对应的日志记录级别是否要比请求的级别低->若是调用forceLog记录日志->创建LoggingEvent实例->将LoggingEvent实例传递给Appender->Appender调用Layout实例格式化日志消息->Appender将格式化后的日志信息写入该Appender对应的日志输出中。

包含Log4J其他模块类的更详细序列图如下：

 1  private  ResourceBundle resourceBundle;
 2  public   void  l7dlog(Level level, String key, Throwable cause) {
 3       if (isLevelEnabled(level)) {
 4          String message  =  getResourceBundleString(key);
 5           if (message  ==   null ) {
 6              message  =  key;
 7          }
 8          forceLog(FQCN, level, message, cause);
 9      }
10  }
11 
12  public   void  l7dlog(Level level, String key, Object[] params, Throwable cause) {
13      
14           if (pattern  ==   null ) {
15              message  =  key;
16          }  else  {
17              message  =  MessageFormat.format(pattern, params);
18          }
19      
20  }
21 
22  protected  String getResourceBundleString(String key) {
23      ResourceBundle rb  =  getResourceBundle();
24      
25       return  rb.getString(key);
26  } 
27  public  ResourceBundle getResourceBundle() {
28       for (Logger logger  =   this ; logger  !=   null ; logger  =  logger.parent) {
29           if (logger.resourceBundle  !=   null ) {
30               return  logger.resourceBundle;
31          }
32      }
33       return   null ;    
34 }

我们知道在异常栈中每一条记录都包含了方法调用对应的这些信息，Log4J的这些信息正是利用了这个原理，即通过构建一个Throwable实例，而后在该Throwable的栈信息中解析出来的：

1  public  LocationInfo getLocationInformation() {
2       if  (locationInfo  ==   null ) {
3          locationInfo  =   new  LocationInfo( new  Throwable(), 
4  fqnOfCategoryClass);
5      }
6       return  locationInfo;
7  }

以上Throwable一般会产生如下异常栈：

1  java.lang.Throwable
2 
3  at org.apache.log4j.PatternLayout.format(PatternLayout.java: 413 )
4  at org.apache.log4j.FileAppender.doAppend(FileAppender.java: 183 )
5  at org.apache.log4j.Category.callAppenders(Category.java: 131 )
6  at org.apache.log4j.Category.log(Category.java: 512 )
7  at callers.fully.qualified.className.methodName(FileName.java: 74 )
8 

因而我们就可以通过callers.fully.qualified.className信息来找到改行信息，这个className信息即是传入的fqnOfCategoryClass。

如果当前JDK版本是1.4以上，我们就可以通过JDK提供的一些方法来查找：

 1  getStackTraceMethod  =  Throwable. class .getMethod( " getStackTrace " ,
 2          noArgs);
 3  Class stackTraceElementClass  =  Class
 4          .forName( " java.lang.StackTraceElement " );
 5  getClassNameMethod  =  stackTraceElementClass.getMethod(
 6           " getClassName " , noArgs);
 7  getMethodNameMethod  =  stackTraceElementClass.getMethod(
 8           " getMethodName " , noArgs);
 9  getFileNameMethod  =  stackTraceElementClass.getMethod( " getFileName " ,
10          noArgs);
11  getLineNumberMethod  =  stackTraceElementClass.getMethod(
12           " getLineNumber " , noArgs);
13 
14  Object[] noArgs  =   null ;
15  Object[] elements  =  (Object[]) getStackTraceMethod.invoke(t,
16          noArgs);
17  String prevClass  =  NA;
18  for  ( int  i  =  elements.length  -   1 ; i  >=   0 ; i -- ) {
19      String thisClass  =  (String) getClassNameMethod.invoke(
20              elements[i], noArgs);
21       if  (fqnOfCallingClass.equals(thisClass)) {
22           int  caller  =  i  +   1 ;
23           if  (caller  <  elements.length) {
24              className  =  prevClass;
25              methodName  =  (String) getMethodNameMethod.invoke(
26                      elements[caller], noArgs);
27              fileName  =  (String) getFileNameMethod.invoke(
28                      elements[caller], noArgs);
29               if  (fileName  ==   null ) {
30                  fileName  =  NA;
31              }
32               int  line  =  ((Integer) getLineNumberMethod.invoke(
33                      elements[caller], noArgs)).intValue();
34               if  (line  <   0 ) {
35                  lineNumber  =  NA;
36              }  else  {
37                  lineNumber  =  String.valueOf(line);
38              }
39              StringBuffer buf  =   new  StringBuffer();
40              buf.append(className);
41              buf.append( " . " );
42              buf.append(methodName);
43              buf.append( " ( " );
44              buf.append(fileName);
45              buf.append( " : " );
46              buf.append(lineNumber);
47              buf.append( " ) " );
48               this .fullInfo  =  buf.toString();
49          }
50           return ;
51      }
52      prevClass  =  thisClass;
53  }

否则，则需要我们通过字符串查找的方式来查找：

 1  String s;
 2  //  Protect against multiple access to sw.
 3  synchronized  (sw) {
 4      t.printStackTrace(pw);
 5      s  =  sw.toString();
 6      sw.getBuffer().setLength( 0 );
 7  }
 8  int  ibegin, iend;
 9  ibegin  =  s.lastIndexOf(fqnOfCallingClass);
10  if  (ibegin  ==   - 1 )
11       return ;
12  //  See bug 44888.
13  if  (ibegin  +  fqnOfCallingClass.length()  <  s.length()
14           &&  s.charAt(ibegin  +  fqnOfCallingClass.length())  !=   ' . ' ) {
15       int  i  =  s.lastIndexOf(fqnOfCallingClass  +   " . " );
16       if  (i  !=   - 1 ) {
17          ibegin  =  i;
18      }
19  }
20 
21  ibegin  =  s.indexOf(Layout.LINE_SEP, ibegin);
22  if  (ibegin  ==   - 1 )
23       return ;
24  ibegin  +=  Layout.LINE_SEP_LEN;
25 
26  //  determine end of line
27  iend  =  s.indexOf(Layout.LINE_SEP, ibegin);
28  if  (iend  ==   - 1 )
29       return ;
30 
31  //  VA has a different stack trace format which doesn't
32  //  need to skip the inital 'at'
33  if  ( ! inVisualAge) {
34       //  back up to first blank character
35      ibegin  =  s.lastIndexOf( " at  " , iend);
36       if  (ibegin  ==   - 1 )
37           return ;
38       //  Add 3 to skip "at ";
39      ibegin  +=   3 ;
40  }
41  //  everything between is the requested stack item
42  this .fullInfo  =  s.substring(ibegin, iend);

对于通过字符串查找到的fullInfo值，在获取其他单个值时还需要做相应的字符串解析：
className:

 1  //  Starting the search from '(' is safer because there is
 2  //  potentially a dot between the parentheses.
 3  int  iend  =  fullInfo.lastIndexOf( ' ( ' );
 4  if  (iend  ==   - 1 )
 5      className  =  NA;
 6  else  {
 7      iend  =  fullInfo.lastIndexOf( ' . ' , iend);
 8 
 9       //  This is because a stack trace in VisualAge looks like:
10 
11       //  java.lang.RuntimeException
12       //  java.lang.Throwable()
13       //  java.lang.Exception()
14       //  java.lang.RuntimeException()
15       //  void test.test.B.print()
16       //  void test.test.A.printIndirect()
17       //  void test.test.Run.main(java.lang.String [])
18       int  ibegin  =   0 ;
19       if  (inVisualAge) {
20          ibegin  =  fullInfo.lastIndexOf( '   ' , iend)  +   1 ;
21      }
22 
23       if  (iend  ==   - 1 )
24          className  =  NA;
25       else
26          className  =   this .fullInfo.substring(ibegin, iend);

 

ObjectRender接口

Log4J中，对传入的message实例，如果是非String类型，会先使用注册的ObjectRender（在LogRepository中查找注册的ObjectRender信息）处理成String后返回，若没有找到相应的ObjectRender，则使用默认的ObjectRender，它只是调用该消息实例的toString()方法。

ThrowableInformation类

ThrowableInformation类用以处理异常栈信息，即通过Throwable实例获取异常栈字符串数组。同时还支持自定义的ThrowableRender（在LogRepository中设置），默认的ThrowableRender通过系统printStackTrace()方法来获取信息：

Layout类

Layout负责将LoggingEvent中的信息格式化成一行日志信息。对不同格式的日志可能还需要提供头和尾等信息。另外有些Layout不会处理异常信息，此时ignoresThrowable()方法返回false，并且异常信息需要Appender来处理，如PatternLayout。

Layout的实现比较简单，如SimpleLayout对一行日志信息只是打印日志级别信息以及日志信息。

关于Layout更详细的信息将会在以后小节中介绍。

Appender接口

Appender负责定义日志输出的目的地，它可以是控制台（ConsoleAppender）、文件（FileAppender）、JMS服务器（JmsLogAppender）、以Email的形式发送出去（SMTPAppender）等。Appender是一个命名的实体，另外它还包含了对Layout、ErrorHandler、Filter等引用：

简单的，在配置文件中，Appender会注册到Logger中，Logger在写日志时，通过继承机制遍历所有注册到它本身和其父节点的Appender（在additivity为true的情况下），调用doAppend()方法，实现日志的写入。在doAppend方法中，若当前Appender注册了Filter，则doAppend还会判断当前日志时候通过了Filter的过滤，通过了Filter的过滤后，如果当前Appender继承自SkeletonAppender，还会检查当前日志级别时候要比当前Appender本身的日志级别阀门要打，所有这些都通过后，才会将LoggingEvent实例传递给Layout实例以格式化成一行日志信息，最后写入相应的目的地，在这些操作中，任何出现的错误都由ErrorHandler字段来处理。

SkeletonAppender类

目前Log4J实现的Appender都继承自SkeletonAppender类，该类对Appender接口提供了最基本的实现，并且引入了Threshold的概念，即所有的比当前Appender定义的日志级别阀指要大的日志才会记录下来。

SkeletonAppender实现了doAppend()方法，它首先检查日志级别是否要比threshold要大；然后如果注册了Filter，则使用Filter对LoggingEvent实例进行过滤，如果Filter返回Filter.DENY则doAppend()退出，否则执行append()方法，该方法由子类实现。

在Log4J中，Filter组成一条链，它定了以decide()方法，由子类实现，若返回DENY则日志不会被记录、NEUTRAL则继续检查下一个Filter实例、ACCEPT则Filter通过，继续执行后面的写日志操作。使用Filter可以为Appender加入一些出了threshold以外的其他逻辑，由于它本身是链状的，而且它的执行是横跨在Appender的doAppend方法中，因而这也是一个典型的AOP的概念。Filter的实现将会在下一小节中讲解。

SkeletonAppender还重写了finalize()方法，这是因为Log4J本身作为一个组件，它可能还是通过其他组件如commons-logging或slf4j组件间接的引入，因而使用它的程序不应该对它存在依赖的，然而在程序退出之前所有的Appender需要调用close()方法以释放它所占据的资源，为了不在使用Log4J的程序手动的close()的方法，以减少Log4J代码的侵入性，因而Log4J将close()的方法调用加入到finalize()方法中，即在垃圾回收器回收Appender实例时就会调用它的close()方法。

WriterAppender类和ConsoleAppender类

WriterAppender将日志写入Java IO中，它继承自SkeletonAppender类。它引入了三个字段：immediateFlush，指定没写完一条日志后，即将日志内容刷新到设备中，虽然这么做会有一点性能上的损失，但是如果不怎么做，则会出现在程序异常终止的时候无法看到部分日志信息，而经常这些丢失的日志信息要用于分析为什么会出现异常终止的情况，因而一般推荐将该值设置为true，即默认值；econding用于定义日志文本的编码方式；qw定义写日志的writer，它可以是文件或是控制台等Java IO支持的流。

在写日志文本前，WriterAppender还会做其他检查，如该Appender不能已经closed、qw和layout必须有值等，而后才可以将layout格式化后的日志行写入设备中。若layout本身不处理异常问题，则有Appender处理异常问题。最后如果每行日志需要刷新，则调用刷新操作。

ConsoleAppender继承自WriterAppender，它只是简单的将System.out或System.err实例传递给WriterAppender以构建相应的writer，最后实现将日志写入到控制台中。

Filter类

在Log4J中，Filter组成一条链，它定了以decide()方法，由子类实现，若返回DENY则日志不会被记录、NEUTRAL则继续检查下一个Filter实例、ACCEPT则Filter通过，继续执行后面的写日志操作。使用Filter可以为Appender加入一些出了threshold以外的其他逻辑，由于它本身是链状的，而且它的执行是横跨在Appender的doAppend方法中，因而这也是一个典型的AOP的概念。

Log4J本身提供了四个Filter：DenyAllFilter、LevelMatchFilter、LevelRangeFilter、StringMatchFilter。

DenyAllFilter只是简单的在decide()中返回DENY值，可以将其应用在Filter链尾，实现如果之前的Filter都没有通过，则该LoggingEvent没有通过，类似或的操作：

StringMatchFilter通过日志消息中的字符串来判断Filter后的状态：

LevelMatchFilter判断日志级别是否和设置的级别匹配以决定Filter后的状态：

LevelRangeFilter判断日志级别是否在设置的级别范围内以决定Filter后的状态：

总结

这一系列终于是结束了。本文主要介绍了Log4J核心类的实现和他们之间的交互关系。涉及到各个模块本身的其他详细信息将会在接下来的小节中详细介绍，如LogRepository与配置信息、Appender类结构的详细信息、Layout类结构的详细信息以及部分LoggingEvent提供的高级功能。而像Level、Logger本身，由于内容不多，已经在这一小节中全部介绍完了。