Fork me on GitHub

JUL日志框架

字数统计: 4k字   |   阅读时长≈ 18分

JUL

架构：

Logger(filter)—>Handler(filter)—>Outside World

Loggers:被称为记录器，应用程序通过获取Logger对象，调用其API来发布日志信息。Logger通常是应用程序访问日志系统的入口程序

Appenders：也被称为handlers，每个logger都会关联一组hanlders，Logger会在日志交给关联的Handlers处理，有Handlers负责将日志做记录。Handlers在此是一个抽象，在具体的实现决定了日志记录的位置可以是控制台，文件，网络上的其他日志服务

Layouts：也被称为Formatters，她负责对日志事件中的数据进行转换和格式化，layouts决定了数据在一条日志记录中的最终形式

level：每条日志消息都有一个关联的日志级别，该级别粗略指导了日志消息的重要性和紧迫，我们可以讲level和loggers，Appenders做关联以便于我们过滤消息

Filter 过滤器，根据需要制定那些信息会被记录，那些信息会被放过

使用：

pom.xml

1
2
3
4
5
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
  </dependency>
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


public class MyLogLearn {

    @Test
    public void test(){

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

       logger.log(Level.INFO,"hi");
   }



}

占位符
   @Test
    public void test1(){

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

        String name="张三";
        Integer age=18;

        logger.log(Level.INFO,"用户信息: name:{0},age:{1}",new Object[]{name,age});
    }

级别：

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
//SEVERE是指示严重失败的消息级别。一般来说SEVERE消息应该描述相当重要且这将阻止程序的正常执行的事件。 他们应该合理地理解为在最终用户和系统管理员。 此级别初始化为1000 
 public static final Level SEVERE = new Level("SEVERE",1000, defaultBundle);

//警告是指示一个潜在的问题的消息级别。一般来说WARNING消息应该描述事件，将感兴趣的最终用户或系统管理员，或表明潜在的问题。 此级别初始化为900 
 public static final Level WARNING = new Level("WARNING", 900, defaultBundle);


//INFO是报告消息的消息级别。典型地，INFO消息将被写入到控制台或它的等同物。 因此，INFO级别应该只用于合理显著的消息，这将是有意义的最终用户和系统管理员。 此级别初始化为800 。
  public static final Level INFO = new Level("INFO", 800, defaultBundle);

//CONFIG是用于静态配置消息的消息级别。CONFIG消息用于提供各种静态配置信息，以帮助调试可能与特定配置相关的问题。 例如，CONFIG消息可能包括CPU类型，图形深度，GUI外观和手感等。这种电平初始化为700 
 public static final Level CONFIG = new Level("CONFIG", 700, defaultBundle);


//FINE是消息一级提供跟踪信息。一切都很好，细，和最好的打算用于相对详细的跟踪。 三个层次的确切含义将子系统之间有所不同，但一般来说，FINEST应该用于最大体积详细的输出，对于FINER稍差详细的输出，和FINE为最低体积（和最重要的）消息。在一般的精细程度应使用谁没有在特定的子系统中的专业兴趣做，这将是广泛的有趣的开发人员的信息。FINE消息可能包括诸如次要的（可恢复的）失败。 表明潜在的性能问题的问题也值得记录的罚款。 此级别初始化为500 
 public static final Level FINE = new Level("FINE", 500, defaultBundle);


//FINER指示一条相当详细的跟踪消息。 默认情况下，记录来电进入，返回，或抛出异常在这个级别被跟踪。 此级别初始化为400 。
 public static final Level FINER = new Level("FINER", 400, defaultBundle);

//FINEST表示高度详细的跟踪消息。 此级别初始化为300 
  public static final Level FINEST = new Level("FINEST", 300, defaultBundle);

//ALL表示所有消息应被记录。 此级别初始化为Integer.MIN_VALUE 
public static final Level ALL = new Level("ALL", Integer.MIN_VALUE, defaultBundle);


