几种控制Web应用中log4j日志输出相应级别的日志信息方式

最新推荐文章于 2022-11-01 08:47:33 发布

笨鸟先飞的菜鸟

最新推荐文章于 2022-11-01 08:47:33 发布

阅读量662

点赞数

本文链接：https://blog.csdn.net/qsz1281509180/article/details/112721325

版权

java 同时被 3 个专栏收录

32 篇文章 1 订阅

订阅专栏

Spring

5 篇文章 0 订阅

订阅专栏

Log4j

1 篇文章 0 订阅

订阅专栏

这里讨论的是使用log4j1.x版本的情况。

1、直接修改log4j.xml配置文件中对应logger的日志级别

优点: 简单直接

缺点: 需要重新启动应用

2、使用org.springframework.web.util.Log4jConfigListener定时刷新

常见web.xml中配置如下：

<context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.xml</param-value>
</context-param>
<context-param>
    <param-name>log4jRefreshInterval</param-name>
    <param-value>6000</param-value>
</context-param>

<listener>
   <listener-class>
     org.springframework.web.util.Log4jConfigListener
   </listener-class>
</listener>

优点: 不需要重新启动应用

缺点: 不适合在容器中使用，比如我的应用被打成一个Docker镜像，使用Docker运行或者K8S运行。这样的话除非我进入容器中修改对应的log4j.xml的配置。

3、在应用中提供一个界面管理log4j.xml配置的logger日志级别

一个简单的实现：

（1）log4j.xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

    <!-- 日志输出到控制台 -->
    <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
        <!-- 日志输出格式 -->
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss SSS}|%t|%c|%-5p|%m%n"/>
        </layout>
        <!--过滤器设置输出的级别-->
        <filter class="org.apache.log4j.varia.LevelRangeFilter">
            <!-- 设置日志输出的最小级别 -->
            <param name="levelMin" value="INFO"/>
            <!-- 设置日志输出的最大级别 -->
            <param name="levelMax" value="ERROR"/>
        </filter>
    </appender>

    <category name="org.jackson.mvc" additivity="false">
        <priority value="INFO"/>
        <appender-ref ref="CONSOLE"/>
    </category>

    <category name="ECHO-CONTROLLER" additivity="false">
        <level value="INFO"/>
        <appender-ref ref="CONSOLE"/>
    </category>

    <logger name="logTest" additivity="false">
        <level value ="INFO"/>
        <appender-ref ref="dailyRollingAppender"/>
    </logger>


    <!-- 根logger的设置，若代码中未找到指定的logger，则会根据继承机制，使用根logger-->
    <root>
        <appender-ref ref="CONSOLE"/>
    </root>

</log4j:configuration>

（2）JSP页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@page isELIgnored="false" %>
<html>
<head>
    <title>logLevel</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css">
    <script src="https://cdn.staticfile.org/jquery/2.1.1/jquery.min.js"></script>
    <script src="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>
</head>
<script type="application/javascript">
    function changeHref(current, loggerName) {
        var loggerLevel = document.getElementById(loggerName).value;
        current.href = "/v1/log4j/changeLevel?logger=" + loggerName + "&level=" + loggerLevel;
    }
</script>
<body>
<div class="container">
    <h2>log4j日志级别调控</h2>
    <p> all logger configuration：</p>
    <table class="table">
        <thead>
        <tr>
            <th>name</th>
            <th>level</th>
            <th>optional</th>
            <th>operation</th>
        </tr>
        </thead>
        <tbody>
        <c:forEach items="${loggers}" var="logger">
            <tr class="success">
                <td>${logger.name}</td>
                <td>${logger.level}</td>
                <td>
                    <select id="${logger.name}">
                        <option value="DEBUG">DEBUG</option>
                        <option value="INFO">INFO</option>
                        <option value="WARN">WARN</option>
                        <option value="ERROR">ERROR</option>
                    </select>
                </td>
                <td>
                    <a class="playitbtn tryitbtnsyntax"
                       href="/v1/log4j/changeLevel"
                       onclick="changeHref(this, '${logger.name}')">update</a>
                </td>
            </tr>
        </c:forEach>
        </tbody>
    </table>
</div>
</body>
</html>

要使用c:forEach标签需要引入以下两个依赖：

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

但是我这边引入后还是没有正确解析，最终使用该博客的方法解决。原文链接如下：

https://blog.csdn.net/weixin_42247720/article/details/104416973?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242

（3）Java代码如下：

Controller层代码

package org.jackson.mvc.web.controllers.simple;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.jackson.mvc.web.controllers.simple.vo.LoggerInfo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;

@Controller
@RequestMapping(path = "v1/log4j")
public class LogLevelController {

    private List<LoggerInfo> loggerInfoList;
    private volatile boolean isInitialed = false;

    @RequestMapping(path = "/changeLevel")
    public String logLevelChange(HttpServletRequest request) {
        if(!isInitialed) {
            initLoggerInfo();
        }
        String queryString = request.getQueryString();
        String loggerName = request.getParameter("logger");
        String loggerLevel = request.getParameter("level");
        if(StringUtils.isNotEmpty(queryString) && StringUtils.isNotEmpty(loggerName)
                && StringUtils.isNotEmpty(loggerLevel)) {
            changeLoggerLevel(loggerName, loggerLevel);
        }
        request.setAttribute("loggers", loggerInfoList);
        return "logLevel";
    }

