log4j2 的配置与使用

た入场券 2022-04-12 05:16 366阅读 0赞

简单说一下log4j2的改进，引用一下百度上的：

1、丢数据这种情况少，可以用来做审计功能。而且自身内部报的exception会被发现，但是logback和log4j不会。  
2、log4j2使用了disruptor技术，在多线程环境下，据说性能高于logback等10倍以上。  
3、(garbage free）之前的版本会产生非常多的临时对象，会造成GC频繁，log4j2则在这方面上做了优化，减少产生临时对象。尽可能少的GC  
4、利用插件系统，使得扩展新的appender,filter,layout等变得容易，log4j不可以扩展 插件？？？？  
5、因为插件系统的简单性，所以在配置的时候，可以不用具体指定所要处理的类型。class  
6、可以自定义level  
7、Java 8 lambda support for lazy logging  
8、Support for Message objects  
9、对filter的功能支持的更强大  
10、系统日志(Syslog)协议supports both TCP and UDP  
11、利用jdk1.5并发的特性，减少了死锁的发生。  
12、Socket LogEvent SerializedLayout  
13、支持kafka queue

然后就是看怎么集成了：

1、用maven引入jar支持：

<dependency>
    			<groupId>org.apache.logging.log4j</groupId>
    			<artifactId>log4j-core</artifactId>
    			<version>2.10.0</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.logging.log4j</groupId>
    			<artifactId>log4j-api</artifactId>
    			<version>2.10.0</version>
    		</dependency>
    
    
    		
    		<dependency>
    			<groupId>com.lmax</groupId>
    			<artifactId>disruptor</artifactId>
    			<version>3.3.6</version>
    		</dependency>

需要注意的是，如果你引入了spring boot整合的库，比如：spring-cloud-starter。。。等这些包，记得要先排除其他日志框架，否则可能会造成jar冲突。举个例子：

<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-eureka</artifactId>
    			<version>1.4.4.RELEASE</version>
    			<exclusions>
                    
    				<exclusion>
    					<groupId>org.springframework.boot</groupId>
    					<artifactId>spring-boot-starter-logging</artifactId>
    				</exclusion>
    				<exclusion>
    					<artifactId>*</artifactId>
    					<groupId>ch.qos.logback</groupId>
    				</exclusion>
    				<exclusion>
    					<artifactId>*</artifactId>
    					<groupId>org.slf4j</groupId>
    				</exclusion>
    			</exclusions>
    		</dependency>

2、再就是添加log2j的配置文件了，直接看吧，注释比较清楚：

<?xml version="1.0" encoding="UTF-8"?>
    
    
    
    
    
    
    
    <configuration status="INFO">
    
    	
    	<Properties>
    		
    		<Property name="fileName">rblZuulServer</Property>
    		
    		<Property name="backupFilePatch">/usr/log</Property>
    	</Properties>
    	
    	<appenders>
    
    		
    		<Console name="Console" target="SYSTEM_OUT">
    			
    			<ThresholdFilter level="trace" onMatch="ACCEPT"
    				onMismatch="DENY" />
    			
    			<PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss.SSS} %p %c %M - %m%n" />
    		</Console>
    
    		
    		<File name="File" fileName="${backupFilePatch}/${fileName}_test.log"
    			append="false">
    			<ThresholdFilter level="trace" onMatch="ACCEPT"
    				onMismatch="DENY" />
    			<PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss.SSS} %p %c %M - %m%n" />
    		</File>
    
    		
    		
    		<RollingFile name="service_appender" fileName="${backupFilePatch}/${fileName}.log"
    			filePattern="${backupFilePatch}/${fileName}.log.%d{yyyy-MM-dd}-%i.log.gz"
    			immediateFlush="true">
    
    			
    
    			<PatternLayout pattern="%d{yyyy.MM.dd HH:mm:ss.SSS} %p %c %M - %m%n" />
    
    			<Policies>
    				<TimeBasedTriggeringPolicy interval="1"
    					modulate="true" />
    				
    				<SizeBasedTriggeringPolicy size="30MB" />
    			</Policies>
    
    			
    			<DefaultRolloverStrategy max="20">
    				<Delete basePath="${backupFilePatch}/" maxDepth="1">
    					
    					<IfFileName glob="*.log.gz" />
    					
    					<IfLastModified age="20D" />
    				</Delete>
    			</DefaultRolloverStrategy>
    		</RollingFile>
    
    	</appenders>
    
    	
    	<loggers>
    
    		
    		<AsyncLogger name="org.springframework" level="ERROR">
    		</AsyncLogger>
    		<AsyncLogger name="org.mybatis" level="error">
    		</AsyncLogger>
    		<AsyncLogger name="org.hibernate" level="error">
    		</AsyncLogger>
    		<AsyncLogger name="org.apache" level="error">
    		</AsyncLogger>
    	
    
    		
    		<AsyncLogger name="com.poly.zuul" level="DEBUG"
    			additivity="true">
    		</AsyncLogger>
    
    		
    		<asyncRoot level="INFO">
    			
    			<AppenderRef ref="Console" />
    			<AppenderRef ref="File" />
    			<AppenderRef ref="service_appender" />
    		</asyncRoot>
    	</loggers>
    </configuration>