//OFF是一个可用于关闭日志记录的特殊级别。 此级别初始化为Integer.MAX_VALUE 
  public static final Level OFF = new Level("OFF",Integer.MAX_VALUE, defaultBundle);



  @Test
    public void test2(){

        Logger logger=Logger.getLogger("MyLogLearn");
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info"); //jul默认日志级别
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

自定义级别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Test
   public void test2(){

       Logger logger=Logger.getLogger("MyLogLearn");
       //去除自带的handler，使用自定义的
       logger.setUseParentHandlers(false);
       //创建一个格式转化
       SimpleFormatter simpleFormatter=new SimpleFormatter();
       //创建handler
       ConsoleHandler consoleHandler=new ConsoleHandler();
       consoleHandler.setFormatter(simpleFormatter);
       consoleHandler.setLevel(Level.ALL);
       //自定义日志级别
       logger.addHandler(consoleHandler);
       logger.setLevel(Level.ALL);
       logger.severe("severe");
       logger.warning("warning");
       logger.info("info");
       logger.config("config");
       logger.fine("fine");
       logger.finer("finer");
       logger.finest("finest");
   }

文件记录

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
@Test
    public void test2() throws IOException {

        Logger logger=Logger.getLogger("MyLogLearn");
        //去除自带的handler，使用自定义的
        logger.setUseParentHandlers(false);

        //创建一个格式转化
        SimpleFormatter simpleFormatter=new SimpleFormatter();
        //创建handler
        FileHandler fileHandler=new FileHandler("./test.txt");

        //日志关联
        //handler关联 formatter
        fileHandler.setFormatter(simpleFormatter);
        //logger关联handler
        logger.addHandler(fileHandler);

        //自定义 日志级别 双层级别过滤
        //定义该logger的级别
        logger.setLevel(Level.ALL);

        //定义具体这个appender（handler的级别）
        fileHandler.setLevel(Level.ALL);



        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

源码

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

  private static Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
      
        //LogManager使用单例模式，所以LogManager里面的所有成员（静态和非静态）字段被所有的logger访问
        LogManager manager = LogManager.getLogManager();
        SecurityManager sm = System.getSecurityManager();
        if (sm != null && !SystemLoggerHelper.disableCallerCheck) {
            if (caller.getClassLoader() == null) {
                return manager.demandSystemLogger(name, resourceBundleName);
            }
        }
      //
        return manager.demandLogger(name, resourceBundleName, caller);
        // ends up calling new Logger(name, resourceBundleName, caller)
        // iff the logger doesn't exist already
    }


Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
    //通过名字来查找logger，这也是为什么每次获取一个logger时需要指定名字，
    //所以多线程情况下，可以通过每个线程的线程名字注册一个logger，每个线程使用一个logger，就不会产生线程争用
        Logger result = getLogger(name);
        if (result == null) {
            // 只分配一次新的记录器
            Logger newLogger = new Logger(name, resourceBundleName, caller, this, false);
            do {
                if (addLogger(newLogger)) {
                    // 我们成功地添加了我们在上面创建的新记录器，因此不必重新提取就返回它。
                    return newLogger;
                }
                // 我们没有添加上面创建的新记录器，因为另一个线程在上面的空检查之后和调用addLogger（）之前添加了一个同名的记录器。我们必须重新提取记录器，因为addLogger（）返回的是布尔值，而不是记录器引用本身。但是，如果创建另一个记录器的线程没有保存对另一个记录器的强引用，那么在我们在addLogger（）中看到另一个记录器之后，在我们可以重新提取它之前，就有可能被GC'ed。如果它已经被GC'ed，那么我们将循环并再试一次。
                //多线程 采用轮询获取，注意addLogger(newLogger)保证线程安全
                result = getLogger(name);
            } while (result == null);
        }
        return result;
    }

  //namedLoggers使用Hashtable是为了保证线程安全
  private final Hashtable<String,LoggerWeakRef> namedLoggers = new Hashtable<>();
