Log4j源码解析--核心类解析

时间 2019-11-13

标签 log4j log 源码解析核心栏目 Log4j 繁體版

原文原文链接

原文出处：http://www.blogjava.net/DLevin/archive/2012/06/28/381667.html。感谢上善若水的无私分享。html

在简单的介绍了Log4J各个模块类的做用后，如下将详细的介绍各个模块的具体做用以及代码实现。java

Logger类

Logger是对记录日志动做的抽象，它提供了记录不一样级别日志的接口，日志信息能够包含异常信息也能够不包含：apache

1 public void debug(Object message) {
2      if (isLevelEnabled(Level.DEBUG)) {
3         forceLog(FQCN, Level.DEBUG, message, null );
4     }
5 }
6 public void debug(Object message, Throwable cause) {
7      if (isLevelEnabled(Level.DEBUG)) {
8         forceLog(FQCN, Level.DEBUG, message, cause);
9     }
10 }
11 protected void forceLog(String fqcn, Level level, Object message, Throwable t) {
12     callAppenders( new LoggingEvent(fqcn, this , level, message, t));
13 }

Logger类包含Level信息，若是当前Logger未设置Level值，它也能够中父节点中继承下来，该值能够用来控制该Logger能够记录的日志级别：数组

1 protected Level level;
2 public Level getEffectiveLevel() {
3      for (Logger logger = this ; logger != null ; logger = logger.parent) {
4          if (logger.level != null ) {
5              return logger.level;
6         }
7     }
8      return null ;
9 }
10 public boolean isLevelEnabled(Level level) {
11      return level.isGreaterOrEqual( this .getEffectiveLevel());
12 }
13 public boolean isDebugEnabled() {
14      return isLevelEnabled(Level.DEBUG);
15 }

Logger是一个命名的实体，其名字通常用”.”分割以体现不一样Logger的层次关系，其中Level和Appender信息能够从父节点中获取，于是Logger类中还具备name和parent属性。服务器

1 private String name;
2 protected Logger parent;

在某些状况下，咱们但愿某些Logger只将日志记录到特定的Appender中，而不想记录在父节点中的Appender中，Log4J为这种需求提供了additivity属性，即对当前Logger节点，若是其additivity属性设置为false，则该Logger不会继承父节点的Appender信息，可是其子节点依然会继承该Logger的Appender信息，除非子节点的additivity属性也设置成了false。app

1 private boolean additive = true ;
2 public void callAppenders(LoggingEvent event) {
3      int writes = 0 ;
4
5      for (Logger logger = this ; logger != null ; logger = logger.parent) {
6          synchronized (logger) {
7              if (logger.appenders != null ) {
8                 writes += logger.appenders.appendLoopOnAppenders(event);
9             }
10              if ( ! logger.additive) {
11                  break ;
12             }
13         }
14     }
15
16      if (writes == 0 ) {
17         System.err.println( " No Appender is configed. " );
18     }
19 }

最后，为了支持国际化，Log4J还提供了两个l7dlog()方法，经过指定的key，以从资源文件中获取消息内容。为了使用这两个方法，须要设置资源文件。一样，资源文件也是能够从父节点中继承的。ide

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 }

另外，在实际开发中常常会遇到要把日志信息同时写到不一样地方，如同时写入文件和控制台，于是一个Logger实例中能够包含多个Appender，为了管理多个Appender，Log4J抽象出了AppenderAttachable接口，它定义了几个用于管理多个Appender实例的方法，这些方法由AppenderAttachableImpl类实现，而Logger会实例化AppenderAttachableImpl，并将这些方法代理给该实例：oop

1 public interface AppenderAttachable {
2      public void addAppender(Appender newAppender);
3      public Enumeration getAllAppenders();
4      public Appender getAppender(String name);
5      public boolean isAttached(Appender appender);
6      void removeAllAppenders();
7      void removeAppender(Appender appender);
8      void removeAppender(String name);
9 }

RootLogger类

在 Log4J 中，全部 Logger 实例组成一个单根的树状结构，因为 Logger 实例的根节点有一点特殊：它的名字为“ root ”，它没有父节点，它的 Level 字段必须设值以防止其余 Logger 实例都没有设置 Level 值的状况。基于这些考虑， Log4J 经过继承 Logger 类实现了 RootLogger 类，它用于表达全部 Logger 实例的根节点：

