Fork me on GitHub

Logback日志框架

字数统计: 5.8k字   |   阅读时长≈ 31分

Logback

logback由log4j创始人设计的另一个开源日志框架，性能高于log4j

logback-core ：其他两个模块的基础模块

logback-classic ：他是log4j的一个改良版本，同时他完整实现了slf4j的api

logback-access：访问模块与servlet容器集成提供通过http来访问日志的功能

pom.xml

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

<dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>

    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

因为logback 是按slf4j来实现的，所以

工厂获取

初始化
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
   private static Object KEY = new Object();

    static {
        SINGLETON.init();
    }

   private LoggerContext defaultLoggerContext = new LoggerContext();
void init() {
        try {
            try {
                //引入配置，ContextInitializer去引入，配置与工厂获取分离
                new ContextInitializer(defaultLoggerContext).autoConfig();
            } catch (JoranException je) {
                Util.report("Failed to auto configure default logger context", je);
            }
            // logback-292
            if (!StatusUtil.contextHasStatusListener(defaultLoggerContext)) {
                StatusPrinter.printInCaseOfErrorsOrWarnings(defaultLoggerContext);
            }
            //这里的logger工厂变成了  loggerContext
           //这里借助log4j思想 引入一个 策略接口来  包装具体的 logger工厂
            contextSelectorBinder.init(defaultLoggerContext, KEY);
            initialized = true;
        } catch (Exception t) { // see LOGBACK-1159
            Util.report("Failed to instantiate [" + LoggerContext.class.getName() + "]", t);
        }
    }
获取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
StaticLoggerBinder.getSingleton().getLoggerFactory();
 
 private static StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }



public ILoggerFactory getLoggerFactory() {
        if (!initialized) {
            return defaultLoggerContext;
        }

        if (contextSelectorBinder.getContextSelector() == null) {
            throw new IllegalStateException("contextSelector cannot be null. See also " + NULL_CS_URL);
        }
       //最终使用的还是defaultLoggerContext作为logger的工厂
        return contextSelectorBinder.getContextSelector().getLoggerContext();
    }

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
   public LoggerContext() {
        super();
       //使用的ConcurrentHashMap，而不是传统的hashtable
        this.loggerCache = new ConcurrentHashMap，而不是传统的hashtable<String, Logger>();

       //扩展一个logger工厂，作为远程视图
        this.loggerContextRemoteView = new LoggerContextVO(this);
       //初始化根logger
        this.root = new Logger(Logger.ROOT_LOGGER_NAME, null, this);
       //根级别 初始为debug
        this.root.setLevel(Level.DEBUG);
       //缓存
        loggerCache.put(Logger.ROOT_LOGGER_NAME, root);
        initEvaluatorMap();
        size = 1;
        this.frameworkPackages = new ArrayList<String>();
    }

//初始化评估映射
void initEvaluatorMap() {
        putObject(EVALUATOR_MAP, new HashMap<String, EventEvaluator<?>>());
    }


public ContextBase() {
        //初始化碰撞集合
        initCollisionMaps();
    }
  protected void initCollisionMaps() {
        putObject(FA_FILENAME_COLLISION_MAP, new HashMap<String, String>());
        putObject(RFA_FILENAME_PATTERN_COLLISION_MAP, new HashMap<String, FileNamePattern>());
    }