父子关系
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

 synchronized boolean addLocalLogger(Logger logger, boolean addDefaultLoggersIfNeeded) {
      
     //addDefaultLoggersIfNeeded用于在添加默认记录器时中断递归。如果我们要添加一个默认的记录器（从ensureDefaultLogger()调用），那么addDefaultLoggersIfNeeded将为false：我们不想再次调用ensureAllDefaultLoggers。
            // 注意：当requiresDefaultLoggers为false时，addDefaultLoggersIfNeeded也可以为false—因为在这种情况下，调用ensureAllDefaultLoggers没有任何效果。
            if (addDefaultLoggersIfNeeded) {
                ensureAllDefaultLoggers(logger);
            }

            final String name = logger.getName();
            if (name == null) {
                throw new NullPointerException();
            }
            LoggerWeakRef ref = namedLoggers.get(name);
            if (ref != null) {
                if (ref.get() == null) {
                    //记录器可能是在上面的drainLoggerRefQueueBounded（）调用之后GC的，因此允许注册一个新的记录器。
                    ref.dispose();
                } else {
                    // We already have a registered logger with the given name.
                    return false;
                }
            }

            // We're adding a new logger.
            // Note that we are creating a weak reference here.
            final LogManager owner = getOwner();
            logger.setLogManager(owner);
            ref = owner.new LoggerWeakRef(logger);
            namedLoggers.put(name, ref);

            // Apply any initial level defined for the new logger, unless
            // the logger's level is already initialized
            Level level = owner.getLevelProperty(name + ".level", null);
            if (level != null && !logger.isLevelInitialized()) {
                doSetLevel(logger, level);
            }

            
     //处理程序的实例化是在LogManager.addLogger实现中完成的，因为对于自定义日志管理器案例，处理程序类只能对LogManager子类可见
            processParentHandlers(logger, name);

            // 这里是找到当前 名字的节点，按照com.zgw.xxx 以点的形式来区分级别
            LogNode node = getNode(name);
            node.loggerRef = ref;
            Logger parent = null;
            LogNode nodep = node.parent;
     
     		//没有parent就直到获取到rootLooger
            while (nodep != null) {
                LoggerWeakRef nodeRef = nodep.loggerRef;
                if (nodeRef != null) {
                    parent = nodeRef.get();
                    if (parent != null) {
                        break;
                    }
                }
                nodep = nodep.parent;
            }
			
          //设置自己的父亲
            if (parent != null) {
                doSetParent(logger, parent);
            }
           //告诉自己的孩子节点设置他们的父亲为自己
            // Walk over the children and tell them we are their new parent.
            node.walkAndSetParent(logger);
            // new LogNode is ready so tell the LoggerWeakRef about it
     		//LoggerWeakRef与自己节点关联
            ref.setNode(node);
            return true;
        }



顶级rootLogger
    
   final void ensureLogManagerInitialized() {
        final LogManager owner = this;
        if (initializationDone || owner != manager) {
            // we don't want to do this twice, and we don't want to do
            // this on private manager instances.
            return;
        }

        // Maybe another thread has called ensureLogManagerInitialized()
        // before us and is still executing it. If so we will block until
        // the log manager has finished initialized, then acquire the monitor,
        // notice that initializationDone is now true and return.
        // Otherwise - we have come here first! We will acquire the monitor,
        // see that initializationDone is still false, and perform the
        // initialization.
        //
        synchronized(this) {
            // If initializedCalled is true it means that we're already in
            // the process of initializing the LogManager in this thread.
            // There has been a recursive call to ensureLogManagerInitialized().
            final boolean isRecursiveInitialization = (initializedCalled == true);

            assert initializedCalled || !initializationDone
                    : "Initialization can't be done if initialized has not been called!";

            if (isRecursiveInitialization || initializationDone) {
                // If isRecursiveInitialization is true it means that we're
                // already in the process of initializing the LogManager in
                // this thread. There has been a recursive call to
                // ensureLogManagerInitialized(). We should not proceed as
                // it would lead to infinite recursion.
                //
                // If initializationDone is true then it means the manager
                // has finished initializing; just return: we're done.
                return;
            }
            // Calling addLogger below will in turn call requiresDefaultLogger()
            // which will call ensureLogManagerInitialized().
            // We use initializedCalled to break the recursion.
            initializedCalled = true;
            try {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        assert rootLogger == null;
                        assert initializedCalled && !initializationDone;

                        // Read configuration. 加载配置文件，会默认加载
                        owner.readPrimordialConfiguration();

                        // Create and retain Logger for the root of the namespace.
                        owner.rootLogger = owner.new RootLogger();
                        owner.addLogger(owner.rootLogger);
                        if (!owner.rootLogger.isLevelInitialized()) {
                            owner.rootLogger.setLevel(defaultLevel);
                        }

                        // Adding the global Logger.
                        // Do not call Logger.getGlobal() here as this might trigger
                        // subtle inter-dependency issues.
                        @SuppressWarnings("deprecation")
                        final Logger global = Logger.global;

                        // Make sure the global logger will be registered in the
                        // global manager
                        owner.addLogger(global);
                        return null;
                    }
                });
            } finally {
                initializationDone = true;
            }
        }
    }
