精华内容
参与话题
问答
  • springboot整合kafka实现logback收集日志

    万次阅读 2018-06-25 19:38:53
    springboot中实现logback收集日志输出到kafka 异常容错机制,如果kafka服务宕机,输出到本地文件,可用其他方式重新加载local中的数据记录; 效率比对下:也可以尝试直接用kafka客户端写入到kafka中,手动针对异常做容错...

    springboot实现logback收集日志输出到kafka

    异常容错机制,如果kafka服务宕机,输出到本地文件,可用其他方式重新加载local中的数据记录;

    效率比对下:也可以尝试直接用kafka客户端写入到kafka中,手动针对异常做容错(如,写入文件)

    • 1.pom依赖
    • 2.logback.xml配置
    • 3.自定义KafkaAppender
    • 4.测试代码

    1.kafka相关pom依赖:(0.10.1.1版本)

    <dependency>
    	<groupId>org.apache.kafka</groupId>
    	<artifactId>kafka-clients</artifactId>
    	<version>${kafka.client.version}</version>
    	<scope>compile</scope>
    	<exclusions>
    		<exclusion>
    			<artifactId>slf4j-api</artifactId>
    			<groupId>org.slf4j</groupId>
    		</exclusion>
    	</exclusions>
    </dependency>
    <dependency>
    	<groupId>org.apache.kafka</groupId>
    	<artifactId>kafka_2.11</artifactId>
    	<version>${kafka.client.version}</version>
    	<exclusions>
    		<exclusion>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    		</exclusion>
    	</exclusions>
    </dependency>
    

    sl4j依赖,自行选择;此处整合springboot,未单独引入

    2.logback的配置

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    	<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径 -->
    	<property name="LOG_HOME" value="logs" />
    	<property name="SYS_NAME" value="system" />
    	<property name="DATA_NAME" value="data" />
    	<property name="APP_LOGS_FILENAME" value="app" />
    	<property name="EVENT_LOGS_FILENAME" value="event_loss_data" />
       <!--  <springProperty scope="context" name="APP_LOGS_FILENAME" source="logback.filename.applogs"/>
        <springProperty scope="context" name="EVENT_LOGS_FILENAME" source="logback.filename.eventlogs"/> -->
    
    	<appender name="CONSOLE"
    		class="ch.qos.logback.core.ConsoleAppender">
    		<layout class="ch.qos.logback.classic.PatternLayout">
    			<pattern>[%d] [%-5level] [%thread] [%logger] - %msg%n</pattern>
    		</layout>
    	</appender>
    	
    	<appender name="FILE"
    		class="ch.qos.logback.core.rolling.RollingFileAppender">
    		<rollingPolicy
    			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
    			<!--日志文件输出的文件名 -->
    			<FileNamePattern>${LOG_HOME}/${SYS_NAME}/${APP_LOGS_FILENAME}.%d{yyyy-MM-dd}.log
    			</FileNamePattern>
    			<!--日志文件保留天数 -->
    			<MaxHistory>10</MaxHistory>
    		</rollingPolicy>
    
    		<layout class="ch.qos.logback.classic.PatternLayout">
    			<pattern>[%d] [%-5level] [%thread] [%logger] - %msg%n</pattern>
    		</layout>
    		<!--日志文件最大的大小 -->
    		<triggeringPolicy
    			class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
    			<MaxFileSize>100MB</MaxFileSize>
    		</triggeringPolicy>
    	</appender>
    
    
    	<!-- 业务日志:写入kafka -->
    	<appender name="KAFKA-EVENTS"
    		class="com.demo.kafka.logs.KafkaAppender">
    		<layout class="ch.qos.logback.classic.PatternLayout">
    			<pattern>%msg</pattern>
    		</layout>
    	</appender>
    
    	<appender name="ASYNC-KAFKA-EVENTS"
    		class="ch.qos.logback.classic.AsyncAppender">
    		<discardingThreshold>0</discardingThreshold>
    		<queueSize>2048</queueSize>
    		<appender-ref ref="KAFKA-EVENTS" />
    	</appender>
    
    	<logger name="kafka-event" additivity="false">
    		<appender-ref ref="ASYNC-KAFKA-EVENTS" />
    	</logger>
    
    	<!-- 业务日志:异常 写入本地 -->
    	<appender name="LOCAL"
    		class="ch.qos.logback.core.rolling.RollingFileAppender">
    		<rollingPolicy
    			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!-- 基于时间的策略 -->
    			<fileNamePattern>${LOG_HOME}/${DATA_NAME}/${EVENT_LOGS_FILENAME}.%d{yyyy-MM-dd}.log
    			</fileNamePattern>
    			<!-- 日志文件保留天数 -->
    			<MaxHistory>10</MaxHistory>
    		</rollingPolicy>
    		<triggeringPolicy
    			class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
    			<!-- 文件大小触发重写新文件 -->
    			<MaxFileSize>100MB</MaxFileSize>
    			<!-- <totalSizeCap>10GB</totalSizeCap> -->
    		</triggeringPolicy>
    		<encoder>
    			<charset>UTF-8</charset>
    			<pattern>[%d] [%-5level] [%thread] [%logger] - %msg%n</pattern>
    		</encoder>
    	</appender>
    	<appender name="ASYNC-LOCAL"
    		class="ch.qos.logback.classic.AsyncAppender">
    		<discardingThreshold>0</discardingThreshold>
    		<queueSize>2048</queueSize>
    		<appender-ref ref="LOCAL" />
    	</appender>
    
    	<!--万一kafka队列不通,记录到本地 -->
    	<logger name="local" additivity="false">
    		<appender-ref ref="ASYNC-LOCAL" />
    	</logger>
    
    	<root level="INFO">
    		<appender-ref ref="CONSOLE" />
    		<appender-ref ref="FILE" />
    	</root>
    	<logger name="org.apache.kafka" level="DEBUG">
    	</logger>
    	<logger name="org.apache.zookeeper" level="DEBUG">
    	</logger>
    
    </configuration>
    

    3.自定义KafkaAppender

    上述logback.xml中的com.demo.kafka.logs.KafkaAppender

    package com.demo.kafka.logs;
    
    import org.apache.kafka.clients.producer.Callback;
    import org.apache.kafka.clients.producer.Producer;
    import org.apache.kafka.clients.producer.ProducerRecord;
    import org.apache.kafka.clients.producer.RecordMetadata;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.util.Assert;
    
    import com.demo.kafka.KafkaConfigUtils;
    
    import ch.qos.logback.core.AppenderBase;
    import ch.qos.logback.core.Layout;
    
    public class KafkaAppender<E> extends AppenderBase<E> {
    	//此处,logback.xml中的logger的name属性,输出到本地
    	private static final Logger log = LoggerFactory.getLogger("local");
    	protected Layout<E> layout;
    	private Producer<String, String> producer;//kafka生产者
    
    	@Override
    	public void start() {
    		Assert.notNull(layout, "you don't set the layout of KafkaAppender");
    		super.start();
    		this.producer = KafkaConfigUtils.createProducer();
    	}
    
    	@Override
    	public void stop() {
    		super.stop();
    		producer.close();
    		System.out.println("[Stopping KafkaAppender !!!]");
    	}
    
    	@Override
    	protected void append(E event) {
    		String msg = layout.doLayout(event);
    		//拼接消息内容
    		ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(
    				KafkaConfigUtils.DEFAULT_TOPIC_NAME, msg);
    		System.out.println("[推送数据]:" + producerRecord);
    		//发送kafka的消息
    		producer.send(producerRecord, new Callback() {
    			@Override
    			public void onCompletion(RecordMetadata metadata, Exception exception) {
    				//监听发送结果
    				if (exception != null) {
    					exception.printStackTrace();
    					log.info(msg);
    				} else {
    					System.out.println("[推送数据到kafka成功]:" + metadata);
    				}
    			}
    		});
    	}
    	public Layout<E> getLayout() {
    		return layout;
    	}
    	public void setLayout(Layout<E> layout) {
    		this.layout = layout;
    	}
    
    }
    
    

    4.测试代码段

    //logback.xml中logger的name属性(输出到kafka)
    private static final Logger log = LoggerFactory.getLogger("kafka-event");
    	@Override
    	public void produce(String msgContent) {
    		if (StringUtils.isEmpty(msgContent)) {
    			return;
    		}
    		//打印日志
    		log.info(msgContent);
    	}
    
    

    公众号文章链接:

    https://mp.weixin.qq.com/s/NjHrSYIWWTqNRYx3hKH1Zg

    源码地址

    github:springboot-kafka-logs源码地址

    公众号搜索:DeanKano
    企鹅群号: 561932405

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • logback

    千次阅读 2019-09-06 14:19:22
    logback 1.性能比log4j要好 2.配置获取顺序 logback在启动的时候,会按照下面的顺序加载配置文件 1.如果java程序启动时指定了logback.configurationFile属性,就用该属性指定的配置文件。如java -Dlogback....

    logback

    1.性能比log4j要好

    2.配置获取顺序

    	logback在启动的时候,会按照下面的顺序加载配置文件
    	1.如果java程序启动时指定了logback.configurationFile属性,就用该属性指定的配置文件。如java -Dlogback.configurationFile=/path/to/mylogback.xml Test ,这样执行Test类的时候就会加载/path/to/mylogback.xml配置
    	2.在classpath中查找 logback.groovy 文件
    	3.在classpath中查找 logback-test.xml 文件
    	4.在classpath中查找 logback.xml 文件
    

    3.logger以及root节点

    	root节点和logger节点其实都是表示Logger组件。个人觉的可以把他们之间的关系可以理解为父子关系,root是最顶层的logger,正常情况getLogger("name/class")没有找到对应logger的情况下,都是使用root节点配置的logger。
    	如果配置了logger,并且通过getLogger("name/class")获取到这个logger,输出日志的时候,就会使用这个logger配置的appender输出,同时还会使用rootLogger配置的appender。我们可以使用logger节点的additivity="false"属性来屏蔽rootLogger的appender。这样就可以不使用rootLogger的appender输出日志了。
    	关于logger的获取,一般logger是配置name的。我们再代码中经常通过指定的CLass来获取Logger,比如这样LoggerFactory.getLogger(Test.class);,其实这个最后也是转成对应的包名+类名的字符串com.kongtrio.Test.class。假设有一个logger配置的那么是com.kongtrio,那么通过LoggerFactory.getLogger(Test.class)获取到的logger就是这个logger。
    

    4.具体配置demo(单独某个或者某些class生成日志文件)

    <?xml version="1.0" encoding="UTF-8"?>
    <!--configuration节点相关属性-->
    <!--debug	false	要不要打印 logback内部日志信息,true则表示要打印。建议开启-->
    <!--scan	true	配置发送改变时,要不要重新加载-->
    <!--scanPeriod	1 seconds	检测配置发生变化的时间间隔。如果没给出时间单位,默认时间单位是毫秒-->
    <configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!--configuration子节点介绍-->
        <!--contextName节点 设置日志上下文名称,后面输出格式中可以通过定义 %contextName 来打印日志上下文名称-->
        <!--property节点 用来设置相关变量,通过key-value的方式配置,然后在后面的配置文件中通过 ${key}来访问-->
        <!--appender节点 日志输出组件,主要负责日志的输出以及格式化日志。常用的属性有name和class-->
            <!--name	无默认值	appender组件的名称,后面给logger指定appender使用-->
            <!--class	无默认值	appender的具体实现类。常用的有 ConsoleAppender、FileAppender、RollingFileAppender-->
                <!--ConsoleAppender:向控制台输出日志内容的组件,只要定义好encoder节点就可以使用。-->
                <!--FileAppender:向文件输出日志内容的组件,用法也很简单,不过由于没有日志滚动策略,一般很少使用-->
                <!--RollingFileAppender:向文件输出日志内容的组件,同时可以配置日志文件滚动策略,在日志达到一定条件后生成一个新的日志文件。-->
    <contextName>bm</contextName>
    <property name="log.path" value="log" />
    <property name="log.maxHistory" value="15" />
    <property name="log.colorPattern" value="%d{yyyy-MM-dd HH:mm:ss} | %highlight(%-5level) | %boldYellow(%thread) | %boldGreen(%logger) | %msg%n"/>
    <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n" />
    
    <!--输出到控制台-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log.colorPattern}</pattern>
        </encoder>
    </appender>
    
    <!--输出到文件-->
    <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--定义文件滚动时的文件名的格式-->
            <fileNamePattern>${log.path}/info/info.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!--15天的时间周期,日志量最大20GB-->
            <!--<MaxHistory>${log.maxHistory}</MaxHistory>-->
            <!--<totalSizeCap>20GB</totalSizeCap>-->
        </rollingPolicy>
        <encoder>
            <!--定义控制台输出格式-->
            <pattern>${log.pattern}</pattern>
        </encoder>
        <!--定义了一个过滤器,在LEVEL之下的日志输出不会被打印出来-在slf4j中,从小到大的日志级别依旧是trace、debug、info、warn、error -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    
    <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/error.%d{yyyy-MM-dd}.log</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    
    <!--root是默认的logger 这里设定输出级别是debug-->
    <root level="debug">
        <appender-ref ref="console" />
    </root>
    
    <root level="info">
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
    </root>
    
    <!--单独某个或者某些class生成日志文件 结算日志文件-->
    <appender name="SettlementDetailControllerAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/moneyCount/error.%d{yyyy-MM-dd}.log</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!--additivity 子Logger 是否继承 root的Logger 的 输出源(appender) 的标志位 如果没有设置 additivity="false" ,就会导致一条日志在控制台输出两次的情况-->
    <logger name="com.sunits.bm.settlement.controller.SettlementDetailController" level="${logging.level}" additivity="false">
        <appender-ref ref="SettlementDetailControllerAppender" />
    </logger>
    

    5.方法内日志单独保存到相关文件

    1.xml建立相关logger
    	<logger name="testlog" level="${logging.level}" additivity="false">
    		<appender-ref ref="SettlementDetailControllerAppender" />
    	</logger>
    2.在相关方法或者类中中写上  Logger testlog = LoggerFactory.getLogger("testlog"); 然后开始使用即可
    
    展开全文
  • LogBack

    千次阅读 2018-03-30 18:13:40
    一、logback的介绍 Logback是由log4j创始人设计的另一个开源日志组件,官方网站: http://logback.qos.ch。 它当前分为下面下个模块: logback-core:其它两个模块的基础模块 logback-classic:它是log4j的一...

    一、logback的介绍

    Logback是由log4j创始人设计的另一个开源日志组件,官方网站:
    http://logback.qos.ch
    它当前分为下面下个模块:   logback-core:其它两个模块的基础模块
    logback-classic:它是log4j的一个改良版本,同时它完整实现了slf4j
    API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging
    logback-access:访问模块与Servlet容器集成提供通过Http来访问日志的功能

    二、logback取代log4j的理由:

    1、更快的实现:Logback的内核重写了,在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了,初始化内存加载也更小了。

    2、非常充分的测试:Logback经过了几年,数不清小时的测试。Logback的测试完全不同级别的。

    3、Logback-classic非常自然实现了SLF4j:Logback-classic实现了SLF4j。在使用SLF4j中,你都感觉不到logback-classic。而且因为logback-classic非常自然地实现了slf4j , 所 以切换到log4j或者其他,非常容易,只需要提供成另一个jar包就OK,根本不需要去动那些通过SLF4JAPI实现的代码。

    4、非常充分的文档 官方网站有两百多页的文档。

    5、自动重新加载配置文件,当配置文件修改了,Logback-classic能自动重新加载配置文件。扫描过程快且安全,它并不需要另外创建一个扫描线程。这个技术充分保证了应用程序能跑得很欢在JEE环境里面。

    6、Lilith是log事件的观察者,和log4j的chainsaw类似。而lilith还能处理大数量的log数据 。

    7、谨慎的模式和非常友好的恢复,在谨慎模式下,多个FileAppender实例跑在多个JVM下,能够安全地写道同一个日志文件。RollingFileAppender会有些限制。Logback的FileAppender和它的子类包括RollingFileAppender能够非常友好地从I/O异常中恢复。

    8、配置文件可以处理不同的情况,开发人员经常需要判断不同的Logback配置文件在不同的环境下(开发,测试,生产)。而这些配置文件仅仅只有一些很小的不同,可以通过,和来实现,这样一个配置文件就可以适应多个环境。

    9、Filters(过滤器)有些时候,需要诊断一个问题,需要打出日志。在log4j,只有降低日志级别,不过这样会打出大量的日志,会影响应用性能。在Logback,你可以继续保持那个日志级别而除掉某种特殊情况,如alice这个用户登录,她的日志将打在DEBUG级别而其他用户可以继续打在WARN级别。要实现这个功能只需加4行XML配置。可以参考MDCFIlter 。

    10、SiftingAppender(一个非常多功能的Appender):它可以用来分割日志文件根据任何一个给定的运行参数。如,SiftingAppender能够区别日志事件跟进用户的Session,然后每个用户会有一个日志文件。

    11、自动压缩已经打出来的log:RollingFileAppender在产生新文件的时候,会自动压缩已经打出来的日志文件。压缩是个异步过程,所以甚至对于大的日志文件,在压缩过程中应用不会受任何影响。

    12、堆栈树带有包版本:Logback在打出堆栈树日志时,会带上包的数据。

    13、自动去除旧的日志文件:通过设置TimeBasedRollingPolicy或者SizeAndTimeBasedFNATP的maxHistory属性,你可以控制已经产生日志文件的最大数量。如果设置maxHistory

    12,那那些log文件超过12个月的都会被自动移除。

    三、logback的配置介绍

    1、Logger、appender及layout
    Logger作为日志的记录器,把它关联到应用的对应的context上后,主要用于存放日志对象,也可以定义日志类型、级别。 Appender主要用于指定日志输出的目的地,目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。 Layout 负责把事件转换成字符串,格式化的日志信息的输出。

    2、logger context 各个logger 都被关联到一个 LoggerContext,LoggerContext负责制造logger,也负责以树结构排列各logger。其他所有logger也通过org.slf4j.LoggerFactory类的静态方法getLogger取得。 getLogger方法以logger名称为参数。用同一名字调用LoggerFactory.getLogger 方法所得到的永远都是同一个logger对象的引用。

    3、有效级别及级别的继承 Logger 可以被分配级别。级别包括:TRACE、DEBUG、INFO、WARN 和 ERROR,定义于ch.qos.logback.classic.Level类。如果logger没有被分配级别,那么它将从有被分配级别的最近的祖先那里继承级别。root logger 默认级别是 DEBUG。

    4、打印方法与基本的选择规则 打印方法决定记录请求的级别。例如,如果 L 是一个 logger 实例,那么,语句 L.info(“..”)是一条级别为 INFO的记录语句。记录请求的级别在高于或等于其 logger 的有效级别时被称为被启用,否则,称为被禁用。记录请求级别为 p,其 logger的有效级别为 q,只有则当 p>=q时,该请求才会被执行。该规则是 logback 的核心。级别排序为: TRACE < DEBUG < INFO < WARN < ERROR

    四、logback的默认配置

    如果配置文件 logback-test.xml 和 logback.xml 都不存在,那么 logback 默认地会调用BasicConfigurator ,创建一个最小化配置。最小化配置由一个关联到根 logger 的ConsoleAppender 组成。输出用模式为%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 的 PatternLayoutEncoder 进行格式化。root logger 默认级别是 DEBUG。

      1、Logback的配置文件

    Logback 配置文件的语法非常灵活。正因为灵活,所以无法用 DTD 或 XML schema
    进行定义。尽管如此,可以这样描述配置文件的基本结构:以开头,后面有零个或多个<appender>元素,有零个或多个<logger>元素,有最多一个<root>元素。

      2、Logback默认配置的步骤
       

     (1). 尝试在 classpath下查找文件logback-test.xml;
     (2). 如果文件不存在,则查找文件logback.xml;
     (3). 如果两个文件都不存在,logback用BasicConfigurator自动对自己进行配置,这会导致记录输出到控制台。

    五、logback.xml常用配置详解

      1、根节点<configuration>,包含下面三个属性:

    scan: 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
        scanPeriod: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。
        debug: 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。

      例如:
        

    <configuration scan="true" scanPeriod="60 seconds" debug="false"> 
          <!--其他配置省略--> 
        </configuration>

      2、子节点<contextName>:用来设置上下文名称,每个logger都关联到logger上下文,默认上下文名称为default。但可以使用设置成其他名字,用于区分不同应用程序的记录。一旦设置,不能修改。
      例如:

     <configuration scan="true" scanPeriod="60 seconds" debug="false"> 
          <contextName>myAppName</contextName> 
          <!--其他配置省略-->
        </configuration>    

      3、子节点<property> :用来定义变量值,它有两个属性name和value,通过<property>定义的值会被插入到logger上下文中,可以使“${}”来使用变量。
        name: 变量的名称
        value: 的值时变量定义的值
      例如:

    <configuration scan="true" scanPeriod="60 seconds" debug="false"> 
          <property name="APP_Name" value="myAppName" /> 
          <contextName>${APP_Name}</contextName> 
          <!--其他配置省略--> 
        </configuration>

      4、子节点<timestamp>:获取时间戳字符串,他有两个属性key和datePattern
        key: 标识此<timestamp> 的名字;
        datePattern: 设置将当前时间(解析配置文件的时间)转换为字符串的模式,遵循java.txt.SimpleDateFormat的格式。
      例如:

    <configuration scan="true" scanPeriod="60 seconds" debug="false"> 
          <timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/> 
          <contextName>${bySecond}</contextName> 
          <!-- 其他配置省略--> 
        </configuration>

      5、子节点<appender>:负责写日志的组件,它有两个必要属性name和class。name指定appender名称,class指定appender的全限定名
        5.1、ConsoleAppender 把日志输出到控制台,有以下子节点:
          <encoder>:对日志进行格式化。(具体参数稍后讲解 )
          <target>:字符串System.out(默认)或者System.err(区别不多说了)
        例如:

    <configuration> 
          <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> 
          <encoder> 
            <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern> 
          </encoder> 
          </appender> 
    
          <root level="DEBUG"> 
            <appender-ref ref="STDOUT" /> 
          </root> 
        </configuration>
        上述配置表示把>=DEBUG级别的日志都输出到控制台

    5.2、FileAppender:把日志添加到文件,有以下子节点:
          <file>:被写入的文件名,可以是相对目录,也可以是绝对目录,如果上级目录不存在会自动创建,没有默认值。
          <append>:如果是 true,日志被追加到文件结尾,如果是 false,清空现存文件,默认是true。
          <encoder>:对记录事件进行格式化。(具体参数稍后讲解 )
          <prudent>:如果是 true,日志会被安全的写入文件,即使其他的FileAppender也在向此文件做写入操作,效率低,默认是 false。
        例如:
        

    <configuration> 
          <appender name="FILE" class="ch.qos.logback.core.FileAppender"> 
            <file>testFile.log</file> 
            <append>true</append> 
            <encoder> 
              <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern> 
            </encoder> 
          </appender> 
    
          <root level="DEBUG"> 
          <appender-ref ref="FILE" /> 
          </root> 
        </configuration>
        上述配置表示把>=DEBUG级别的日志都输出到testFile.log

        5.3、RollingFileAppender:滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件。有以下子节点:
         <file>:被写入的文件名,可以是相对目录,也可以是绝对目录,如果上级目录不存在会自动创建,没有默认值。
         <append>:如果是 true,日志被追加到文件结尾,如果是 false,清空现存文件,默认是true。
         <rollingPolicy>:当发生滚动时,决定RollingFileAppender的行为,涉及文件移动和重命名。属性class定义具体的滚动策略类
         class=”ch.qos.logback.core.rolling.TimeBasedRollingPolicy”: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责出发滚动。有以下子节点:
         <fileNamePattern>:必要节点,包含文件名及“%d”转换符,“%d”可以包含一个java.text.SimpleDateFormat指定的时间格式,如:%d{yyyy-MM}。
    如果直接使用 %d,默认格式是 yyyy-MM-dd。RollingFileAppender的file字节点可有可无,通过设置file,可以为活动文件和归档文件指定不同位置,当前日志总是记录到file指定的文件(活动文件),活动文件的名字不会改变;如果没设置file,活动文件的名字会根据fileNamePattern 的值,每隔一段时间改变一次。“/”或者“\”会被当做目录分隔符。
          <maxHistory>:可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。假设设置每个月滚动,且是6,则只保存最近6个月的文件,删除之前的旧文件。注意,删除旧文件是,那些为了归档而创建的目录也会被删除。class=”ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy”: 查看当前活动文件的大小,如果超过指定大小会告知RollingFileAppender 触发当前活动文件滚动。只有一个节点:
          <maxFileSize>:这是活动文件的大小,默认值是10MB。
       <prudent>:当为true时,不支持FixedWindowRollingPolicy。支持TimeBasedRollingPolicy,但是有两个限制,1不支持也不允许文件压缩,2不能设置file属性,必须留空。
         <triggeringPolicy >: 告知 RollingFileAppender 合适激活滚动。
    class=”ch.qos.logback.core.rolling.FixedWindowRollingPolicy” 根据固定窗口算法重命名文件的滚动策略。有以下子节点:
         <minIndex>:窗口索引最小值
         <maxIndex>:窗口索引最大值,当用户指定的窗口过大时,会自动将窗口设置为12。
         <fileNamePattern>:必须包含“%i”例如,假设最小值和最大值分别为1和2,命名模式为 mylog%i.log,会产生归档文件mylog1.log和mylog2.log。还可以指定文件压缩选项,例如,mylog%i.log.gz 或者 没有log%i.log.zip
          例如:

     <configuration> 
              <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
                <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> 
                  <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern> 
                  <maxHistory>30</maxHistory> 
                </rollingPolicy> 
                <encoder> 
                  <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern> 
                </encoder> 
              </appender> 
    
              <root level="DEBUG"> 
                <appender-ref ref="FILE" /> 
              </root> 
            </configuration>
            上述配置表示每天生成一个日志文件,保存30天的日志文件。
            <configuration> 
              <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
                <file>test.log</file> 
    
                <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy"> 
                  <fileNamePattern>tests.%i.log.zip</fileNamePattern> 
                  <minIndex>1</minIndex> 
                  <maxIndex>3</maxIndex> 
                </rollingPolicy> 
    
                <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"> 
                  <maxFileSize>5MB</maxFileSize> 
                </triggeringPolicy> 
                <encoder> 
                  <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern> 
                </encoder> 
              </appender> 
    
              <root level="DEBUG"> 
                <appender-ref ref="FILE" /> 
              </root> 
            </configuration>

     上述配置表示按照固定窗口模式生成日志文件,当文件大于20MB时,生成新的日志文件。窗口大小是1到3,当保存了3个归档文件后,将覆盖最早的日志。
     
         <encoder>:对记录事件进行格式化。负责两件事,一是把日志信息转换成字节数组,二是把字节数组写入到输出流。
    PatternLayoutEncoder 是唯一有用的且默认的encoder ,有一个节点,用来设置日志的输入格式。使用“%”加“转换符”方式,如果要输出“%”,则必须用“\”对“\%”进行转义。
        5.4、还有SocketAppender、SMTPAppender、DBAppender、SyslogAppender、SiftingAppender,并不常用,这里就不详解了。
    大家可以参考官方文档(http://logback.qos.ch/documentation.html),还可以编写自己的Appender。
      6、子节点<loger>:用来设置某一个包或具体的某一个类的日志打印级别、以及指定<appender><loger>仅有一个name属性,一个可选的level和一个可选的addtivity属性。
    可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个loger
        name: 用来指定受此loger约束的某一个包或者具体的某一个类。
        level: 用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF,还有一个特俗值INHERITED或者同义词NULL,代表强制执行上级的级别。 如果未设置此属性,那么当前loger将会继承上级的级别。
    addtivity: 是否向上级loger传递打印信息。默认是true。同<loger>一样,可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个loger。
      7、子节点<root>:它也是<loger>元素,但是它是根loger,是所有<loger>的上级。只有一个level属性,因为name已经被命名为”root”,且已经是最上级了。
       level: 用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF,不能设置为INHERITED或者同义词NULL。 默认是DEBUG。

    logback.xml实例:

    <?xml version="1.0" encoding="UTF-8"?>  
    <configuration>  
    
        <!-- 尽量别用绝对路径,如果带参数不同容器路径解释可能不同,以下配置参数在pom.xml里 -->  
        <!--<property name="log.root.level" value="DEBUG"/> 日志级别  
        <property name="log.other.level" value="DEBUG"/> 其他日志级别   -->
        <!--<property name="log.base" value="logs"/> 日志路径,这里是相对路径,web项目eclipse下会输出到eclipse的安装目录下,如果部署到linux上的tomcat下,会输出到tomcat/bin目录 下  
        <property name="log.moduleName" value="OALog"/>  模块名称, 影响日志配置名,日志文件名  
        <property name="log.max.size" value="100MB"/> 日志文件大小  
        -->
    
        <!--控制台输出 -->  
        <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">  
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">  
                <Pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</Pattern>  
            </encoder>  
        </appender>
        q
        <!-- 日志文件输出 -->
        <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">  
            <File>D:/logs/OALog.log</File>
    
            <!-- 设置日志不超过${log.max.size}时的保存路径,注意如果 是web项目会保存到Tomcat的bin目录 下 -->  
            <!-- 滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件。-->  
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  
                <FileNamePattern>D:/logs/archive/OALog_all_%d{yyyy-MM-dd}.%i.log.zip  
                </FileNamePattern>  
                <!-- 当天的日志大小 超过${log.max.size}时,压缩日志并保存 -->  
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">  
                    <maxFileSize>100MB</maxFileSize>  
                </timeBasedFileNamingAndTriggeringPolicy>  
            </rollingPolicy>  
    
            <!-- 日志输出的文件的格式  -->  
            <layout class="ch.qos.logback.classic.PatternLayout">  
                <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</pattern>  
            </layout>
        </appender>
    
        <!-- 为某个包下的所有类的指定Appender 这里也可以指定类名称例如:com.aa.bb.ClassName -->  
        <logger name="cn.*" additivity="false">
            <level value="debug" />
            <appender-ref ref="stdout" />
            <appender-ref ref="file" />
        </logger>  
    
        <!-- root将级别为“DEBUG”及大于“DEBUG”的日志信息交给已经配置好的名为“Console”的appender处理,“Console”appender将信息打印到Console -->  
        <root level="debug">  
            <appender-ref ref="stdout" /> <!-- 标识这个appender将会添加到这个logger -->  
            <appender-ref ref="file" />  
        </root>  
    
    </configuration>  
    展开全文
  • Logback

    2016-01-21 15:15:33
    一、logback的介绍  Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是...

    一、logback的介绍

         Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-classic完整实现SLF4J API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging。logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。 Logback是要与SLF4J结合起来用两个组件的官方网站如下:

        logback的官方网站: http://logback.qos.ch

        SLF4J的官方网站:http://www.slf4j.org

        本文章用到的组件如下:请自行到官方网站下载!

        logback-access-1.0.0.jar

        logback-classic-1.0.0.jar

        logback-core-1.0.0.jar

        slf4j-api-1.6.0.jar

    二、logback取代 log4j的理由:

        Logback和log4j是非常相似的,如果你对log4j很熟悉,那对logback很快就会得心应手。下面列了logback相对于log4j的一些优点:

        1、更快的实现  Logback的内核重写了,在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了,初始化内存加载也更小了。

        2、非常充分的测试  Logback经过了几年,数不清小时的测试。Logback的测试完全不同级别的。在作者的观点,这是简单重要的原因选择logback而不是log4j。

        3、Logback-classic非常自然实现了SLF4j    Logback-classic实现了 SLF4j。在使用SLF4j中,你都感觉不到logback-classic。而且因为logback-classic非常自然地实现了SLF4J,  所 以切换到log4j或者其他,非常容易,只需要提供成另一个jar包就OK,根本不需要去动那些通过SLF4JAPI实现的代码。

        4、非常充分的文档  官方网站有两百多页的文档。

        5、自动重新加载配置文件  当配置文件修改了,Logback-classic能自动重新加载配置文件。扫描过程快且安全,它并不需要另外创建一个扫描线程。这个技术充分保证了应用程序能跑得很欢在JEE环境里面。

        6、Lilith   Lilith是log事件的观察者,和log4j的chainsaw类似。而lilith还能处理大数量的log数据 。

        7、谨慎的模式和非常友好的恢复  在谨慎模式下,多个FileAppender实例跑在多个JVM下,能 够安全地写道同一个日志文件。RollingFileAppender会有些限制。Logback的FileAppender和它的子类包括 RollingFileAppender能够非常友好地从I/O异常中恢复。

        8、配置文件可以处理不同的情况   开发人员经常需要判断不同的Logback配置文件在不同的环境下(开发,测试,生产)。而这些配置文件仅仅只有一些很小的不同,可以通过,和来实现,这样一个配置文件就可以适应多个环境。

        9、Filters(过滤器)  有些时候,需要诊断一个问题,需要打出日志。在log4j,只有降低日志级别,不过这样会打出大量的日志,会影响应用性能。在Logback,你可以继续 保持那个日志级别而除掉某种特殊情况,如alice这个用户登录,她的日志将打在DEBUG级别而其他用户可以继续打在WARN级别。要实现这个功能只需 加4行XML配置。可以参考MDCFIlter 。

       10、SiftingAppender(一个非常多功能的Appender)  它可以用来分割日志文件根据任何一个给定的运行参数。如,SiftingAppender能够区别日志事件跟进用户的Session,然后每个用户会有一个日志文件。

       11、自动压缩已经打出来的log  RollingFileAppender在产生新文件的时候,会自动压缩已经打出来的日志文件。压缩是个异步过程,所以甚至对于大的日志文件,在压缩过程中应用不会受任何影响。

       12、堆栈树带有包版本  Logback在打出堆栈树日志时,会带上包的数据。

       13、自动去除旧的日志文件  通过设置TimeBasedRollingPolicy或者SizeAndTimeBasedFNATP的maxHistory属性,你可以控制已经产生日志文件的最大数量。如果设置maxHistory 12,那那些log文件超过12个月的都会被自动移除。

        总之,logback比log4j太优秀了,让我们的应用全部建立logback上吧 !

    、Logback的配置介绍

        1、Logger、appender及layout

           Logger作为日志的记录器,把它关联到应用的对应的context上后,主要用于存放日志对象,也可以定义日志类型、级别。

        Appender主要用于指定日志输出的目的地,目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。 

        Layout 负责把事件转换成字符串,格式化的日志信息的输出。

         2、logger context

           各个logger 都被关联到一个 LoggerContext,LoggerContext负责制造logger,也负责以树结构排列各logger。其他所有logger也通过org.slf4j.LoggerFactory 类的静态方法getLogger取得。 getLogger方法以 logger名称为参数。用同一名字调用LoggerFactory.getLogger 方法所得到的永远都是同一个logger对象的引用。

       3、有效级别及级别的继承

          Logger 可以被分配级别。级别包括:TRACE、DEBUG、INFO、WARN 和 ERROR,定义于ch.qos.logback.classic.Level类。如果 logger没有被分配级别,那么它将从有被分配级别的最近的祖先那里继承级别。root logger 默认级别是 DEBUG。

       4、打印方法与基本的选择规则

        打印方法决定记录请求的级别。例如,如果 L 是一个 logger 实例,那么,语句 L.info("..")是一条级别为 INFO的记录语句。记录请求的级别在高于或等于其 logger 的有效级别时被称为被启用,否则,称为被禁用。记录请求级别为 p,其 logger的有效级别为 q,只有则当 p>=q时,该请求才会被执行。

        该规则是 logback 的核心。级别排序为: TRACE < DEBUG < INFO < WARN < ERROR

     

    四、Logback的默认配置

          如果配置文件 logback-test.xml 和 logback.xml 都不存在,那么 logback 默认地会调用BasicConfigurator ,创建一个最小化配置。最小化配置由一个关联到根 logger 的ConsoleAppender 组成。输出用模式为%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 的 PatternLayoutEncoder 进行格式化。root logger 默认级别是 DEBUG。

         1、Logback的配置文件

          Logback 配置文件的语法非常灵活。正因为灵活,所以无法用 DTD 或 XML schema 进行定义。尽管如此,可以这样描述配置文件的基本结构:以<configuration>开头,后面有零个或多个<appender>元素,有零个或多个<logger>元素,有最多一个<root>元素。

         2、Logback默认配置的步骤

         (1). 尝试在 classpath 下查找文件 logback-test.xml;

         (2). 如果文件不存在,则查找文件 logback.xml;

         (3). 如果两个文件都不存在,logback 用 Bas icConfigurator 自动对自己进行配置,这会导致记录输出到控制台。

        3、Logback.xml 文件     

      

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->  
        <property name="LOG_HOME" value="c:/log" />  
        <!-- 控制台输出 -->   
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           <!-- 日志输出编码 -->  
           <Encoding>UTF-8</Encoding>   
            <layout class="ch.qos.logback.classic.PatternLayout">   
                 <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符--> 
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   
                </pattern>   
            </layout>   
        </appender>   
        <!-- 按照每天生成日志文件 -->   
        <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">   
            <Encoding>UTF-8</Encoding>   
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!--日志文件输出的文件名-->
                <FileNamePattern>${LOG_HOME}/myApp.log.%d{yyyy-MM-dd}.log</FileNamePattern>   
                <MaxHistory>30</MaxHistory>
            </rollingPolicy>   
            <layout class="ch.qos.logback.classic.PatternLayout">  
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符--> 
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n   
                </pattern>   
           </layout> 
            <!--日志文件最大的大小-->
           <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
             <MaxFileSize>10MB</MaxFileSize>
           </triggeringPolicy>
        </appender> 
       <!-- show parameters for hibernate sql 专为 Hibernate 定制 -->  
        <logger name="org.hibernate.type.descriptor.sql.BasicBinder"  level="TRACE" />  
        <logger name="org.hibernate.type.descriptor.sql.BasicExtractor"  level="DEBUG" />  
        <logger name="org.hibernate.SQL" level="DEBUG" />  
        <logger name="org.hibernate.engine.QueryParameters" level="DEBUG" />  
        <logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG" />  
        
        <!-- 日志输出级别 -->
        <root level="INFO">   
            <appender-ref ref="STDOUT" />   
            <appender-ref ref="FILE" />   
        </root> 
         
         <!--日志异步到数据库 -->  
        <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
            <!--日志异步到数据库 --> 
            <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
               <!--连接池 --> 
               <dataSource class="com.mchange.v2.c3p0.ComboPooledDataSource">
                  <driverClass>com.mysql.jdbc.Driver</driverClass>
                  <url>jdbc:mysql://127.0.0.1:3306/databaseName</url>
                  <user>root</user>
                  <password>root</password>
                </dataSource>
            </connectionSource>
      </appender> -->
    </configuration>



    五、在程序用引用Logback

    package com.stu.system.action; 
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class BlogAction{
         //定义一个全局的记录器,通过LoggerFactory获取
         private final static Logger logger = LoggerFactory.getLogger(BlogAction.class); 
         /**
         * @param args
         */
        public static void main(String[] args) {
            logger.info("logback 成功了");
            logger.error("logback 成功了");
        }
    }
    展开全文
  • Springboot-logback配色方案

    万次阅读 2020-05-13 10:19:39
    会根据spring.application.name 创建 log日志 直接创建该文件 文件内容如下: <?xml version="1.0" encoding="UTF-8"?> <configuration>...springProperty name="APP_NAME" scope="context" source=...
  • logback-Appender 自定义详解

    万次阅读 2017-07-19 11:31:32
    实际上Appender可能是logback框架中最重要的组件之一,虽然Logger是记录日志的接口,但是如果一个Logger没有关联到任何Appender的话,那么这个Logger就无法记录任何信息。此外虽然logback提供了很多扩展点,但是在...
  • logback.xml

    2019-08-20 23:22:20
    一个标准的logback.xml文件,eg:<!-- scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位...
  • spring配置logback出错

    2017-08-11 05:24:45
    <groupId>ch.qos.logback <artifactId>logback-classic <version>1.1.7 <groupId>ch.qos.logback <artifactId>logback-core <version>1.1.7 <groupId>org.logback-extensions <artifactId>logback-...
  • spring logback 日志文件

    2016-11-07 10:52:42
    <appender name="consoleAppender" class="ch.qos.logback.core.ConsoleAppender"> <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %...
  • 现在需要将logback的最大日志数量提高到40个,由于logback内部最大只支持20个,设置超过20后也只输出20个文件。 重写FixedWindowRollingPolicy类如下: package com.logback.test; import ch.qos.logback.core....
  • logback日志接入

    2015-07-30 17:29:37
    logback
  • 解决办法很简单,把logback.xml的dtd注释掉。 Java程序在解析xml文件时,如果xml文件中指定了dtd,在默认会从指定的url下载dtd文件,但是很多情况下如果网络连接不上,或者防火墙原因,dtd文件无法下载下来导致...

空空如也

1 2 3 4 5 ... 20
收藏数 18,979
精华内容 7,591
关键字:

logback