1 public final class RootLogger extends Logger {
2      public RootLogger(Level level) {
3          super ( " root " );
4         setLevel(level);
5     }
6      public final Level getChainedLevel() {
7          return level;
8     }
9      public final void setLevel(Level level) {
10          if (level == null ) {
11             LogLog.error( " You have tried to set a null level to root. " ,
12                      new Throwable());
13         } else {
14              this .level = level;
15         }
16     }
17 }

NOPLogger类

有时候，为了测试等其余需求，咱们但愿Logger自己不作什么事情，Log4J为这种需求提供了NOPLogger类，它继承自Logger，可是基本上的方法都为空。性能

Level类

Level是对日志级别的抽象，目前Log4J支持的级别有FATAL、ERROR、WARN、INFO、DEBUG、TRACE，从头至尾一次级别递减，另外Log4J还支持两种特殊的级别：ALL和OFF，它们分别表示打开和关闭日志功能。测试

1 public static final int OFF_INT = Integer.MAX_VALUE;
2 public static final int FATAL_INT = 50000 ;
3 public static final int ERROR_INT = 40000 ;
4 public static final int WARN_INT = 30000 ;
5 public static final int INFO_INT = 20000 ;
6 public static final int DEBUG_INT = 10000 ;
7 public static final int TRACE_INT = 5000 ;
8 public static final int ALL_INT = Integer.MIN_VALUE;
9
10 public static final Level OFF = new Level(OFF_INT, " OFF " , 0 );
11 public static final Level FATAL = new Level(FATAL_INT, " FATAL " , 0 );
12 public static final Level ERROR = new Level(ERROR_INT, " ERROR " , 3 );
13 public static final Level WARN = new Level(WARN_INT, " WARN " , 4 );
14 public static final Level INFO = new Level(INFO_INT, " INFO " , 6 );
15 public static final Level DEBUG = new Level(DEBUG_INT, " DEBUG " , 7 );
16 public static final Level TRACE = new Level(TRACE_INT, " TRACE " , 7 );
17 public static final Level ALL = new Level(ALL_INT, " ALL " , 7 );

每一个Level实例包含了该Level表明的int值（通常是从级别低到级别高一次增大）、该Level的String表达、该Level和系统Level的对应值。

1 protected transient int level;
2 protected transient String levelStr;
3 protected transient int syslogEquivalent;
4 protected Level( int level, String levelStr, int syslogEquivalent) {
5      this .level = level;
6      this .levelStr = levelStr;
7      this .syslogEquivalent = syslogEquivalent;
8 }

Level类主要提供了判断哪一个Level级别更高的方法isGreaterOrEqual()以及将int值或String值转换成Level实例的toLevel()方法：

1 public boolean isGreaterOrEqual(Level level) {
2      return this .level >= level.level;
3 }
4 public static Level toLevel( int level) {
5      return toLevel(level, DEBUG);
6 }
7 public static Level toLevel( int level, Level defaultLevel) {
8      switch (level) {
9          case OFF_INT: return OFF;
10          case FATAL_INT: return FATAL;
11          case ERROR_INT: return ERROR;
12          case WARN_INT: return WARN;
13          case INFO_INT: return INFO;
14          case DEBUG_INT: return DEBUG;
15          case TRACE_INT: return TRACE;
16          case ALL_INT: return ALL;
17     }
18      return defaultLevel;
19 }

另外，因为对相同级别的Level实例来讲，它必须是单例的，于是Log4J对序列化和反序列化作了一些处理。即它的三个成员都是transient，真正序列化和反序列化的代码本身写，而且加入readResolve()方法的支持，以保证反序列化出来的相同级别的Level实例是相同的实例。

1 private void readObject( final ObjectInputStream input) throws IOException, ClassNotFoundException {
2     input.defaultReadObject();
3     level = input.readInt();
4     syslogEquivalent = input.readInt();
5     levelStr = input.readUTF();
6      if (levelStr == null ) {
7         levelStr = "" ;
8     }
9 }
10 private void writeObject( final ObjectOutputStream output) throws IOException {
11     output.defaultWriteObject();
12     output.writeInt(level);
13     output.writeInt(syslogEquivalent);
14     output.writeUTF(levelStr);
15 }
16 private Object readResolve() throws ObjectStreamException {
17      if ( this .getClass() == Level. class ) {
18          return toLevel(level);
19     }
20      return this ;
21 }

若是要实现本身的Level类，能够继承自Level，而且实现相应的静态toLevel()方法便可。关于如何实现本身的Level类将会在配置文件相关小节中详细讨论。

LoggerRepository类