获取
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
public final Logger getLogger(final String name) {

       if (name == null) {
           throw new IllegalArgumentException("name argument cannot be null");
       }

       // if we are asking for the root logger, then let us return it without
       // wasting time
       if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) {
           return root;
       }

       int i = 0;
       Logger logger = root;

       // check if the desired logger exists, if it does, return it
       // without further ado.
       Logger childLogger = (Logger) loggerCache.get(name);
       // if we have the child, then let us return it without wasting time
       if (childLogger != null) {
           return childLogger;
       }

    ----下面是第一次初始化自定义logger----
       ---logger = root;
    -----childLogger=null
    
       // if the desired logger does not exist, them create all the loggers
       // in between as well (if they don't already exist)
       String childName;
       while (true) {
           //循环直到父到子logger都创建完毕
           int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
           if (h == -1) {
               childName = name;
           } else {
               childName = name.substring(0, h);
           }
           // move i left of the last point
           i = h + 1;
           synchronized (logger) {
               //获取此logger的子logger名字与指定名字相匹配的
               childLogger = logger.getChildByName(childName);
               if (childLogger == null) {
                   //Logger内部提供一个工厂方法来创建自己 ，顺便把当前新创建logger加到调用创建方法的logger的子链中
                   childLogger = logger.createChildByName(childName);
                    //放入缓存
                   loggerCache.put(childName, childLogger);
                   incSize();
               }
           }
           logger = childLogger;
           if (h == -1) {
               return childLogger;
           }
       }
   }

执行

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
    public void error(String msg) {
        filterAndLog_0_Or3Plus(FQCN, null, Level.ERROR, msg, null, null);
    }


    private void filterAndLog_0_Or3Plus(final String localFQCN, final Marker marker, final Level level, final String msg, final Object[] params,
                    final Throwable t) {

        //filter处理
        final FilterReply decision = loggerContext.getTurboFilterChainDecision_0_3OrMore(marker, this, level, msg, params, t);

        if (decision == FilterReply.NEUTRAL) {
            if (effectiveLevelInt > level.levelInt) {
                return;
            }
        } else if (decision == FilterReply.DENY) {
            return;
        }
//构建事件日志和输出
        buildLoggingEventAndAppend(localFQCN, marker, level, msg, params, t);
    }



 private void buildLoggingEventAndAppend(final String localFQCN, final Marker marker, final Level level, final String msg, final Object[] params,
                    final Throwable t) {
        LoggingEvent le = new LoggingEvent(localFQCN, this, level, msg, t, params);
        le.setMarker(marker);
     //调用所有的处理器
        callAppenders(le);
    }


 public void callAppenders(ILoggingEvent event) {
        int writes = 0;
        for (Logger l = this; l != null; l = l.parent) {
            writes += l.appendLoopOnAppenders(event);
            if (!l.additive) {
                break;
            }
        }
        // No appenders in hierarchy
        if (writes == 0) {
            loggerContext.noAppenderDefinedWarning(this);
        }
    }


 private int appendLoopOnAppenders(ILoggingEvent event) {
     //    transient private AppenderAttachableImpl<ILoggingEvent> aai;
        if (aai != null) {
            return aai.appendLoopOnAppenders(event);
        } else {
            return 0;
        }
    }
/*
 AppenderAttachableImpl<ILoggingEvent> aai 初始化在添加第一个appender时
   public synchronized void addAppender(Appender<ILoggingEvent> newAppender) {
        if (aai == null) {
            aai = new AppenderAttachableImpl<ILoggingEvent>();
        }
        aai.addAppender(newAppender);
    }

*/
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
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
134
135
136
137
138
synchronized线程同步，，子类重写此方法需要保证线程同步
 public synchronized void doAppend(E eventObject) {
        //警告：保护检查必须是doAppend（）方法中的第一个语句。

        // 防止再次进入。
        if (guard) {
           // 这个保护防止appender重复调用它自己的doAppend方法。
            return;
        }

        try {
            guard = true;

            if (!this.started) {
                if (statusRepeatCount++ < ALLOWED_REPEATS) {
                    addStatus(new WarnStatus("Attempted to append to non started appender [" + name + "].", this));
                }
                return;
            }
			//appender过滤器过滤
            if (getFilterChainDecision(eventObject) == FilterReply.DENY) {
                return;
            }

            // 好的，我们现在调用派生类的append实现
            //子类都来实现这个方法就行
            this.append(eventObject);

        } catch (Exception e) {
            if (exceptionCount++ < ALLOWED_REPEATS) {
                addError("Appender [" + name + "] failed to append.", e);
            }
        } finally {
            guard = false;
        }
    }



