精华内容
下载资源
问答
  • 实际项目中经常会用到日志打印 为避免日志打印输出文件过大 消耗服务器内存 需要限制大小
  • Java日志文件

    千次阅读 2008-12-05 15:01:00
    1. 为什么要使用Java日志 在程序的开发过程中我们需要调试程序,这时我们通过建立日志文件来记录程序的异常信息,当然有人说我们可以在IDE环境中通过控制台来查看堆栈信息也是可以调试程序,甚至通过单步调试来进行。...
    1. 为什么要使用Java日志
    
        在程序的开发过程中我们需要调试程序,这时我们通过建立日志文件来记录程序的异常信息,当然有人说我们可以在IDE环境中通过控制台来查看堆栈信息也是可以调试程序,甚至通过单步调试来进行。没错,可是如果我们能够对异常信息进行保存那不是更好吗?所以Java日志的第一个作用就是在开发阶段记录程序的调试信息。
        另外更为重要的是在产品交付使用后,我们可以用日志文件来记录程序的运行期间所发生的问题,帮助我们跟踪程序的运行状态,用户的使用信息,以改进程序,这时日志的第二个作用

    2. Log4j的下载安装
        Log4j是Java最流行的日志处理框架,包括许多著名的开源项目都是通过Log4j来记录和管理日志信息的,例如Hibernate。那么到哪里去下载Log4j呢,我们可以在apache的网站上down一个Log4j,地址是:http://logging.apache.org/log4j/去下载,下载解压后将log4j-1.2.15.jar文件(注意1.2.15是版本号,你下载时可能有所区别)拷贝到你的程序的classpath中去,这样就可以使用log4j的日志功能了。

    3. Log4j的使用
    package liky.log;

    import java.util.Date;
    import org.apache.log4j.Logger;

    /**
     * 演示log4j的使用
     * @author 阿布
     *
     */
    public class MainClass {

        // 调用Logger的getLogger方法获得一个Logger的实例,在这个方法中通常传入当前要记录的类
        private static Logger log = Logger.getLogger(MainClass.class);

        /**
         * @param args
         */
        public static void main(String[] args) {
            log.info("程序开始运行"+ new Date().toString());
                    
            int result = 0;
            
            try {
                result = 4 / 0;
            } catch (Exception ex) {
                log.error("在获得两个数相除的结果时产生异常.", ex);
            }
            
            log.info("程序运行结束"+ new Date().toString());
        }
    }

    4. log4j的配置
       在上面的代码中如果运行就会在控制台上输出下列信息:
    log4j:WARN No appenders could be found for logger (liky.log.MainClass).
    log4j:WARN Please initialize the log4j system properly.

    这是因为你还没有配置log4j的配置文件,log4j的日志文件有两种格式,一种是java的属性文件.properties文件,另一种是.xml文件,这里我们以属性文件为例说明如何配置。
        首先在你当前的源代码src根目录下新建一个log4j.properties文件,然后在文件中输入下列内容:

    # log4j.rootLogger=level,appenderName1,...,appenderNameN
    # 表示日志记录所有包中的所有的类的日志,可以在同时声明多个日志,每个日志都可以单独配置

    # all:表示日志的级别,可用的选项有:all、trace、debug、info、warn、error、fatal、off
    # all表示输出所有信息,off表示任何信息都不记录,越往后级别越高,记录的信息越少

    log4j.rootLogger=all,root

    # log4j.logger.package: 如果只是记录一部分包的类的日志则使用log4j.logger.package
    # 例如:log4j.logger.liky.log.test就表示只记录liky.log包中的类的日志

    log4j.logger.liky.log.test=info,test

    # log4j.appender.appenderName=org.appender.log4j.Appender
    # 表示日志的输出到哪里,Appender表示org.appender.log4j这个包中实现了Appender接口的类
    # 实现了Appender接口的类有很多,最常用的有:
    # org.apache.log4j.ConsoleAppender:输出到控制台
    # org.apache.log4j.FileAppender:输出到日志文件,使用一个日志文件,没有大小限制
    # org.apache.log4j.DailyRollingFileAppender:输出到日志文件,每天产生一个日志文件
    # org.apache.log4j.RollingFileAppender:输出到日志文件,如果超过了限定大小,则重新产生一个新的
    # org.apache.log4j.WriterAppender:将日志文件以字符串流的格式发送到客户指定的任何地方
    # org.apache.log4j.jdbc.JDBCAppender:将日志文件输出到数据库中

    log4j.appender.root=org.apache.log4j.FileAppender

    log4j.appender.test=org.apache.log4j.DailyRollingFileAppender

    # log4j.appender.appernderName.File=filePath/fileName
    # 如果指定日志输出到文件中,那么需要制定日志文件的路径和文件名,这里和文件的样式相关联

    log4j.appender.root.File=log.html
    log4j.appender.test.File=test.html

    # log4j.appender.appenderName.layout=org.apache.log4j.formatLayout
    # 这里制定文件的格式,可选的有:
    # org.apache.log4j.HTMLLayout:输出为html格式
    # org.apache.log4j.SimpleLayout:由日志的级别和日志的提示信息组成,中间用"-"连接
    # org.apache.log4j.TTCCLayout:由时间、线程名、分类、上下文的提示信息组成
    # org.apache.log4j.PatternLayout:这是最灵活的日志文件格式,可以配置,相关的配置请参考log4j的文档

    log4j.appender.root.layout=org.apache.log4j.HTMLLayout
    log4j.appender.test.layout=org.apache.log4j.SimpleLayout





     
    展开全文
  • 比如当前日志有3份,分别为:Log2016-05-11.txt (日期最早,大小为5M), Log2016-05-12.txt (日期第二早,大小为6M), Log2016-0513.txt(最近日期,大小为2M) ,服务器设置日志容量大小为10MB,则每当应用初始化...
  • 清除error.log、access.log并限制Apache日志文件大小的方法Apache下的access.log和error.log文件从安装服务器到现在没有动过,今天突然discuz 的MYSQL数据库连接错误,提示2003 错误,检查发现原来是error.log、...

    清除error.log、access.log并限制Apache日志文件大小的方法
    Apache下的access.log和error.log文件从安装服务器到现在没有动过,今天突然discuz 的MYSQL数据库连接错误,提示2003 错误,检查发现原来是error.log、access.log爆满,文件达到30个G,奶奶的,立马搜索,得把这两个小子干掉。

    下面是在网上搜索到的方法,立马见效,顶一个!

    在 Windows 下的设置例子如下:
    第一步:删除 Apache2/logs/目录下的 error.log、access.log文件

    第二步:打开 Apache 的 httpd.conf配置文件并找到下面两条配置

    ErrorLog logs/error.log
    CustomLog logs/access.log common

    直接注释掉,换成下面的配置文件。


    # 限制错误日志文件为 1M
    ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 1M”

    # 每天生成一个错误日志文件
    #ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 86400″

    # 限制访问日志文件为 1M
    CustomLog “|bin/rotatelogs.exe -l logs/access-%Y-%m-%d.log 1M” common

    # 每天生成一个访问日志文件
    #CustomLog “|bin/rotatelogs.exe -l logs/access-%Y-%m-%d.log 86400″ common

    参考:


    Apache下的access.log和error.log文件处理方法

    这几天有会员和我说到网站访问速度越来越慢。我查了一下,看到Apache2下面有两个日志文件非常大了,加起来有800多M了。
    分别是access.log和error.log。

    于是在网上找找了给access.log和error.log减肥的方法,这个方法可让这两个文件按每天日期生成。这样你可以选择
    把前面的旧文件删除了。

    在Apache下的httpd.conf配置文件下找到下面两句:

    ErrorLog logs/error.log

    CustomLog logs/access.log common

    然后把这两句分别改为如下:

    CustomLog “|D:/apache2/bin/rotatelogs.exe D:/apache2/logs/access_%Y_%m_%d.log 86400 480″ common 

    ErrorLog “|D:/apache2/bin/rotatelogs.exe D:/apache2/logs/error_%Y_%m_%d.log 86400 480″ 

    一切就这么简单,这样这两个日志文件每天都会起一个新文件,就不至于单个文件太大,打不开,而无法看到日志信息了. 
    你还可以把前面的日志文件删除。

    access.log,件在 WEB 服务器运行一段时间之后会达到几十兆甚至上百兆,如果Apache运行有错误,error.log也会增大到几十兆,我们知道系统读写一个大的文本文件是非常耗内存的,因此限定日志文件大小十分必要。
    日志文件大小的配置指令,通过参考http://httpd.apache.org/docs/2.0/programs /rotatelogs.html,可以用apache 自己的程序 rotatelogs.exe(位于 {$apache}/bin/目录下),来限制日志文件的大小。
    Usage: rotatelogs [-l] [offset minutes from UTC] or
    Add this:
    TransferLog “|rotatelogs /some/where 86400″
    or
    TransferLog “|rotatelogs /some/where 5M”
    to httpd.conf. The generated name will be /some/where.nnnn where nnnn is the system time at which the log nominally starts (N.B. if using a rotation time, the time will always be a multiple of the rotation time, so you can synchronizecron scripts with it). At the end of each rotation time or when the file size is reached a new log is started.
    在 Windows 下的设置例子如下:
    # 限制错误日志文件为 1M
    ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 1M”
    # 每天生成一个错误日志文件
    #ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 86400″
    # 限制访问日志文件为 1M
    CustomLog “|bin/rotatelogs.exe -l logs/access-%Y-%m-%d.log 1M” common
    # 每天生成一个访问日志文件
    #CustomLog “|bin/rotatelogs.exe -l logs/access-%Y-%m-%d.log 86400″ common
    linux/Unix下 应该类似。


    清除apache的access.log方法

    有个客户服务器是用apache搭建的,最近总是感觉站很慢,服务器很慢很卡,有时候甚至网站都打不开,后来经过排查分析原来是里面的access.log和error.log这两个文件要经常上去看,和清理,如果时间忙,忘记看和清理了,过不了多久,这两个文件就膨胀的非常的大,打都打不开了。 下面就跟你说下 清理access.log和error.log这两个日志文件的方法希望对大家有些帮助。也怀疑怀疑是有其他的爬虫,明天都在爬我的几个网站。 
    优化access.log和error.log的方法如下 :
    CustomLog “|D:/thridparty-system/java/apache2/bin/rotatelogs.exe D:/thridparty-system/java/apache2/logs/access_%Y_%m_%d.log 86400 480″ common 
    ErrorLog “|D:/thridparty-system/java/apache2/bin/rotatelogs.exe D:/thridparty-system/java/apache2/logs/error_%Y_%m_%d.log 86400 480″ 
    一切就这么简单,这样这两个日志文件每天都会起一个新文件,就不至于单个文件太大,打不开,而无法看到日志信息了.

    解决Apache日志文件ACCESS.LOG日益膨胀的一个办法

    将httpd.conf中customlog logs/access.log common 改成

    customlog “|c:/apache/bin/rotatelogs c:/apache/logs/%y_%m_%d.access.log 86400 480″ common

    重启apache

    其中c:/apache/是你安装apache的路径
    这样每一天生成一个日志文件

    解决Apache日志文件ACCESS.LOG日益膨胀的一个办法

     

    http://bbs.yunyubaby.com/ 孕育宝贝论坛


    <script type="text/javascript"> </script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"></script>
    展开全文
  • log4j2.xml管理日志文件示例 生产上默认每天最多7个文件,每个文件100MB;保存30天以内的,并且总大小不超过5GB。具体配置如下所示 <?xml version="1.0" encoding="UTF-8"?> <Configuration status="WARN" ...

    log4j2.xml管理日志文件示例-限制保存日志文件时间及大小


    生产上默认每天最多7个文件,每个文件100MB;保存30天以内的,并且总大小不超过5GB。具体配置如下所示

    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="WARN" name="MyApp" packages="">
        <Properties>
            <Property name="baseDir">/var/log/springboot/RecLogger/</Property>
            <property name="LOG_PATTERN" value=""/>
            <property name="FILE_NAME" value="rec-logger.log"/>
        </Properties>
        <Appenders>
            <Console name="Console" target="SYSTEM_OUT">
                <PatternLayout charset="UTF-8" pattern="[%d] [%t] %-5level %logger{36} - %msg%n" />
            </Console>
            <RollingFile name="RollingFileInfo" filePermissions="rw-r--r--"
                         fileName="${baseDir}/rec-logger.log"
                         filePattern="${baseDir}/rec-logger-%d{yyyy-MM-dd}-%i.log">
                <Filters>
                    <ThresholdFilter level="INFO" />
                </Filters>
                <PatternLayout charset="UTF-8" pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" />
                <Policies>
                   <!-- 启动时,会删除多余的日志文件 -->
                    <OnStartupTriggeringPolicy/>
                    <TimeBasedTriggeringPolicy/>
                    <SizeBasedTriggeringPolicy size="100M"/>
                </Policies>
                <DefaultRolloverStrategy max="2">
                    <Delete basePath="${baseDir}" maxDepth="1">
                        <!-- 最近30天,最多5GB的日志 -->
                        <IfFileName glob="rec-logger-*.log">
                            <IfAny>
                                <IfLastModified age="30d"/>
                                <IfAccumulatedFileSize exceeds="5GB"/>
                            </IfAny>
                        </IfFileName>
                    </Delete>
                </DefaultRolloverStrategy>
            </RollingFile>
        </Appenders>
        <Loggers>
            <Root level="TRACE">
                <appender-ref ref="Console"/>
                <AppenderRef ref="RollingFileInfo"/>
            </Root>
            <Logger name="org.mybatis" level="INFO" />
            <Logger name="org.springframework" level="INFO" />
            <Logger name="com.ydfind.www.rec" level="INFO" />
        </Loggers>
    </Configuration>
    
    展开全文
  • 正确配置 这里我使用的是... logging.config=classpath:logback-spring.xml // 指定日志配置文件 根目录增加 logback-spring.xml 配置文件 logback-spring.xml 配置文件 注:<rollingPolicy> 标签...

    正确配置

    这里我使用的是springboot所以的 application.properties 文件增加

     logging.config=classpath:logback-spring.xml    // 指定日志配置文件
    

    根目录增加 logback-spring.xml 配置文件

    logback-spring.xml 配置文件

    同步模式
    注:<rollingPolicy> 标签 的 ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy是重点
    日志输出的文件名:${LOG_FILE}-%d{yyyy-MM-dd}.%i.log   (%d 和 %i 必须存在)

     

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <include resource="org/springframework/boot/logging/logback/base.xml"/>
        <include resource="com/zyc/datamonitor/logback/monitor.xml" optional="true"/>
    
        <property name="FILE_PATH_ERROR" value="${CY_LOG_HOME}/ops-error.log"/>
        <property name="FILE_PATH_WARN" value="${CY_LOG_HOME}/ops-warn.log"/>
        <property name="FILE_PATH_INFO" value="${CY_LOG_HOME}/ops.log"/>
        <property name="FILE_PATH_DEBUG" value="${CY_LOG_HOME}/ops-debug.log"/>
        <!-- 控制台输出 -->
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger{50} - %msg%n
                </pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <!-- 按照每天生成日志文件 -->
        <appender name="FILE-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_ERROR}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_ERROR}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>5GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于ERROR以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>ERROR</level>
            </filter>
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger{50} - %msg%n
                </pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <appender name="FILE-INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_INFO}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_INFO}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>5GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
    
            <!-- 按临界值过滤日志:低于INFO以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger{50} - %msg%n
                </pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <appender name="FILE-WARN"
                  class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_WARN}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_WARN}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>5GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于WARN以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>WARN</level>
            </filter>
            <!-- 按指定规则过滤日志 -->
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>DENY</onMatch><!-- ERROR级别被抛弃 -->
                <onMismatch>NEUTRAL</onMismatch><!-- 其它级别继续处理 -->
            </filter>
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger{50} - %msg%n
                </pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
    
        <appender name="FILE-DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_DEBUG}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_DEBUG}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>5GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于INFO以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>DEBUG</level>
            </filter>
            <!-- 不过滤日志 -->
            <encoder>
                <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] %logger{50} - %msg%n
                </pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
        <springProfile name="test,dev">
            <logger name="org.springframework" level="INFO" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </logger>
            <logger name="o.springframework" level="INFO" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </logger>
            <logger name="com.netflix" level="INFO" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </logger>
            <logger name="com.zyc.test" level="DEBUG" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </logger>
            <logger name="java.sql" level="DEBUG" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </logger>
    
            <!-- 日志输出级别 -->
            <root level="INFO">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-DEBUG"/>
            </root>
        </springProfile>
    
        <springProfile name="prod,default">
            <logger name="org.springframework" level="WARN" additivity="false">
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
            </logger>
            <logger name="com.netflix" level="WARN" additivity="false">
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
            </logger>
            <logger name="com.zyc.test" level="INFO" additivity="false">
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
            </logger>
            <logger name="java.sql" level="INFO" additivity="false">
                <appender-ref ref="STDOUT"/>
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
            </logger>
    
            <!-- 日志输出级别 -->
            <root level="WARN">
                <appender-ref ref="FILE-ERROR"/>
                <appender-ref ref="FILE-WARN"/>
                <appender-ref ref="FILE-INFO"/>
                <appender-ref ref="FILE-INFO"/>
            </root>
        </springProfile>
    </configuration>
    
    

    异步模式:推荐

     

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration scan="true" scanPeriod="120 seconds" debug="false">
        <!-- scan: 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
             scanPeriod: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。
             debug: 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。
        -->
        <include resource="com/zyc/log/base/logback.xml" optional="true"/>
        <include resource="com/zyc/log/base/zyc-monitor-logback.xml" optional="true"/>
        <include resource="com/zyc/log/base/zyc-commons-logback.xml" optional="true"/>
        <!-- root日志会输出到catalina日志中,默认应用是不需要设置。  -->
        <!-- 错误日志路径 -->
        <property name="FILE_PATH_ERROR" value="${CY_LOG_HOME}/core-error.log"/>
        <property name="FILE_PATH_WARN" value="${CY_LOG_HOME}/core-warn.log"/>
        <property name="FILE_PATH_INFO" value="${CY_LOG_HOME}/core.log"/>
        <property name="FILE_PATH_ALL_INFO" value="${CY_LOG_HOME}/core-all.log"/>
        <property name="FILE_PATH_DEBUG" value="${CY_LOG_HOME}/core-debug.log"/>
    
        <!-- 异步日志提取调用者数据标识 true/false -->
        <property name="includeCallerData" value="true"/>
        <!-- 异步日志的队列容量 -->
        <property name="queueSize" value="256"/>
        <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度%msg:日志消息,%n是换行符 -->
        <property name="LOG_PATTERN"
                  value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%thread] [%c][%M][%L] - %msg%n"/>
    
        <!-- add sensitive message converter -->
        <conversionRule conversionWord="msg"
                        converterClass="com.zyc.occ.logback.converter.SensitiveMessageConverter"/>
        <!-- 彩色日志 -->
        <!-- 彩色日志依赖的渲染类 -->
        <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
        <conversionRule conversionWord="wex"
                        converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
        <conversionRule conversionWord="wEx"
                        converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
        <!-- 彩色日志格式 -->
        <property name="CONSOLE_LOG_PATTERN"
                  value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%thread]){faint} %clr(%-40.40logger{39}){cyan} %L %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
    
        <!-- 控制台输出 -->
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>${CONSOLE_LOG_PATTERN}</pattern>
                <charset>UTF-8</charset>
            </encoder>
            <layout class="ch.qos.logback.classic.PatternLayout">
                <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            </layout>
        </appender>
        <appender name="CONSOLE-ASYNC" class="ch.qos.logback.classic.AsyncAppender">
            <discardingThreshold>0</discardingThreshold>
            <queueSize>${queueSize}</queueSize>
            <includeCallerData>${includeCallerData}</includeCallerData>
            <appender-ref ref="CONSOLE"/>
        </appender>
    
        <!-- 按照每天生成日志文件 -->
        <appender name="FILE-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_ERROR}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_ERROR}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <!--压缩格式-->
                <!--<FileNamePattern>${FILE_PATH_ERROR}.%d{yyyy-MM-dd}.%i.log.gz</FileNamePattern>-->
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>2GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于ERROR以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>ERROR</level>
            </filter>
            <encoder>
                <pattern>${LOG_PATTERN}</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
        <appender name="FILE-ERROR-ASYNC" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <includeCallerData>${includeCallerData}</includeCallerData>
            <appender-ref ref="FILE-ERROR"/>
        </appender>
        <appender name="FILE-INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_INFO}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_INFO}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>2GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于INFO以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <encoder>
                <pattern>${LOG_PATTERN}</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
        <appender name="FILE-INFO-ASYNC" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <includeCallerData>${includeCallerData}</includeCallerData>
            <appender-ref ref="FILE-INFO"/>
        </appender>
        <appender name="FILE-ALL-INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_ALL_INFO}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_ALL_INFO}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>150MB</MaxFileSize>
                <totalSizeCap>2GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于INFO以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <encoder>
                <pattern>${LOG_PATTERN}</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
        <appender name="FILE-ALL-INFO-ASYNC" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <includeCallerData>${includeCallerData}</includeCallerData>
            <appender-ref ref="FILE-ALL-INFO"/>
        </appender>
        <appender name="FILE-DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <!--日志文件输出的文件名 -->
            <File>${FILE_PATH_DEBUG}</File>
            <!--滚动日志 基于时间和文件大小-->
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!-- 滚动日志文件保存格式 -->
                <FileNamePattern>${FILE_PATH_DEBUG}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
                <MaxFileSize>60MB</MaxFileSize>
                <totalSizeCap>2GB</totalSizeCap>
                <MaxHistory>10</MaxHistory>
            </rollingPolicy>
            <!-- 按临界值过滤日志:低于INFO以下级别被抛弃 -->
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>DEBUG</level>
            </filter>
            <!-- 不过滤日志 -->
            <encoder>
                <pattern>${LOG_PATTERN}</pattern>
                <charset>UTF-8</charset>
            </encoder>
        </appender>
        <appender name="FILE-DEBUG-ASYNC" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>${queueSize}</queueSize>
            <includeCallerData>${includeCallerData}</includeCallerData>
            <appender-ref ref="FILE-DEBUG"/>
        </appender>
        <springProfile name="zyc-platform-dev,zyc-platform,test,dev,local">
            <logger name="org.springframework" level="INFO" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="o.springframework" level="INFO" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="com.netflix" level="INFO" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="java.sql" level="DEBUG" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="com.zyc" level="DEBUG" additivity="false">
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="CONSOLE-ASYNC"/>
            </logger>
            <logger name="com.zyc" level="INFO" additivity="false">
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <!-- 日志输出级别 -->
            <root level="INFO">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </root>
        </springProfile>
        <springProfile name="prod,pre,default">
            <logger name="org.springframework" level="WARN" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="com.netflix" level="WARN" additivity="false">
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <logger name="java.sql" level="INFO" additivity="false">
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
                <appender-ref ref="CONSOLE-ASYNC"/>
            </logger>
            <logger name="com.zyc" level="DEBUG" additivity="false">
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
            </logger>
            <logger name="com.zyc" level="INFO" additivity="false">
                <appender-ref ref="CONSOLE-ASYNC"/>
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-DEBUG-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </logger>
            <!-- 日志输出级别 -->
            <root level="INFO">
                <appender-ref ref="FILE-ERROR-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-INFO-ASYNC"/>
                <appender-ref ref="FILE-ALL-INFO-ASYNC"/>
            </root>
        </springProfile>
    </configuration>

    启动参数 

    #!/bin/bash
    
    export CY_LOG_HOME="/logs/ops"
    export SPRING_CLOUD_CONFIG_URI=http://10.20.1.1:9482
    export SPRING_CLOUD_CONFIG_PROFILE=test_V1.0
    export SPRING_CLOUD_CONFIG_LABEL=default
    export SPRING_CLOUD_CONFIG_NAME=test
    JAVA_OPTS="-server -Xmx2g -Xms2g -Xmn1024m -Xss256k -XX:MetaspaceSize=96m"
    JAVA_OPTS="$JAVA_OPTS -XX:+DisableExplicitGC"
    JAVA_OPTS="$JAVA_OPTS -XX:+UseConcMarkSweepGC"
    JAVA_OPTS="$JAVA_OPTS -XX:CMSMaxAbortablePrecleanTime=5000"
    JAVA_OPTS="$JAVA_OPTS -XX:+CMSClassUnloadingEnabled "
    JAVA_OPTS="$JAVA_OPTS -XX:+CMSParallelRemarkEnabled"
    JAVA_OPTS="$JAVA_OPTS -XX:+UseFastAccessorMethods"
    JAVA_OPTS="$JAVA_OPTS -XX:+UseCMSInitiatingOccupancyOnly"
    JAVA_OPTS="$JAVA_OPTS -XX:+ExplicitGCInvokesConcurrent"
    JAVA_OPTS="$JAVA_OPTS -XX:CMSInitiatingOccupancyFraction=80"
    JAVA_OPTS="$JAVA_OPTS -XX:SurvivorRatio=10"
    JAVA_OPTS="$JAVA_OPTS -XX:MaxDirectMemorySize=1g"
    JAVA_OPTS="$JAVA_OPTS -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=$CY_LOG_HOME/java.hprof"
    JAVA_OPTS="$JAVA_OPTS -Xloggc:$CY_LOG_HOME/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps"
    JAVA_OPTS="$JAVA_OPTS -Dlog_path=$CY_LOG_HOME"
    java $JAVA_OPTS -Dspring.profiles.active=default -jar /server/test/lib/test.jar
    

    Spring Boot 日志配置

    官方文档

    Spring Boot使用Commons Logging进行所有内部日志记录,但保留底层日志实现。为Java Util Logging,Log4J2和 Logback提供了默认配置 。在不同情况下,记录器都预先配置为使用控制台输出,并且还提供可选的文件输出。

    默认情况下,如果使用“Starters”,则使用Logback进行日志记录。还包括适当的Logback路由,以确保使用Java Util Logging,Commons Logging,Log4J或SLF4J的依赖库都能正常工作。

    日志格式

    Spring Boot的默认日志输出类似于以下示例:

    2014-03-05 10:57:51.112 INFO 45469 --- [main] org.apache.catalina.core.StandardEngine:启动Servlet引擎:Apache Tomcat / 7.0.52 
    2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] oaccC [Tomcat]。[localhost]。[/]:初始化Spring embedded WebApplicationContext 
    2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] osweb .context.ContextLoader:Root WebApplicationContext:初始化完成时间为1358 ms 
    2014-03-05 10:57:51.698 INFO 45469 --- [ost-startStop-1] osbceServletRegistrationBean:映射servlet:'dispatcherServlet'到[/] 
    2014-03 -05 10:57:51.702 INFO 45469 --- [ost-startStop-1] osbcembedded.FilterRegistrationBean:映射过滤器:'hiddenHttpMethodFilter'为:[/ *]
    复制代码

    Logback是没有FATAL级别的日志,它将被映射到ERROR

    • 时间日期:精确到毫秒,可以用于排序
    • 日志级别:ERROR、WARN、INFO、DEBUG、TRACE
    • 进程ID
    • 分隔符:采用 --- 来标识日志开始部分
    • 线程名:方括号括起来(可能会截断控制台输出)
    • Logger名:通常使用源代码的类名
    • 日志内容:我们输出的消息

    控制台输出

    日志级别从低到高分为:

    TRACE < DEBUG < INFO < WARN < ERROR < FATAL。
    复制代码

    如果设置为WARN ,则低于WARN的信息都不会输出。

    Spring Boot中默认配置ERRORWARNINFO级别的日志输出到控制台。

    您还可以通过启动您的应用程序 --debug 标志来启用“调试”模式(开发的时候推荐开启),以下两种方式皆可:

    在运行命令后加入--debug标志,如:$ java -jar springTest.jar --debug,这种命令会被 SpringBoot 解析,且优先级最高

    在application.properties中配置debug=true,该属性置为true的时候,核心Logger(包含嵌入式容器、hibernate、spring)会输出更多内容,但是你自己应用的日志并不会输出为DEBUG级别。

    启用调试模式时,将配置一些核心记录器(嵌入式容器、 Hibernate 和 Spring Boot)来输出更多的信息。 启用调试模式不会将应用程序配置为以 DEBUG 级别登录所有消息。

    或者,你也可以通过使用 --trace标志(或application.properties中的trace=true)启用“trace”模式。这样做可以为选择的核心记录器进行跟踪日志记录(嵌入式容器,Hibernate数据库生成和整个Spring 组合)。

    彩色编码输出

    如果你的终端支持ANSI,颜色输出用于帮助可读性。你可以在配置 文件中设置spring.output.ansi.enabled 来改变。 比如:

    spring.output.ansi.enabled=always
    复制代码
    • ALWAYS: 启用 ANSI 颜色的输出。
    • DETECT: 尝试检测 ANSI 着色功能是否可用。
    • NEVER: 禁用 ANSI 颜色的输出。

    颜色编码是通过使用% clr 转换字来配置的。 在最简单的形式中,转换器根据日志级别对输出进行颜色设置,如下面的示例所示:

    %clr(%5p)
    复制代码

    下表描述了将日志级别映射为颜色的情况:

    Levelcolor
    FATALRed
    ERRORRed
    WARNYellow
    INFOGreen
    DEBUGGreen
    TRACEGreen

    或者,你可以指定应该使用的颜色或样式,将其作为转换的选项。例如,为了使文本黄色,使用下 面的设置:

    %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}
    复制代码

    支持以下颜色和风格:

    • blue
    • cyan
    • faint
    • green
    • magenta
    • red
    • yellow

    文件输出

    默认情况下,Spring Boot 只会将日志记录到控制台上,而不会写日志文件。 如果你希望除了控制台输出之外编写日志文件,你需要设置一个logging.file件或 logging.path 属性(例如在你的application.properties)。

    logging.filelogging.pathExampleDescription
    nonenone 控制台只记录日志
    特定文件nonemy.log写入指定的日志文件。名字可以是工作目录的确切位置或相对位置
    noen特定目录/var/log写入spring.log到指定的目录。名字可以是工作目录的确切位置或相对位置

    日志文件在达到 10MB 时进行切割,与控制台输出一样,产生一个新的日志文件(如:spring.1.log、spring.2.log),新的日志依旧输出到 spring.log 中去,默认情况下会记录 ERROR、WARN、INFO 级别消息。

    你可以通过设置logging.file.max大小的属性来改变日志文件的大小限制。以前切割的文件会被无限期存档,除非已经设置了logging.file.max历史属性

    注:logging.file和logging.path二者不能同时使用,如若同时使用,则只有logging.file生效

    日志系统是在应用程序生命周期的早期初始化的。 因此,在通过@propertysource 注释加载的属性文件中找不到日志属性。

    日志记录属性独立于实际的日志基础结构。 因此,spring Boot 不管理特定的配置键(如 Logback.configurationFile for Logback)。

    日志输出级别

    所有支持的日志记录系统可以通过使用logging.level.<包名或Logger名>=<日志级别>在Spring环境中设置日志记录器级别(例如,在application.properties中),其级别可以是TRACE、DEBUG、INFO、WARN、ERROR、FATAL或OFF任意一个。root记录器可以通过使用logging.level.root进行配置。

    下面的示例显示了在application.properties中配置。

    logging.level.root=WARN
    logging.level.org.springframework.web=DEBUG
    logging.level.org.hibernate=ERROR
    复制代码

    自定义日志配置

    你可以使用org.springframework.boot.logging.LoggingSystem系统属性强制Spring Boot使用特定的日志记录系统。 该值应该是LoggingSystem实现的完全限定类名。 您还可以使用none值完全禁用Spring Boot的日志记录配置。

    因为日志记录是在创建ApplicationContext之前初始化的,所以无法控制Spring@Configuration文件中的@PropertySources的日志记录。更改日志记录系统或完全禁用日志记录的唯一方法是通过系统属性。

    根据你的日志记录系统,将加载以下文件:

    Logging SystemCustomization
    Logbacklogback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy
    Log4j2log4j2-spring.xml or log4j2.xml
    JDK (Java Util Logging)logging.properties

    在可能的情况下,我们建议你使用 -spring来进行日志配置(例如:logback-spring.xml而不是logback.xml)。如果使用logback.xml,Spring无法完全控制日志初始化。

    为了帮助进行自定义,Spring环境将一些其他属性转移到System属性,如下表所述:

    Spring EnvironmentSystem PropertyComments
    logging.exception-conversion-wordLOG_EXCEPTION_CONVERSION_WORD记录异常时使用的转换词。
    logging.fileLOG_FILE将日志写入到指定的文件中,默认为相对路径,可以设置成绝对路径
    logging.file.max-sizeLOG_FILE_MAX_SIZE最大日志文件大小(如果启用了日志文件)。 (只支持默认的 Logback 设置。)
    logging.file.max-historyLOG_FILE_MAX_HISTORY需要保存的存档日志文件的最大数量(如果启用了日志文件)。 (只支持默认的 Logback 设置。)
    logging.pathLOG_PATH将名为 spring.log 写入到指定的 文件夹 中,如(/var/log)
    logging.pattern.consoleCONSOLE_LOG_PATTERN在控制台上使用的日志模式(stdout)。 (只支持默认的 Logback 设置。)
    logging.pattern.dateformatLOG_DATEFORMAT_PATTERN设置日志输出日期格式(只支持默认的 Logback 设置。)
    logging.pattern.fileFILE_LOG_PATTERN定义输出到日志文件的日志格式
    logging.pattern.levelLOG_LEVEL_PATTERN绘制日志级别时使用的格式
    PIDPID当前的进程ID

    如果你想在日志属性中使用占位符,则应使用 Spring Boot 的语法,而不是基础框架的语法。 值得注意的是,如果使用Logback,你应该使用 : 作为属性名和其默认值之间的分隔符,而不是使用 :-

    Logback扩展配置

    Spring Boot 包含了一些 Logback 扩展,这些扩展可以帮助提高配置。 您可以在 logback-spring.xml 配置文件中使用这些扩展。 由于标准logback.xml配置文件过早加载,所以不能在其中使用扩展。您需要使用logback- spring.xml,或者定义一个loggingconfig属性。

    扩展配置不能与Logback的配置扫描一起使用。 如果尝试这样做,对配置文件进行更改会导致类似以下记录之一的错误:

    ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]]
    ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]]
    复制代码

    springProperty

    <springProfile> 标签使我们让配置文件更加灵活,它可以选择性的包含或排除部分配置

    <springProfile name="dev">
        <!-- 开发环境时激活 -->
    </springProfile>
    
    <springProfile name="dev,test">
        <!-- 开发,测试的时候激活,多个环境用逗号隔开-->
    </springProfile>
    
    <springProfile name="!prod">
        <!-- 当 "生产" 环境时,该配置不激活-->
    </springProfile>
    复制代码

    例子:

        <!-- 测试环境+开发环境. 多个使用逗号隔开. -->
        <springProfile name="test,dev">
            <logger name="com.example.demo.controller" level="DEBUG" additivity="false">
                <appender-ref ref="consoleLog"/>
            </logger>
        </springProfile>
    
        <!-- 生产环境. -->
        <springProfile name="prod">
            <logger name="com.example.demo.controller" level="INFO" additivity="false">
                <appender-ref ref="consoleLog"/>
            </logger>
        </springProfile>
    展开全文
  • 一、单一根据时间或大小切分日志文件 根据时间,这个相信大家都知道,主要是 log4j.appender.D = org.apache.log4j.DailyRollingFileAppender 就可以了,自然会根据日期来切分日志文件. 根据大小也简单 log4j....
  • java日志文件 log

    千次阅读 2012-04-24 16:16:27
    log4的使用方法:log4是具有日志记录功能,主要通过一个配置文件来对程序进行监测   有两种配置方式:一种程序配置,一种文件配置  有三个主要单元要了解,Logger,appender,layout.  logger是进行记录...
  • Apache日志文件大小管理设置分析方法
  • java解析json文件(文件大小50M),需要计算json文件中第一层的记录数大小。如json文件: [{"name":"帐号","package_name":"com.android.account","check_version":"1.2"}, {"name":"系统升级","package_name":...
  • 项目中尽管对log4j有基本的配置,例如按天生成日志文件以作区分,但如果系统日志文件过大,则就需要考虑以更小的单位切分或者其他切分方式。下面就总结一下log4j常用的配置参数以及切分日志的不同方式。 一、基本...
  • 浅谈JAVA中的日志文件

    千次阅读 2010-06-25 11:06:00
    log4的使用方法:log4是具有日志记录功能,主要通过一个配置文件来对程序进行监测   有两种配置方式:一种程序配置,一种文件配置 <br /> 有三个主要单元要了 解,Logger,appender,layout. ...
  • -- 失败日志还需要记录在日志文件中,日志文件采用10个10M的日志文件循环覆盖的方式,不至占满硬盘空间 --> <!-- files in general, please contact the logback user mailing list --> <!-- at...
  • 20个有用的java程序片段 1. 字符串有整型的相互转换 1 String a = String.valueOf(2); //integer to numeric string
  • log4j 按时间和大小增加新日志文件  我们开发的B/S结构系统,在服务端一般要有日常运行的日志记录。... 或者根据日志文件大小来判断,超过规定大小,日志自动增加新文件。  在log4j中这两种方
  • java错误日志

    千次阅读 2018-08-27 15:08:31
    #配置根Logger log4j.rootLogger = [ level ] , appenderName1 , ...#配置日志信息输出目的地Appender log4j.appender.appenderName = fully.qualified.name.of.appender.class  log4j.appender.appende...
  • 在记录日志时它使用java.util.logging.Handler来处理日志的记录,例如:如果使用的是FileHandler,那么处理器控制日志文件的位置、大小以及是否将新的日志内容添加到原有的日志文件中等。 java.util.logging.Fo
  • java日志管理

    万次阅读 2016-10-08 10:20:44
    java开发中,日志系统是java项目中必不可少的组成部分。日志可以帮助我们快速的定位问题,记录程序运行过程中的情况,以便项目的监控和优化。我们在日常开发中主要使用的java日志框架组件是:log4j、SLF4J、...
  • java上传超大文件

    千次阅读 2019-09-09 09:14:28
    一开始以为是session过期或者文件大小受系统限制,导致的错误。 查看了系统的配置文件没有看到文件大小限制, web.xml中seesiontimeout是30,我把它改成了120。 但还是不行,有时候10分钟就崩了。 同事说,可能是...
  • java 日志 logback-spring.xml 文件配置

    万次阅读 2018-12-05 15:49:44
    test.log tests.%i.log.zip 1 3 5MB %-4relative [%thread] %-5level %logger{35} - %msg%n 备注:上述配置表示按照固定窗口模式生成日志文件,当文件大于20MB时,生成新的日志文件。窗口大小是1到3,当保存了3个...
  •  需要传入某一个文件或者类或者方法的名字,生成对应日志文件,且每一个传入名字的文件单独有一个文件夹,子文件夹为日期,日期文件夹里面包含warn.log,error.log,debug.log,info.log。通过过滤器实现只打印对应...
  • Java gc日志分析

    千次阅读 2018-10-12 20:00:50
    分析gc日志后,经常需要调整jvm内存相关参数,常用参数如下 参数 含义 -Xms 初始堆大小,默认为物理内存的1/64(&lt;1GB);默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时,JVM就会增大堆直到-...
  • Android捕捉崩溃日志并输出日志文件

    千次阅读 2019-08-23 09:29:21
    Android捕捉崩溃日志并输出日志...这里还做了最大文件数量限制,超过数量即删除旧日志文件。 import java.io.BufferedReader; import java.io.File; import java.io.FileFilter; import java.io.FileInputStream;...
  • java 日志处理

    千次阅读 2018-08-13 21:00:00
    java日志组件介绍 common-logging(同时也称JCL)   common-logging是 apache提供的一个通用的日志接口。用户可以自由选择第三方的日志组件作为具体实现,像log4j,或者jdk自带的logging, common-logging会通过...
  • log4j 按时间和大小增加新日志文件 我们开发的B/S结构系统,在服务端一般要有日常运行的日志记录。... 或者根据日志文件大小来判断,超过规定大小,日志自动增加新文件。 在log4j中这两种方式的实现都
  • Java日志系统

    千次阅读 2016-10-24 20:30:27
    Java世界中,有很多的日志工具库来实现日志功能,避免我们重复造轮子,下面我们就来逐一了解日志工具。1. 最原始的日志记录方式最早期的Java程序中,使用System.out.println()把需要显示的内容打印到屏幕,这种...
  • * @Title: 根据DailyRollingFileAppender和RollingFileAppender改编,支持按日期和文件大小分割日志 * @ClassName:MyDailyRollingFileAppender.java * @Description: * * @author: FLY * @date:2016年11月24日...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,069
精华内容 29,627
关键字:

java限制日志文件大小

java 订阅