LoggerRepository从概念以及字面上来讲它就是一个Logger实例的容器：一方面相同名字的Logger实例只须要建立一次，在后面的使用中，只须要从这个容器中取便可；另外一方面，Logger容器能够存放从配置文件中解析出来的信息，从而使配置信息能够无缝的应用到Log4J内部系统中；最后Logger容器还为维护Logger的树状层次结构提供了方面，每一个Logger只维护父节点的信息，有了Logger容器的存在则能够很容易的找到一个新的Logger实例的父节点；关于Logger容器将在下一节中详细讲解。

LoggingEvent类

LoggingEvent我的感受用LoggingContext更合适一些，它是对一第二天志记录时哪能获取到的数据的封装。它包含了如下信息以提供Layout在format()方法中使用：

1. fqnOfCategoryClass：日志记录接口（默认为Logger）的类全名，该信息主要用于计算日志记录点的源文件、调用方法以及行号等位置信息。

2. locationInfo：经过fqnOfCategoryClass计算位置信息，位置信息的计算由LocationInfo类实现，这些信息能够提供给Layout使用。

3. logger：目前来看主要是经过Logger实例取得LogRepository实例，并经过LogRepository取得注册的ObjectRender实例，若是有的话。

4. loggerName：当前日志记录的Logger名称，提供给Layout使用。

5. threadName：当前线程名，提供给Layout使用。

6. level：当前日志的级别，提供给Layout使用。

7. message：当前日志类，通常是String类型，可是也能够经过注册ObjectRender，而后传入相应的其余对象类型。

8. renderedMessage：通过ObjectRender处理后的日志信息，提供给Layout使用。

9. throwableInfo：异常信息，若是存在的话，提供给Layout使用。

10. timestamp：建立LoggingEvent实例的时间，提供给Layout使用。

11. 其余相对不经常使用的信息将会在后面小节中讲解。

LoggingEvent只是一个简单的数据对象（DO），于是其实现仍是比较简单的，即在建立实例时将数据提供给它，在其余类（Layout等）使用它时经过getXXX()方法取数据。不过仍是有几个方法能够简单的讲解一下。

LocationInfo类计算位置信息

LocationInfo所指的位置信息主要包括记录日志所在的源文件名、类名、方法名、所在源文件的行号。

1      transient String lineNumber;
2      transient String fileName;
3      transient String className;
4      transient String methodName;
5 // fully.qualified.classname.of.caller.methodName(Filename.java:line)
6      public String fullInfo;

咱们知道在异常栈中每一条记录都包含了方法调用对应的这些信息，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);

fileName:

1
2 int iend = fullInfo.lastIndexOf( ' : ' );
3 if (iend == - 1 )
4     fileName = NA;
5 else {
6      int ibegin = fullInfo.lastIndexOf( ' ( ' , iend - 1 );
7     fileName = this .fullInfo.substring(ibegin + 1 , iend);
8 }

lineNumber:

1 int iend = fullInfo.lastIndexOf( ' ) ' );
2 int ibegin = fullInfo.lastIndexOf( ' : ' , iend - 1 );
3 if (ibegin == - 1 )
4 lineNumber = NA;
5 else
6 lineNumber = this .fullInfo.substring(ibegin + 1 , iend);

methodName:

1 int iend = fullInfo.lastIndexOf( ' ( ' );
2 int ibegin = fullInfo.lastIndexOf( ' . ' , iend);
3 if (ibegin == - 1 )
4 methodName = NA;
5 else
6 methodName = this .fullInfo.substring(ibegin + 1 , iend);

ObjectRender接口

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

1 public Object getMessage() {
2      if (message != null ) {
3          return message;
4     } else {
5          return getRenderedMessage();
6     }
7 }
8 public String getRenderedMessage() {
9      if (renderedMessage == null && message != null ) {
10          if (message instanceof String)
11             renderedMessage = (String) message;
12          else {
13             LoggerRepository repository = logger.getLoggerRepository();
14
15              if (repository instanceof RendererSupport) {
16                 RendererSupport rs = (RendererSupport) repository;
17                 renderedMessage = rs.getRendererMap()
18                         .findAndRender(message);
19             } else {
20                 renderedMessage = message.toString();
21             }
22         }
23     }
24      return renderedMessage;
25 }

ThrowableInformation类

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