//这是多线程首选的，保证多个线程使用同一个logger调用处理方法时出会造成资源抢占
//但是 this.append(eventObject); 这个方法子类实现必须同步
//UnsynchronizedAppenderBase 衍生appender程序  （不需要处理自己的线程同步）因为所有的事件都是一个线程在处理。
 public void doAppend(E eventObject) {
        // WARNING: The guard check MUST be the first statement in the
        // doAppend() method.

        // prevent re-entry.
        if (Boolean.TRUE.equals(guard.get())) {
            return;
        }

        try {
            guard.set(Boolean.TRUE);

            if (!this.started) {
                if (statusRepeatCount++ < ALLOWED_REPEATS) {
                    addStatus(new WarnStatus("Attempted to append to non started appender [" + name + "].", this));
                }
                return;
            }

            if (getFilterChainDecision(eventObject) == FilterReply.DENY) {
                return;
            }

            // ok, we now invoke derived class' implementation of append
            this.append(eventObject);

        } catch (Exception e) {
            if (exceptionCount++ < ALLOWED_REPEATS) {
                addError("Appender [" + name + "] failed to append.", e);
            }
        } finally {
            guard.set(Boolean.FALSE);
        }
    }





异步append
    
    注意异步的appender重在一个事件循环，所以它可以添加其他的appender
    protected void append(E eventObject) {
        if (isQueueBelowDiscardingThreshold() && isDiscardable(eventObject)) {
            return;
        }
        preprocess(eventObject);
        put(eventObject);
    }


    

 protected void preprocess(ILoggingEvent eventObject) {
        eventObject.prepareForDeferredProcessing();
        if (includeCallerData)
            eventObject.getCallerData();
    }



    private void put(E eventObject) {
        if (neverBlock) {
            blockingQueue.offer(eventObject);
        } else {
            putUninterruptibly(eventObject);
        }
    }




public void run() {
            AsyncAppenderBase<E> parent = AsyncAppenderBase.this;
            AppenderAttachableImpl<E> aai = parent.aai;

            // loop while the parent is started
            while (parent.isStarted()) {
                try {
                   // 就是无限取事件拿出来消费
                    E e = parent.blockingQueue.take();
                    aai.appendLoopOnAppenders(e);
                } catch (InterruptedException ie) {
                    break;
                }
            }

            addInfo("Worker thread will flush remaining events before exiting. ");

            for (E e : parent.blockingQueue) {
                aai.appendLoopOnAppenders(e);
                parent.blockingQueue.remove(e);
            }

            aai.detachAndStopAllAppenders();
        }

配置引入

默认加载 logback.groovy,logback-test.xml,logback.xml配置文件

关系

Logger：日志记录器，跟他关联到应用context，主要用于存放日志对象，定义类型，级别

appender：用于指定日志输出的目的地，可以时控制台，文件，数据库等，还有一个AsyncAppender它可以添加appender

Layout：负责把事件转换c成字符串，格式化输出，在logback中的layout被封装在encoder中

logback.xml配置文件
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

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
    配置集中管理属性
    可以直接使用属性的value
    格式 类似el表达式 ${name}
    -->
    <!--
    日志格式：
        %-5level 左对齐站5个字符，输出日志级别
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %C 类的完整名称
            %M 方法名
            %L 行号
        %thread  线程名
        %m或者%msg 消息
        %n 换行
    -->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %C %M %L - %m%n"></property>

    <property name="log_dir" value="F:/test"></property>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 把默认输出流 System.out 换成 System.err -->
        <target>System.err</target>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <file>${log_dir}/logback.log</file>
        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="html_file" class="ch.qos.logback.core.FileAppender">
        <file>${log_dir}/logback.html</file>
        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>${pattern}</pattern>
            </layout>
        </encoder>
    </appender>


    <!-- 把appender附加到指定的logger -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
        <appender-ref ref="html_file"></appender-ref>
    </root>