总结父子关系
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

    public void test3(){

        Logger logger1=Logger.getLogger("com.zgw");
        Logger logger2=Logger.getLogger("com");
        System.out.println(logger1.getParent()==logger2);

        //=============设置logger2的自定义级别======================================
        //创建一个格式转化
        SimpleFormatter simpleFormatter=new SimpleFormatter();
        //创建handler
        ConsoleHandler consoleHandler=new ConsoleHandler();

        consoleHandler.setFormatter(simpleFormatter);
        logger2.addHandler(consoleHandler);

        consoleHandler.setLevel(Level.ALL);
        logger2.setLevel(Level.ALL);
        //=================关闭logger2的根继承==================================

        logger2.setUseParentHandlers(false);
        
        logger1.severe("severe");
        logger1.warning("warning");
        logger1.info("info");
        logger1.config("config");
        logger1.fine("fine");
        logger1.finer("finer");
        logger1.finest("finest");

    }


当一个logger存在父级时，如果不关闭UseParentHandlers，则会继承parent logger的所有Handlers

但是 一个logger的级别 不会使用 父级的，不指定才会继承父级的level，但是处理器 handler(也叫Appender)会使用父级的（开启使用父级的handlers）   ；  同样也会使用自己的

配置文件

由于硬编码不好维护

所以使用加载配置文件来配置logger

加载配置文件需要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

 // Read configuration. 加载配置文件，会默认加载
    owner.readPrimordialConfiguration(); //LogManager.getLogManager();时会执行这段话
        
最终调用此方法
   public void readConfiguration() throws IOException, SecurityException {
        checkPermission();

        // if a configuration class is specified, load it and use it.
        String cname = System.getProperty("java.util.logging.config.class");
        if (cname != null) {
            try {
                // Instantiate the named class.  It is its constructor's
                // responsibility to initialize the logging configuration, by
                // calling readConfiguration(InputStream) with a suitable stream.
                try {
                    Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                } catch (ClassNotFoundException ex) {
                    Class<?> clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                }
            } catch (Exception ex) {
                System.err.println("Logging configuration class \"" + cname + "\" failed");
                System.err.println("" + ex);
                // keep going and useful config file.
            }
        }
//获取java.util.logging.config.file的属性，然后读取
        String fname = System.getProperty("java.util.logging.config.file");
        if (fname == null) {
            fname = System.getProperty("java.home");
            if (fname == null) {
                throw new Error("Can't find java.home ??");
            }
            //上面都没获取到，那么使用 jre目录下的lib目录下的logging.properties文件
            File f = new File(fname, "lib");
            f = new File(f, "logging.properties");
            fname = f.getCanonicalPath();
        }
        try (final InputStream in = new FileInputStream(fname)) {
            final BufferedInputStream bin = new BufferedInputStream(in);
            readConfiguration(bin);
        }
    }
logging.properties
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
############################################################
#  	Default Logging Configuration File
#
# 您可以使用其他文件，方法是使用java.util.logging.配置文件系统属性   
# 例如java-Djava.util.logging.config.file= 我的文件
############################################################

############################################################
#  	Global properties
############################################################

# “handlers”指定以逗号分隔的日志处理程序类列表。这些处理程序将在VM启动期间安装。
#  请注意，这些类必须位于系统类路径中。
# 默认情况下，我们只配置一个ConsoleHandler，它将只显示INFO和更高级别的消息。

#这个是设置顶级rootlogger的handlers "".handlers
handlers= java.util.logging.ConsoleHandler
# 给指定的logger添加handlers, loggerName.handlers=XXX
# aa.handlers= java.util.logging.ConsoleHandler

# 若要同时添加FileHandler，请改为使用以下行。
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# 默认全局日志记录级别。 也就是rootlogger的级别
# 它指定在所有记录器中记录哪些类型的事件。  
# 对于任何给定的设备，此全局级别都可以由特定于设备的级别覆盖请注意（父子继承知识），ConsoleHandler还具有一个单独的级别设置，以限制打印到控制台的消息。
# .level 是 "".level  意思是 rootLogger的level
# 如果logger的name为 com，那么 com.level = INFO 就代表 名为com的level是info级别
.level= INFO