1 if (throwable != null ) {
2      this .throwableInfo = new ThrowableInformation(throwable, logger);
3 }
4 ThrowableRenderer renderer = null ;
5 if (category != null ) {
6     LoggerRepository repo = category.getLoggerRepository();
7      if (repo instanceof ThrowableRendererSupport) {
8         renderer = ((ThrowableRendererSupport) repo)
9                 .getThrowableRenderer();
10     }
11 }
12 if (renderer == null ) {
13     rep = DefaultThrowableRenderer.render(throwable);
14 } else {
15     rep = renderer.doRender(throwable);
16 }
17 public static String[] render( final Throwable throwable) {
18     StringWriter sw = new StringWriter();
19     PrintWriter pw = new PrintWriter(sw);
20      try {
21         throwable.printStackTrace(pw);
22     } catch (RuntimeException ex) {
23     }
24     pw.flush();
25     LineNumberReader reader = new LineNumberReader( new StringReader(
26             sw.toString()));
27     ArrayList lines = new ArrayList();
28      try {
29         String line = reader.readLine();
30          while (line != null ) {
31             lines.add(line);
32             line = reader.readLine();
33         }
34     } catch (IOException ex) {
35          if (ex instanceof InterruptedIOException) {
36             Thread.currentThread().interrupt();
37         }
38         lines.add(ex.toString());
39     }
40     String[] tempRep = new String[lines.size()];
41     lines.toArray(tempRep);
42      return tempRep;
43 }

Layout类

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

1 public abstract class Layout implements OptionHandler {
2      public final static String LINE_SEP = System.getProperty( " line.separator " );
3      public final static int LINE_SEP_LEN = LINE_SEP.length();
4      abstract public String format(LoggingEvent event);
5      public String getContentType() {
6          return " text/plain " ;
7     }
8      public String getHeader() {
9          return null ;
10     }
11      public String getFooter() {
12          return null ;
13     }
14      abstract public boolean ignoresThrowable();
15 }

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

1 public class SimpleLayout extends Layout {
2     StringBuffer sbuf = new StringBuffer( 128 );
3      public SimpleLayout() {
4     }
5      public void activateOptions() {
6     }
7      public String format(LoggingEvent event) {
8         sbuf.setLength( 0 );
9         sbuf.append(event.getLevel().toString());
10         sbuf.append( " - " );
11         sbuf.append(event.getRenderedMessage());
12         sbuf.append(LINE_SEP);
13          return sbuf.toString();
14     }
15      public boolean ignoresThrowable() {
16          return true ;
17     }
18 }

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

Appender接口

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

1 public interface Appender {
2      void addFilter(Filter newFilter);
3      public Filter getFilter();
4      public void clearFilters();
5      public void close();
6      public void doAppend(LoggingEvent event);
7      public String getName();
8      public void setErrorHandler(ErrorHandler errorHandler);
9      public ErrorHandler getErrorHandler();
10      public void setLayout(Layout layout);
11      public Layout getLayout();
12      public void setName(String name);
13      public boolean requiresLayout();
14 }

简单的，在配置文件中，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定义的日志级别阀指要大的日志才会记录下来。

1 public abstract class AppenderSkeleton implements Appender, OptionHandler {
2      protected Layout layout;
3      protected String name;
4      protected Priority threshold;
5      protected ErrorHandler errorHandler = new OnlyOnceErrorHandler();
6      protected Filter headFilter;
7      protected Filter tailFilter;
8      protected boolean closed = false ;
9      public AppenderSkeleton() {
10          super ();
11     }
12      public void activateOptions() {
13     }
14      abstract protected void append(LoggingEvent event);
15      public boolean isAsSevereAsThreshold(Priority priority) {
16          return ((threshold == null ) || priority.isGreaterOrEqual(threshold));
17     }
18      public synchronized void doAppend(LoggingEvent event) {
19          if (closed) {
20             LogLog.error( " Attempted to append to closed appender named [ "
21                      + name + " ]. " );
22              return ;
23         }
24          if ( ! isAsSevereAsThreshold(event.getLevel())) {
25              return ;
26         }
27         Filter f = this .headFilter;
28         FILTER_LOOP: while (f != null ) {
29              switch (f.decide(event)) {
30              case Filter.DENY:
31                  return ;
32              case Filter.ACCEPT:
33                  break FILTER_LOOP;
34              case Filter.NEUTRAL:
35                 f = f.getNext();
36             }
37         }
38          this .append(event);
39     }
40 public void finalize() {
41          if ( this .closed)
42              return ;
43         LogLog.debug( " Finalizing appender named [ " + name + " ]. " );
44         close();
45     }
46 }

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处理异常问题。最后若是每行日志须要刷新，则调用刷新操做。