</configuration>
配置源码
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
public void autoConfig() throws JoranException {
        StatusListenerConfigHelper.installIfAsked(loggerContext);
        URL url = findURLOfDefaultConfigurationFile(true);
        if (url != null) {
            configureByResource(url);
        } else {
            
            //走默认配置，就是配置了一个consoleAppender
            Configurator c = EnvUtil.loadFromServiceLoader(Configurator.class);
            if (c != null) {
                try {
                    c.setContext(loggerContext);
                    c.configure(loggerContext);
                } catch (Exception e) {
                    throw new LogbackException(String.format("Failed to initialize Configurator: %s using ServiceLoader", c != null ? c.getClass()
                                    .getCanonicalName() : "null"), e);
                }
            } else {
                BasicConfigurator basicConfigurator = new BasicConfigurator();
                basicConfigurator.setContext(loggerContext);
                basicConfigurator.configure(loggerContext);
            }
        }
    }



  public URL findURLOfDefaultConfigurationFile(boolean updateStatus) {
        ClassLoader myClassLoader = Loader.getClassLoaderOfObject(this);
      //找自定义命名的配置文件
        URL url = findConfigFileURLFromSystemProperties(myClassLoader, updateStatus);
        if (url != null) {
            return url;
        }
//TEST_AUTOCONFIG_FILE = "logback-test.xml";
        url = getResource(TEST_AUTOCONFIG_FILE, myClassLoader, updateStatus);
        if (url != null) {
            return url;
        }
// GROOVY_AUTOCONFIG_FILE = "logback.groovy";
        url = getResource(GROOVY_AUTOCONFIG_FILE, myClassLoader, updateStatus);
        if (url != null) {
            return url;
        }
//final public static String AUTOCONFIG_FILE = "logback.xml";
        return getResource(AUTOCONFIG_FILE, myClassLoader, updateStatus);
    }



 public void configureByResource(URL url) throws JoranException {
     //判断资源类型，使用对应的加载器
        if (url == null) {
            throw new IllegalArgumentException("URL argument cannot be null");
        }
        final String urlString = url.toString();
        if (urlString.endsWith("groovy")) {
            if (EnvUtil.isGroovyAvailable()) {
                // avoid directly referring to GafferConfigurator so as to avoid
                // loading groovy.lang.GroovyObject . See also http://jira.qos.ch/browse/LBCLASSIC-214
                GafferUtil.runGafferConfiguratorOn(loggerContext, this, url);
            } else {
                StatusManager sm = loggerContext.getStatusManager();
                sm.add(new ErrorStatus("Groovy classes are not available on the class path. ABORTING INITIALIZATION.", loggerContext));
            }
        } else if (urlString.endsWith("xml")) {
            //抽出配置器配置具体格式的配置文件
            JoranConfigurator configurator = new JoranConfigurator();
            configurator.setContext(loggerContext);
            configurator.doConfigure(url);
        } else {
            throw new LogbackException("Unexpected filename extension of file [" + url.toString() + "]. Should be either .groovy or .xml");
        }
    }