3、在你的工程引入配置文件，比如命名为log4j2.xml，然后在工程配置文件中指定日志配置文件。如在application.properties中加入：

#log4j2指定配置文件路径
    logging.config=classpath:xml/log4j2.xml

4、到此为止，基本配置已经完成，可以直接使用了，为了方便，这里给一个日志工具类 LoggerUtil，便于大家使用：

/*
     * 文件名：LoggerUtils.java 版权：Copyright by www.huawei.com 描述： 修改人：kokJuis 修改时间：2017年8月9日 跟踪单号： 修改单号：
     * 修改内容：
     */
    
    package com.poly.rbl.utils;
    
    
    import org.apache.commons.lang3.StringUtils;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    
    /**
     * 日志工具类
     * 
     * @author gogym
     * @version 2017年8月9日
     * @see LoggerUtils
     * @since
     */
    public class LoggerUtil
    {
        /**
         * 是否开启Debug
         */
        public static boolean isDebug = LogManager.getLogger(LoggerUtils.class).isDebugEnabled();
    
        public static void info(String message)
        {
            Logger logger = LogManager.getLogger();
            logger.info(message);
        }
    
        /**
         * Description: info输出
         * 
         * @param clazz
         *            目标.Class
         * @param message
         *            输出信息
         * @see
         */
        public static void info(Class<? extends Object> clazz, String message)
        {
            Logger logger = LogManager.getLogger(clazz);
            logger.info(message);
        }
    
        /**
         * info 输出
         * 
         * @param clazz
         *            目标.Class
         * @param fmtString
         *            输出信息key
         * @param value
         *            输出信息value
         */
        public static void fmtInfo(Class<? extends Object> clazz, String key, Object... value)
        {
    
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (null != value && value.length != 0)
            {
                Logger logger = LogManager.getLogger(clazz);
                logger.info("{}:{}", key, value);
            }
        }
    
        /**
         * Debug 输出
         * 
         * @param clazz
         *            目标.Class
         * @param message
         *            输出信息
         */
        public static void debug(Class<? extends Object> clazz, String message)
        {
            if (!isDebug) return;
            Logger logger = LogManager.getLogger(clazz);
            logger.debug(message);
        }
    
        /**
         * Debug 输出
         * 
         * @param clazz
         *            目标.Class
         * @param fmtString
         *            输出信息key
         * @param value
         *            输出信息value
         */
        public static void fmtDebug(Class<? extends Object> clazz, String key, Object... value)
        {
            if (!isDebug) return;
    
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (null != value && value.length != 0)
            {
                Logger logger = LogManager.getLogger(clazz);
                logger.debug("{}:{}", key, value);
            }
        }
    
        /**
         * Error 输出
         * 
         * @param clazz
         *            目标.Class
         * @param message
         *            输出信息
         * @param e
         *            异常类
         */
        public static void error(Class<? extends Object> clazz, String message, Exception e)
        {
            Logger logger = LogManager.getLogger(clazz);
            if (null == e)
            {
                logger.error(message);
                return;
            }
            logger.error(message, e);
        }
    
        /**
         * Error 输出
         * 
         * @param clazz
         *            目标.Class
         * @param message
         *            输出信息
         */
        public static void error(Class<? extends Object> clazz, String message)
        {
            error(clazz, message, null);
        }
    
        /**
         * 异常填充值输出
         * 
         * @param clazz
         *            目标.Class
         * @param fmtString
         *            输出信息key
         * @param e
         *            异常类
         * @param value
         *            输出信息value
         */
        public static void fmtError(Class<? extends Object> clazz, Exception e, String key,
                                    Object... value)
        {
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (null != value && value.length != 0)
            {
                Logger logger = LogManager.getLogger(clazz);
                logger.error("{}:{}", key, value);
            }
        }
    
        /**
         * 异常填充值输出
         * 
         * @param clazz
         *            目标.Class
         * @param fmtString
         *            输出信息key
         * @param value
         *            输出信息value
         */
        public static void fmtError(Class<? extends Object> clazz, String key, Object... value)
        {
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (StringUtils.isBlank(key))
            {
                return;
            }
            if (null != value && value.length != 0)
            {
                Logger logger = LogManager.getLogger(clazz);
                logger.error("{}:{}", key, value);
            }
        }
    }

使用方式很简单，直接复制上面的类到你的工程。使用示例：

//最简单的使用
    LoggerUtils.info("我是日志");
    
    //加上class出处
    LoggerUtils.info(getClass(), "我是日志");
    
    //debug级别
    LoggerUtils.debug(getClass(), "我是debug日志");
    
    //error级别
    LoggerUtils.error(clazz, "我是error日志");
    
    //error级别，并打印异常
    LoggerUtils.error(clazz, "我是error日志",Exception e);
    
    //自定义输出信息
    LoggerUtils.fmtInfo(getClass(),String key,Object... value);
    
    //...............