1 public class WriterAppender extends AppenderSkeleton {
2      protected boolean immediateFlush = true ;
3      protected String encoding;
4      protected QuietWriter qw;
5      public WriterAppender() {
6     }
7      public WriterAppender(Layout layout, OutputStream os) {
8          this (layout, new OutputStreamWriter(os));
9     }
10      public WriterAppender(Layout layout, Writer writer) {
11          this .layout = layout;
12          this .setWriter(writer);
13     }
14      public void append(LoggingEvent event) {
15          if ( ! checkEntryConditions()) {
16              return ;
17         }
18         subAppend(event);
19     }
20      protected boolean checkEntryConditions() {
21          if ( this .closed) {
22             LogLog.warn( " Not allowed to write to a closed appender. " );
23              return false ;
24         }
25          if ( this .qw == null ) {
26             errorHandler
27                     .error( " No output stream or file set for the appender named [ "
28                              + name + " ]. " );
29              return false ;
30         }
31          if ( this .layout == null ) {
32             errorHandler.error( " No layout set for the appender named [ " + name
33                      + " ]. " );
34              return false ;
35         }
36          return true ;
37     }
38      protected void subAppend(LoggingEvent event) {
39          this .qw.write( this .layout.format(event));
40          if (layout.ignoresThrowable()) {
41             String[] s = event.getThrowableStrRep();
42              if (s != null ) {
43                  int len = s.length;
44                  for ( int i = 0 ; i < len; i ++ ) {
45                      this .qw.write(s[i]);
46                      this .qw.write(Layout.LINE_SEP);
47                 }
48             }
49         }
50          if (shouldFlush(event)) {
51              this .qw.flush();
52         }
53     }
54      public boolean requiresLayout() {
55          return true ;
56     }
57 }

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

Filter类

1 public abstract class Filter implements OptionHandler {
2      public Filter next;
3      public static final int DENY = - 1 ;
4      public static final int NEUTRAL = 0 ;
5      public static final int ACCEPT = 1 ;
6      public void activateOptions() {
7     }
8      abstract public int decide(LoggingEvent event);
9      public void setNext(Filter next) {
10          this .next = next;
11     }
12      public Filter getNext() {
13          return next;
14     }
15 }

Log4J自己提供了四个Filter：DenyAllFilter、LevelMatchFilter、LevelRangeFilter、StringMatchFilter。

DenyAllFilter只是简单的在decide()中返回DENY值，能够将其应用在Filter链尾，实现若是以前的Filter都没有经过，则该LoggingEvent没有经过，相似或的操做：

1 public class DenyAllFilter extends Filter {
2      public int decide(LoggingEvent event) {
3          return Filter.DENY;
4     }
5 }

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

1 public class StringMatchFilter extends Filter {
2      boolean acceptOnMatch = true ;
3     String stringToMatch;
4      public int decide(LoggingEvent event) {
5         String msg = event.getRenderedMessage();
6          if (msg == null || stringToMatch == null )
7              return Filter.NEUTRAL;
8          if (msg.indexOf(stringToMatch) == - 1 ) {
9              return Filter.NEUTRAL;
10         } else { // we've got a match
11              if (acceptOnMatch) {
12                  return Filter.ACCEPT;
13             } else {
14                  return Filter.DENY;
15             }
16         }
17     }
18 }

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

1 public class LevelMatchFilter extends Filter {
2      boolean acceptOnMatch = true ;
3 Level levelToMatch;
4      public int decide(LoggingEvent event) {
5          if ( this .levelToMatch == null ) {
6              return Filter.NEUTRAL;
7         }
8          boolean matchOccured = false ;
9          if ( this .levelToMatch.equals(event.getLevel())) {
10             matchOccured = true ;
11         }
12          if (matchOccured) {
13              if ( this .acceptOnMatch)
14                  return Filter.ACCEPT;
15              else
16                  return Filter.DENY;
17         } else {
18              return Filter.NEUTRAL;
19         }
20     }
21 }

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

1 public class LevelRangeFilter extends Filter {
2      boolean acceptOnMatch = false ;
3     Level levelMin;
4     Level levelMax;
5      public int decide(LoggingEvent event) {
6          if ( this .levelMin != null ) {
7              if (event.getLevel().isGreaterOrEqual(levelMin) == false ) {
8                  return Filter.DENY;
9             }
10         }
11          if ( this .levelMax != null ) {
12              if (event.getLevel().toInt() > levelMax.toInt()) {
13                  return Filter.DENY;
14             }
15         }
16          if (acceptOnMatch) {
17              return Filter.ACCEPT;
18         } else {
19              return Filter.NEUTRAL;
20         }
21     }
22 }

总结

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