public final void doConfigure(URL url) throws JoranException {
        InputStream in = null;
        try {
            //通知上下文用于配置的URL，添加一个watch来 查看资源文件的变动
            informContextOfURLUsedForConfiguration(getContext(), url);
            //
            URLConnection urlConnection = url.openConnection();
            urlConnection.setUseCaches(false);

            in = urlConnection.getInputStream();
            //配置
            doConfigure(in, url.toExternalForm());
        } catch (IOException ioe) {
            String errMsg = "Could not open URL [" + url + "].";
            addError(errMsg, ioe);
            throw new JoranException(errMsg, ioe);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException ioe) {
                    String errMsg = "Could not close input stream";
                    addError(errMsg, ioe);
                    throw new JoranException(errMsg, ioe);
                }
            }
        }
    }


 public final void doConfigure(InputStream inputStream, String systemId) throws JoranException {
     //包装流
        InputSource inputSource = new InputSource(inputStream);
        inputSource.setSystemId(systemId);
     //配置
        doConfigure(inputSource);
    }


 public final void doConfigure(final InputSource inputSource) throws JoranException {

        long threshold = System.currentTimeMillis();
        // if (!ConfigurationWatchListUtil.wasConfigurationWatchListReset(context)) {
        // informContextOfURLUsedForConfiguration(getContext(), null);
        // }
     //初始化一个记录器，这个记录拥有一个 有上下文意识（能够设置和获取logger上下文）的实现
        SaxEventRecorder recorder = new SaxEventRecorder(context);
     
     //记录事件
        recorder.recordEvents(inputSource);
     //消费事件
        doConfigure(recorder.saxEventList);
        // no exceptions a this level
        StatusUtil statusUtil = new StatusUtil(context);
        if (statusUtil.noXMLParsingErrorsOccurred(threshold)) {
            addInfo("Registering current configuration as safe fallback point");
            registerSafeConfiguration(recorder.saxEventList);
        }
    }


  public void doConfigure(final List<SaxEvent> eventList) throws JoranException {
     // 构建一个翻译员
        buildInterpreter();
        // disallow simultaneous configurations of the same context
        synchronized (context.getConfigurationLock()) {
            interpreter.getEventPlayer().play(eventList);
        }
    }


 protected void buildInterpreter() {
     //初始化一个简单的规则存储器
        RuleStore rs = new SimpleRuleStore(context);
     //然后把一些默认的规则安装到rs
        addInstanceRules(rs);
     //初始化一个翻译员，把规则，容器，环境路径放入
        this.interpreter = new Interpreter(context, rs, initialElementPath());
     下面两行有的多余
        InterpretationContext interpretationContext = interpreter.getInterpretationContext();
        interpretationContext.setContext(context);
     
     //添加隐式规则
     /*
     
       protected void addImplicitRules(Interpreter interpreter) {
        // The following line adds the capability to parse nested components
        NestedComplexPropertyIA nestedComplexPropertyIA = new NestedComplexPropertyIA(getBeanDescriptionCache());
        nestedComplexPropertyIA.setContext(context);
        interpreter.addImplicitAction(nestedComplexPropertyIA);

        NestedBasicPropertyIA nestedBasicIA = new NestedBasicPropertyIA(getBeanDescriptionCache());
        nestedBasicIA.setContext(context);
        interpreter.addImplicitAction(nestedBasicIA);
    }
     */
        addImplicitRules(interpreter);
     //添加 默认嵌套组件注册表规则 ，就是给interpretationContext.getDefaultNestedComponentRegistry()这个注册中心注册一些默认的规则组件
        addDefaultNestedComponentRegistryRules(interpretationContext.getDefaultNestedComponentRegistry());
    }
解析
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


    public List<SaxEvent> recordEvents(InputSource inputSource) throws JoranException {
        SAXParser saxParser = buildSaxParser();
        try {
            //这里解析出来，然后SaxEventRecorder也是处理器，最后解析出来的节点交给自己处理
            //SaxEventRecorder的处理就是包装成一个event放到saxEventList
            saxParser.parse(inputSource, this);
            return saxEventList;
        } catch (IOException ie) {
            handleError("I/O error occurred while parsing xml file", ie);
        } catch (SAXException se) {
            // Exception added into StatusManager via Sax error handling. No need to add it again
            throw new JoranException("Problem parsing XML document. See previously reported errors.", se);
        } catch (Exception ex) {
            handleError("Unexpected exception while parsing XML document.", ex);
        }
        throw new IllegalStateException("This point can never be reached");
    }
public void parse(InputSource is, DefaultHandler dh)
        throws SAXException, IOException {
        if (is == null) {
            throw new IllegalArgumentException();
        }
        if (dh != null) {
            xmlReader.setContentHandler(dh);
            xmlReader.setEntityResolver(dh);
            xmlReader.setErrorHandler(dh);
            xmlReader.setDTDHandler(dh);
            xmlReader.setDocumentHandler(null);
        }
        xmlReader.parse(is);
    }

public void parse(InputSource inputSource)
            throws SAXException, IOException {
            if (fSAXParser != null && fSAXParser.fSchemaValidator != null) {
                if (fSAXParser.fSchemaValidationManager != null) {
                    fSAXParser.fSchemaValidationManager.reset();
                    fSAXParser.fUnparsedEntityHandler.reset();
                }
                resetSchemaValidator();
            }
            super.parse(inputSource);
        }