    private void changeLoggerLevel(String loggerName, String loggerLevel) {
        if(StringUtils.isEmpty(loggerName) || StringUtils.isEmpty(loggerLevel)) return;
        Logger logger = LogManager.exists(loggerName);
        if(Optional.ofNullable(logger).isPresent()) {
            logger.setLevel(Level.toLevel(loggerLevel));
            // update logger collect
            for (LoggerInfo loggerInfo : loggerInfoList) {
                if(loggerName.equals(loggerInfo.getName())) {
                    loggerInfo.setLevel(logger.getLevel().toString());
                    break;
                }
            }
        }
    }

    /**
     * init logger with log4j.xml configuration
     */
    private void initLoggerInfo() {
        try {
            InputStream resource = this.getClass().getClassLoader().getResourceAsStream("log4j.xml");
            SAXParser saxParser = buildParser();
            Log4jHandler handler = new Log4jHandler();
            saxParser.parse(resource, handler);
            loggerInfoList = handler.getLoggerInfoList();
            isInitialed = true;
            return;
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        loggerInfoList = Collections.EMPTY_LIST;
    }

    /**
     * 使用SAXParser解析xml文件
     * @return
     * @throws ParserConfigurationException
     * @throws SAXException
     */
    private SAXParser buildParser() throws ParserConfigurationException, SAXException {
        SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
        saxParserFactory.setValidating(false);
        saxParserFactory.setNamespaceAware(true);
        return saxParserFactory.newSAXParser();
    }

    static class Log4jHandler extends DefaultHandler {
        private LoggerInfo loggerInfo;
        private List<LoggerInfo> loggerInfoList = new ArrayList<>();
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            if("category".equals(localName) || "logger".equals(localName)) {
                loggerInfo = new LoggerInfo();
                loggerInfo.setName(attributes.getValue(0));
                loggerInfoList.add(loggerInfo);
            }
            if("priority".equals(localName) || "level".equals(localName)) {
                if (loggerInfo != null) loggerInfo.setLevel(attributes.getValue(0));
            }
        }

        public List<LoggerInfo> getLoggerInfoList() {
            return loggerInfoList;
        }
    }
}

VO代码如下：

package org.jackson.mvc.web.controllers.simple.vo;

public class LoggerInfo {
    private String name;
    private String level;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }
}

注意：使用SAXParser解析XML文件时log4j.xml中不要配置如下信息:

<!DOCTYPE log4j:configuration PUBLIC "-//log4j/log4j Configuration//EN" "log4j.dtd">

或者

<!DOCTYPE SYSTEM "log4j.dtd">

配置dtd文件解析时回报Tomcat的bin目录下找不到这个log4j.dtd文件......。

（4）启动后页面效果如下：

（5）测试代码如下：

@RestController()
@RequestMapping(value = "v1/echo/")
public class EchoController {

    private static final DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private static final Logger LOGGER = LogManager.getLogger(EchoController.class);

    private static final Logger ECHO_CONTROLLER = LogManager.getLogger("ECHO-CONTROLLER");

    @InitBinder
    public void initBinder(WebDataBinder dataBinder) {
        dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(df, false));
    }

    @Autowired
    private EchoService echoService;

    @GetMapping(path = "sayHello/{message}")
    public String sayHello(@PathVariable(name = "message") String message) {
        LOGGER.info(message);
        ECHO_CONTROLLER.info(message);
        return echoService.sayHello(message);
    }
}

访问http://localhost:9090/v1/echo/sayHello/helloSpringMVC 代码输出信息如下：

2021-01-16 20:28:32 191|http-nio-9090-exec-4|org.jackson.mvc.web.controllers.echo.EchoController|INFO |helloSpringMVC
2021-01-16 20:28:32 192|http-nio-9090-exec-4|ECHO-CONTROLLER|INFO |helloSpringMVC

在日志控制页面将ECHO-CONTROLLER的日志级别调整为ERROR。

调整后再次访问 http://localhost:9090/v1/echo/sayHello/helloSpringMVC 输出日志如下：

2021-01-16 20:53:25 725|http-nio-9090-exec-3|org.jackson.mvc.web.controllers.echo.EchoController|INFO |helloSpringMVC

可以看到代码中ECHO-CONTROLLER的对应日志并没有打印，说明此种方式也是可控制应用中日志的输出。

优点: 通过应用提供的界面进行修改，不需要重启应用

缺点:

(1)、暴露了应用的一个对外接口，如果接口被他人获取可能会恶意修改，所以必要的需要添加该接口的访问控制。

(2)、这个修改只是对当前应用起作用，但是生产上我们可能一个应用会部署多套，通过Nginx负载均衡，所以需要每个应用都刷新一下。

(3)、需要自己写代码实现还要考虑接口的安全性等问题

4、针对原生K8S且K8S的版本需要支持以文件生成ConfigMap的版本

使用原生K8S且满足上面的上面的条件，那最简单的方式就是如下命令生成一个ConfigMap，在Deployment中进行相关配置即可。

kubectl create configmap log4j-config --from-file=log4j.xml

以上信息都是个人愚见，若有错误或有更好的方式，欢迎留言讨论^ - ^～^ - ^

笨鸟先飞的菜鸟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
几种控制Web应用中log4j日志输出相应级别的日志信息方式

这里讨论的是使用log4j1.x版本的情况。1、直接修改log4j.xml配置文件中对应logger的日志级别优点: 简单直接缺点: 需要重新启动应用2、使用org.springframework.web.util.Log4jConfigListener定时刷新常见web.xml中配置如下：<context-param> <param-name>log4jConfigLocation</param-name> <param.
复制链接

扫一扫