############################################################
# 处理程序特定属性。
# 描述处理程序的特定配置信息。
############################################################

# 默认文件输出在用户的主目录中。%h系统用户目录  %u是一个数字 
java.util.logging.FileHandler.pattern = %h/java%u.log
#文件最大记录日志条数
java.util.logging.FileHandler.limit = 50000 
# 文件数量 如果为10，则会出现 用户目录/java【1~10】.log的文件
java.util.logging.FileHandler.count = 1
# 日志展示使用的 格式化器
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# 将控制台上打印的消息限制为INFO及以上。
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# 自定义SimpleFormat输出格式以打印一行日志消息的示例如下：
#     <level>: <log message> [<date/time>]
#
# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n

############################################################
# 设施特定属性。为每个记录器提供额外的控制。
############################################################

# 例如，设置com.xyz.foo网站记录器只记录严重信息：
com.xyz.foo.level = SEVERE
#不继承父级Handlers
com.xyz.foo.useParentHandlers=false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21


private void configure() {
        LogManager manager = LogManager.getLogManager();
        String cname = getClass().getName();

    //这里就是配置文件 java.util.logging.ConsoleHandler.level = INFO 的原理
        setLevel(manager.getLevelProperty(cname +".level", Level.INFO));
        setFilter(manager.getFilterProperty(cname +".filter", null));
        setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
        try {
            setEncoding(manager.getStringProperty(cname +".encoding", null));
        } catch (Exception ex) {
            try {
                setEncoding(null);
            } catch (Exception ex2) {
                // doing a setEncoding with null should always work.
                // assert false;
            }
        }
    }
应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19


@Test
   public void test4() throws IOException {

       InputStream in = MyLogLearn.class.getClassLoader().getResourceAsStream("logging.properties");
       LogManager logManager=LogManager.getLogManager();
       logManager.readConfiguration(in);
       Logger logger=Logger.getLogger("aa");

       logger.severe("severe");
       logger.warning("warning");
       logger.info("info");
       logger.config("config");
       logger.fine("fine");
       logger.finer("finer");
       logger.finest("finest");

   }

架构：

我们的应用—> Logger( 有LogManager(单例)提供并初始化 )–（Level）–> LogRecord—（Filter）–>Handler—（Formatter）–>输出

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

  public void log(Level level, String msg) {
        if (!isLoggable(level)) { //日志级别检查
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);
    }

 public void log(LogRecord record) {
        if (!isLoggable(record.getLevel())) {
            return;
        }
        Filter theFilter = filter;
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }

        // Post the LogRecord to all our Handlers, and then to
        // our parents' handlers, all the way up the tree.

        Logger logger = this;
        while (logger != null) {
            final Handler[] loggerHandlers = isSystemLogger
                ? logger.accessCheckedHandlers()
                : logger.getHandlers();

            for (Handler handler : loggerHandlers) {
                handler.publish(record);
            }

            final boolean useParentHdls = isSystemLogger
                ? logger.useParentHandlers
                : logger.getUseParentHandlers();

            if (!useParentHdls) {
                break;
            }

            logger = isSystemLogger ? logger.parent : logger.getParent();
        }
    }


已ConsoleHandler为例
  @Override
    public void publish(LogRecord record) {
        super.publish(record);
        flush();
    }


public synchronized void publish(LogRecord record) {
        if (!isLoggable(record)) {
            return;
        }
        String msg;
        try {
            msg = getFormatter().format(record);
        } catch (Exception ex) {
            // We don't want to throw an exception here, but we
            // report the exception to any registered ErrorManager.
            reportError(null, ex, ErrorManager.FORMAT_FAILURE);
            return;
        }

        try {
            if (!doneHeader) {
                writer.write(getFormatter().getHead(this));
                doneHeader = true;
            }
            writer.write(msg);
        } catch (Exception ex) {
            // We don't want to throw an exception here, but we
            // report the exception to any registered ErrorManager.
            reportError(null, ex, ErrorManager.WRITE_FAILURE);
        }
    }
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

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

很惭愧

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