处理
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
public void play(List<SaxEvent> aSaxEventList) {
        eventList = aSaxEventList;
        SaxEvent se;
        for (currentIndex = 0; currentIndex < eventList.size(); currentIndex++) {
            se = eventList.get(currentIndex);

            if (se instanceof StartEvent) {
                interpreter.startElement((StartEvent) se);
                // invoke fireInPlay after startElement processing
                interpreter.getInterpretationContext().fireInPlay(se);
            }
            if (se instanceof BodyEvent) {
                // invoke fireInPlay before characters processing
                interpreter.getInterpretationContext().fireInPlay(se);
                interpreter.characters((BodyEvent) se);
            }
            if (se instanceof EndEvent) {
                // invoke fireInPlay before endElement processing
                interpreter.getInterpretationContext().fireInPlay(se);
                interpreter.endElement((EndEvent) se);
            }

        }
    }


  private void startElement(String namespaceURI, String localName, String qName, Attributes atts) {
    主要栈压入
        String tagName = getTagName(localName, qName);
        elementPath.push(tagName);

        if (skip != null) {
            // every startElement pushes an action list
            pushEmptyActionList();
            return;
        }
//找到指定标签 所有能够匹配 的action
      //例如appender就使用 appenderAction处理
        List<Action> applicableActionList = getApplicableActionList(elementPath, atts);
        if (applicableActionList != null) {
            actionListStack.add(applicableActionList);
            callBeginAction(applicableActionList, tagName, atts);
        } else {
            // every startElement pushes an action list
            pushEmptyActionList();
            String errMsg = "no applicable action for [" + tagName + "], current ElementPath  is [" + elementPath + "]";
            cai.addError(errMsg);
        }
    }


 private void endElement(String namespaceURI, String localName, String qName) {
           主要是栈弹出
        // given that an action list is always pushed for every startElement, we
        // need
        // to always pop for every endElement
        List<Action> applicableActionList = (List<Action>) actionListStack.pop();

        if (skip != null) {
            if (skip.equals(elementPath)) {
                skip = null;
            }
        } else if (applicableActionList != EMPTY_LIST) {
            callEndAction(applicableActionList, getTagName(localName, qName));
        }

        // given that we always push, we must also pop the pattern
        elementPath.pop();
    }
appenderaction处理
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

public void begin(InterpretationContext ec, String localName, Attributes attributes) throws ActionException {
//栈压入
        // We are just beginning, reset variables
        appender = null;
        inError = false;
//通过指定class 来获取类名
        String className = attributes.getValue(CLASS_ATTRIBUTE);
        if (OptionHelper.isEmpty(className)) {
            addError("Missing class name for appender. Near [" + localName + "] line " + getLineNumber(ec));
            inError = true;
            return;
        }

        try {
            addInfo("About to instantiate appender of type [" + className + "]");

            appender = (Appender<E>) OptionHelper.instantiateByClassName(className, ch.qos.logback.core.Appender.class, context);

            appender.setContext(context);

            //通过指定name 来获取自定义该appender的名字
            String appenderName = ec.subst(attributes.getValue(NAME_ATTRIBUTE));

            if (OptionHelper.isEmpty(appenderName)) {
                addWarn("No appender name given for appender of type " + className + "].");
            } else {
                appender.setName(appenderName);
                addInfo("Naming appender as [" + appenderName + "]");
            }

            // The execution context contains a bag which contains the appenders
            // created thus far.
          //  这里就是获取到 logger上下文的一个objMap对象，然后获取这个对象里面key为APPENDER_BAG的容器，存入
            HashMap<String, Appender<E>> appenderBag = (HashMap<String, Appender<E>>) ec.getObjectMap().get(ActionConst.APPENDER_BAG);

            // add the appender just created to the appender bag.
            appenderBag.put(appenderName, appender);

            ec.pushObject(appender);
        } catch (Exception oops) {
            inError = true;
            addError("Could not create an Appender of type [" + className + "].", oops);
            throw new ActionException(oops);
        }
    }




  public void end(InterpretationContext ec, String name) {
      主要是栈弹出
        if (inError) {
            return;
        }

        if (appender instanceof LifeCycle) {
            ((LifeCycle) appender).start();
        }

        Object o = ec.peekObject();

        if (o != appender) {
            addWarn("The object at the of the stack is not the appender named [" + appender.getName() + "] pushed earlier.");
        } else {
            ec.popObject();
        }
    }
body处理
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

//默认使用NestedBasicPropertyIA这个来进行body填充


public void body(InterpretationContext ec, String body) {
		//这里 可能需要对body进行占位符解析得到 一个最终的finalBody
        String finalBody = ec.subst(body);
        // get the action data object pushed in isApplicable() method call
    //因为xml 分为 开标签 中间体  闭标签 所以可以使用栈结构进行弹栈式的获取上一个actiondata
        IADataForBasicProperty actionData = (IADataForBasicProperty) actionDataStack.peek();
        switch (actionData.aggregationType) {
        case AS_BASIC_PROPERTY:
            actionData.parentBean.setProperty(actionData.propertyName, finalBody);
            break;
        case AS_BASIC_PROPERTY_COLLECTION:
            actionData.parentBean.addBasicProperty(actionData.propertyName, finalBody);
            break;
        default:
            addError("Unexpected aggregationType " + actionData.aggregationType);
        }
    }


 public void setProperty(String name, String value) {
        if (value == null) {
            return;
        }
       //通过setter方法进行填充
        Method setter = findSetterMethod(name);
        if (setter == null) {
            addWarn("No setter for property [" + name + "] in " + objClass.getName() + ".");
        } else {
            try {
                setProperty(setter, name, value);
            } catch (PropertySetterException ex) {
                addWarn("Failed to set property [" + name + "] to value \"" + value + "\". ", ex);
            }
        }
    }
默认配置
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 void configure(LoggerContext lc) {
       addInfo("Setting up default configuration.");
       
       ConsoleAppender<ILoggingEvent> ca = new ConsoleAppender<ILoggingEvent>();
       ca.setContext(lc);
       ca.setName("console");
       LayoutWrappingEncoder<ILoggingEvent> encoder = new LayoutWrappingEncoder<ILoggingEvent>();
       encoder.setContext(lc);
       

       // same as 
       // PatternLayout layout = new PatternLayout();
       // layout.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n");
       TTLLLayout layout = new TTLLLayout();

       layout.setContext(lc);
       layout.start();
       encoder.setLayout(layout);
       
       ca.setEncoder(encoder);
       ca.start();
       
       Logger rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);
       rootLogger.addAppender(ca);
   }
日志拆分
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

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
    配置集中管理属性
    可以直接使用属性的value
    格式 类似el表达式 ${name}
    -->
    <!--
    日志格式：
        %-5level 左对齐站5个字符，输出日志级别
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
        %l  下面三者之和
            %C 类的完整名称
            %M 方法名
            %L 行号
        %thread  线程名
        %m或者%msg 消息
        %n 换行
    -->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %C %M %L - %m%n"></property>

    <property name="log_dir" value="F:/test"></property>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 把默认输出流 System.out 换成 System.err -->
        <target>System.err</target>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <appender name="rollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log_dir}/rollingLogback.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <maxFileSize>1MB</maxFileSize>
            <!--%i用于当maxFileSize指定之后，文件名怎么进行拆分  -->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>
        </rollingPolicy>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>


    <!-- 把appender附加到指定的logger -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
        <appender-ref ref="rollingFile"></appender-ref>
    </root>

</configuration>
filter过滤日志级别
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

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
    配置集中管理属性
    可以直接使用属性的value
    格式 类似el表达式 ${name}
    -->
    <!--
    日志格式：
        %-5level 左对齐站5个字符，输出日志级别
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %C 类的完整名称
            %M 方法名
            %L 行号
        %thread  线程名
        %m或者%msg 消息
        %n 换行
    -->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %C %M %L - %m%n"></property>

    <property name="log_dir" value="F:/test"></property>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 把默认输出流 System.out 换成 System.err -->
        <target>System.err</target>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <file>${log_dir}/logback.log</file>
        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!-- addFilter 也算一个set方法 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>

    </appender>


    <!-- 把appender附加到指定的logger -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
        <appender-ref ref="file"></appender-ref>
    </root>

</configuration>
异步日志
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


<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
    配置集中管理属性
    可以直接使用属性的value
    格式 类似el表达式 ${name}
    -->
    <!--
    日志格式：
        %-5level 左对齐站5个字符，输出日志级别
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %C 类的完整名称
            %M 方法名
            %L 行号
        %thread  线程名
        %m或者%msg 消息
        %n 换行
    -->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %C %M %L - %m%n"></property>

    <property name="log_dir" value="F:/test"></property>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 把默认输出流 System.out 换成 System.err -->
        <target>System.err</target>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <file>${log_dir}/logback.log</file>
        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!-- addFilter 也算一个set方法 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>

    </appender>

    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 使用真正的appender进行处理 -->
        <appender-ref ref="file"></appender-ref>
    </appender>

    <!-- 把appender附加到指定的logger -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
        <appender-ref ref="async"></appender-ref>
    </root>

</configuration>
自定义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


<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--
    配置集中管理属性
    可以直接使用属性的value
    格式 类似el表达式 ${name}
    -->
    <!--
    日志格式：
        %-5level 左对齐站5个字符，输出日志级别
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
            %C 类的完整名称
            %M 方法名
            %L 行号
        %thread  线程名
        %m或者%msg 消息
        %n 换行
    -->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %C %M %L - %m%n"></property>

    <property name="log_dir" value="F:/test"></property>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 把默认输出流 System.out 换成 System.err -->
        <target>System.err</target>

        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <file>${log_dir}/logback.log</file>
        <!-- 设置layout ,logback 的layout就是encoder -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

    </appender>


    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="file"></appender-ref>
    </appender>

    <!-- 把appender附加到指定的logger -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
        <appender-ref ref="async"></appender-ref>
    </root>

    <!--  name就是logger名字 level就是此logger级别  additivity就是要不要继承appender -->
    <logger name="aa" level="info" additivity="true">
        <appender-ref ref="console"></appender-ref>
    </logger>

</configuration>

Logback-access

此模块与servlet容器（tomcat ，jetty）集成，提供http来访问日志的功能，可以使用logback-access来替换tomcat的访问日志

1，将logback-access.jar 与 logback-core.jar放入 tomcat home目录下的lib目录下

2 修改$tomcat_home/conf/server.xml的host元素中添加：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<Host name="localhost"  appBase="webapps"
        unpackWARs="true" autoDeploy="true">

    <!-- SingleSignOn valve, share authentication between web applications
         Documentation at: /docs/config/valve.html -->
    <!--
    <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
    -->

    <!-- Access log processes all example.
         Documentation at: /docs/config/valve.html
         Note: The pattern used is equivalent to using pattern="common" 
    <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
           prefix="localhost_access_log" suffix=".txt"
           pattern="%h %l %u %t &quot;%r&quot; %s %b" />
    -->
   <Valve className="ch.qos.logback.access.tomcat.LogbackValue" /> 
    
  </Host>

3.logback默认会在 $TOMCAT_HOME/conf/下查找logback-access.xml文件

logback-access.xml内容

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

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"></statusListener>
    <property name="LOG_DIR" value="${catalina.base}/logs"></property>

    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_DIR}/tomcatAccess.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>access.%d{yyyy-MM-dd}.log.zip</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>combined</pattern>
        </encoder>
    </appender>
    
    <appender-ref ref="FILE"></appender-ref>
</configuration>

<!--
<encoder>
  <pattern>%h %l %u [%t] "%r" %s %b "%i{Referer}" "%i{User-Agent}"</pattern>
</encoder>
is equivalent to:

<encoder>
  <pattern>combined</pattern>
</encoder>

-->
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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

很惭愧

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