環境

作業系統：win7 
log4j2版本: 2.8.2

準備

下載jar包

把jar包放入到專案中去

開始使用

假設我們要使用log4j2,我們一般是先宣告成一個靜態成員變數：

private static final Logger logger = LogManager.getLogger(MyApp.class);
// 或者

private static final Logger logger = LogManager.getLogger(MyApp.class.getName());

宣告好logger後，我們就可以開始使用它了。

假設我們有這麼一個程式：

package test;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Hello {

    private static Logger logger = LogManager.getLogger(Hello.class.getName());

    public void getHello() {

        logger.entry();
        logger.trace("我是trace");
        logger.info("我是info資訊");
        logger.error("我是error");
        logger.fatal("我是fatal");

        logger.trace("退出程式.");
        logger.exit();
    }

    public static void main(String[] args) {
        new Hello().getHello();
    }
}
 

如果沒有自定義配置檔案，執行上面的方法後，在控制檯顯示如下：

10:45:05.641 [main] ERROR test.Hello - 我是error
10:45:05.644 [main] FATAL test.Hello - 我是fatal

從結果上看出，只有>=error級別的日誌打印出來了。 
這是因為Log4j有一個預設的配置，它的日誌級別是ERROR，輸出只有控制檯。 
如果我已經定義好了日誌，我把日誌級別改成了TRACE，輸出會變成下面這樣：

10:48:21.326 [main] TRACE test.Hello - Enter
10:48:21.330 [main] TRACE test.Hello - 我是trace
10:48:21.331 [main] INFO  test.Hello - 我是info資訊
10:48:21.331 [main] ERROR test.Hello - 我是error
10:48:21.331 [main] FATAL test.Hello - 我是fatal
10:48:21.331 [main] TRACE test.Hello - 退出程式.
10:48:21.331 [main] TRACE test.Hello - Exit
 

配置檔案

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

只需要把上面level改為trace就可以，看到剛才的效果！

由於這篇是簡單使用，就講這些，下篇接著講。

配置

Log4j 2的配置可以通過4種方式中的1種完成：

1、通過使用XML，JSON，YAML或屬性格式編寫的配置檔案。
2、以程式設計方式，通過建立一個ConfigurationFactory和配置實現。
3、以程式設計方式，通過呼叫配置介面中公開的API將元件新增到預設配置。
4、通過程式設計方式，通過呼叫內部Logger類的方法。

自動配置

Log4j能夠在初始化期間自動配置自身。 
當Log4j啟動時，將找到所有ConfigurationFactory外掛，並按照從最高到最低的加權順序進行排列。 
交付時，Log4j包含四個ConfigurationFactory實現：一個用於JSON，一個用於YAML，一個用於properties，一個用於XML。

1、Log4j將檢查log4j.configurationFile系統屬性，如果設定，將嘗試使用與副檔名匹配的ConfigurationFactory載入配置。 
2、如果沒有設定系統屬性，則properties ConfigurationFactory將在類路徑中查詢log4j2-test.properties。 
3、如果沒有找到這樣的檔案，YAML ConfigurationFactory將在類路徑中查詢log4j2-test.yaml或log4j2-test.yml。 
4、如果沒有找到這樣的檔案，JSON ConfigurationFactory將在類路徑中查詢log4j2-test.json或log4j2-test.jsn。 
5、如果沒有找到這樣的檔案，XML ConfigurationFactory將在類路徑中查詢log4j2-test.xml。 
6、如果找不到測試檔案，則properties ConfigurationFactory將在類路徑中查詢log4j2.properties。 
7、如果無法找到屬性檔案，則YAML ConfigurationFactory將在類路徑上查詢log4j2.yaml或log4j2.yml。 
8、如果無法找到YAML檔案，則JSON ConfigurationFactory將在類路徑上查詢log4j2.json或log4j2.jsn。 
9、如果無法找到JSON檔案，則XML ConfigurationFactory將嘗試在類路徑上找到log4j2.xml。 
10、如果沒有找到配置檔案，將使用DefaultConfiguration。這將導致日誌輸出轉到控制檯。

日誌級別

log4j規定了預設的幾個級別：trace<debug<info<warn<error<fatal等。這裡要說明一下：

①級別之間是包含的關係，意思是如果你設定日誌級別是trace，則大於等於這個級別的日誌都會輸出。 
②基本上預設的級別沒多大區別，就是一個預設的設定。你可以通過它的API自己定義級別。你也可以隨意呼叫這些方法，不過你要在配置檔案裡面好好處理了，否則就起不到日誌的作用了，而且也不易讀，相當於一個規範，你要完全定義一套也可以，不用沒多大必要。 
③這不同的級別的含義大家都很容易理解，這裡就簡單介紹一下：

日誌使用

緊接上篇博文

例子1：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="OFF">
    <appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </appenders>
    <loggers>
        <!--我們只讓這個logger輸出trace資訊，其他的都是error級別-->
        <!--
        additivity開啟的話，由於這個logger也是滿足root的，所以會被列印兩遍。
        -->
        <logger name="cn.lsw.base.log4j2.Hello" level="trace" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <root level="error">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

先簡單介紹一下下面這個配置檔案。 
1）根節點configuration，然後有兩個子節點：appenders和loggers（都是複數，意思就是可以定義很多個appender和logger了）（如果想詳細的看一下這個xml的結構，可以去jar包下面去找xsd檔案和dtd檔案）

2）appenders：這個下面定義的是各個appender，就是輸出了，有好多類別，這裡也不多說（容易造成理解和解釋上的壓力，一開始也未必能聽懂，等於白講），先看這個例子，只有一個Console，這些節點可不是隨便命名的，Console就是輸出控制檯的意思。然後就針對這個輸出設定一些屬性，這裡設定了PatternLayout就是輸出格式了，基本上是前面時間，執行緒，級別，logger名稱，log資訊等，差不多，可以自己去查他們的語法規則。

3）loggers下面會定義許多個logger，這些logger通過name進行區分，來對不同的logger配置不同的輸出，方法是通過引用上面定義的logger，注意，appender-ref引用的值是上面每個appender的name，而不是節點名稱。

這個例子為了說明什麼呢？我們要說說這個logger的name（名稱）了（前面有提到）。

name機制

我們看到配置檔案中的那個name是非常重要的。這個name要用好的，就不能隨便亂起。 
（隨便用的話，那就隨便取名字）。這個機制很簡單，就類似於java package一樣。 
上篇中建立logger物件的時候，名稱是通過Hello.class或者Hello.class.getName()這樣的方法。為什麼要這樣做呢？很重要的原因就是有所謂的繼承問題。比如 如果你給com.Hello定義了一個logger，那麼它也適用於com.Hello.base這個logger。名稱的繼承是通過（.）點號分隔的。然後你會返現上面的loggers裡面有個子節點不是logger而是root，而且這個root沒有name屬性。 
這個root相當於根節點。你所有的logger都適用於這個logger，所以，即使你在很多類裡面通過類名.class.getName()或者類名.class得到很多的logger，而且你也沒有在配置檔案中進行任何配置，它們也能夠都輸出，因為他們都繼承了root的log配置。

這種繼承的說法官網的解釋叫做logger 層次結構（Hierarchy） 
官網的例子：

例如：Logger配置中name為com.foo是name為com.foo.Bar的父類。類似的有，java是java.util的父類，是java.util.Vector的祖先。

上面的那個配置檔案裡面還定義了一個logger，他的名稱是cn.lsw.base.log4j2.Hello，這個名稱其實就是通過前面的Hello.class.getName()或者Hello.class得到的。上面那個配置檔案，我們為了給它做單獨配置。意思是：只有cn.lsw.base.log4j2.Hello這個logger輸出trace資訊。也就是它的日誌級別為trace，其他的logger則繼承root的日誌配置，日誌級別為error，只能打印出error及以上級別的日誌。

那麼有人會問，你單獨配置的那個logger不也是繼承了root的配置麼，那這樣的話，豈不是會列印兩遍日誌？ 這個問題確實是存在的。當然如果你設定了additivity=false,就不會輸出兩遍。

我們再寫一個測試類： 
（我們先對上面的配置檔案做下修改，一個是logger的name改為：test.Hello，第二把additivity=false去掉或改為true）

package test;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Logger2Test {

    private static Logger logger = LogManager.getLogger(Logger2Test.class.getName());


    public static void main(String[] args){

        logger.trace("start programe");

        Hello hello = new Hello();
        hello.getHello();

        logger.trace("end programe");
    }
}

• 結果就是：

2017-05-17 11:51:40.783 [main] TRACE test.Hello - Enter
2017-05-17 11:51:40.783 [main] TRACE test.Hello - Enter
2017-05-17 11:51:40.787 [main] TRACE test.Hello - 我是trace
2017-05-17 11:51:40.787 [main] TRACE test.Hello - 我是trace
2017-05-17 11:51:40.787 [main] INFO  test.Hello - 我是info資訊
2017-05-17 11:51:40.787 [main] INFO  test.Hello - 我是info資訊
2017-05-17 11:51:40.787 [main] ERROR test.Hello - 我是error
2017-05-17 11:51:40.787 [main] ERROR test.Hello - 我是error
2017-05-17 11:51:40.787 [main] FATAL test.Hello - 我是fatal
2017-05-17 11:51:40.787 [main] FATAL test.Hello - 我是fatal
2017-05-17 11:51:40.787 [main] TRACE test.Hello - 退出程式.
2017-05-17 11:51:40.787 [main] TRACE test.Hello - 退出程式.
2017-05-17 11:51:40.787 [main] TRACE test.Hello - Exit
2017-05-17 11:51:40.787 [main] TRACE test.Hello - Exit

我們可以看出主程式Logger2Test並沒有trace日誌輸出，因為它繼承了root的日誌配置（error級別及以上）。而Hello輸出了trace及以上級別的日誌，但是呢，每個都輸出了兩遍。為什麼會這樣呢？前面也說過預設所有的logger都繼承root的配置的。此時的Hello既有自己單獨的配置，也有從root那裡繼承下來的配置，所以會列印兩次。這樣的特性，在其name的層次結構中也是同樣適用的，比如：

我建立三個logger名稱為test、test.Hello和test.Hello.Hello2

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="OFF">
    <appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </Console>
    </appenders>
    <loggers>
        <logger name="test.Hello" level="info" additivity="true">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="test.Hello" level="info" additivity="true">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="test.foo.Hello2" level="info" additivity="true">
            <appender-ref ref="Console"/>
        </logger>
        <root level="error">
            <appender-ref ref="Console" />
        </root>
    </loggers>
</configuration>

列印結果:

2017-05-17 14:18:09.388 [main] INFO  test.Hello - 我是info資訊
2017-05-17 14:18:09.388 [main] INFO  test.Hello - 我是info資訊
2017-05-17 14:18:09.388 [main] INFO  test.Hello - 我是info資訊
2017-05-17 14:18:09.392 [main] ERROR test.Hello - 我是error
2017-05-17 14:18:09.392 [main] ERROR test.Hello - 我是error
2017-05-17 14:18:09.392 [main] ERROR test.Hello - 我是error
2017-05-17 14:18:09.392 [main] FATAL test.Hello - 我是fatal
2017-05-17 14:18:09.392 [main] FATAL test.Hello - 我是fatal
2017-05-17 14:18:09.392 [main] FATAL test.Hello - 我是fatal
2017-05-17 14:18:09.393 [main] INFO  test.foo.Hello2 - 我是info資訊
2017-05-17 14:18:09.393 [main] INFO  test.foo.Hello2 - 我是info資訊
2017-05-17 14:18:09.393 [main] INFO  test.foo.Hello2 - 我是info資訊
2017-05-17 14:18:09.393 [main] ERROR test.foo.Hello2 - 我是error
2017-05-17 14:18:09.393 [main] ERROR test.foo.Hello2 - 我是error
2017-05-17 14:18:09.393 [main] ERROR test.foo.Hello2 - 我是error
2017-05-17 14:18:09.393 [main] FATAL test.foo.Hello2 - 我是fatal
2017-05-17 14:18:09.393 [main] FATAL test.foo.Hello2 - 我是fatal
2017-05-17 14:18:09.393 [main] FATAL test.foo.Hello2 - 我是fatal

可以看出列印三篇。

在實際使用過程中，我們其實就是需要一個就行了，這時你可以設定：additivity=false。 
它會把父類全部遮蔽掉。官方說法就是把追加性關閉。

現在我們看一個稍微複雜的例子：

<?xml version="1.0" encoding="UTF-8"?>

<configuration status="error">
    <!--先定義所有的appender-->
    <appenders>
        <!--這個輸出控制檯的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制檯只輸出level及以上級別的資訊（onMatch），其他的直接拒絕（onMismatch）-->
            <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY"/>
            <!--這個都知道是輸出日誌的格式-->
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </Console>
        <!--檔案會打印出所有資訊，這個log每次執行程式會自動清空，由append屬性決定，這個也挺有用的，適合臨時測試用-->
        <File name="log" fileName="log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!--這個會打印出所有的資訊，每次大小超過size，則這size大小的日誌會自動存入按年份-月份建立的資料夾下面並進行壓縮，作為存檔-->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
        </RollingFile>
    </appenders>
    <!--然後定義logger，只有定義了logger並引入的appender，appender才會生效-->
    <loggers>
        <!--建立一個預設的root的logger-->
        <root level="trace">
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="Console"/>
        </root>

    </loggers>
</configuration>

–未完待續

說明

rollover 表示的是當日志文件大小滿足指定大小後，就生成一個新的檔案的過程。

RollingFileAppender

RollingFileAppender是一個OutputStreamAppender，它（會把日誌）寫入到filename引數命名的檔案中，並且會根據TriggeringPolicy和RolloverPolicy來rollover（rolls the file over）。RollingFileAppender會使用RollingFileManager（繼承OutputStreamManager）來實際執行檔案的I/O和執行rollover。儘管不能共享來做不同配置的RolloverFileAppenders，但是如果Manager可以訪問的話，那麼RolloverFileAppenders可以（進行共享）。 
例如：在一個servlet容器中的兩個web應用程式，他們有自己的配置，如果他們Log4j是共用一個類載入器（ClassLoader）那麼就可以安全的寫入到一個檔案中。

RollingFileAppender 需要TriggeringPolicy和RolloverStrategy。triggering policy決定是否應該執行rollover的操作，而RolloverStrategy定義了應該如何完成rollover。如果RolloverStrategy沒有配置的話，RollingFileAppender將使用DefaultRolloverStrategy。從log4j2.5版本開始，在DefaultRolloverStrategy中配置的自定義刪除操作在rollover時將被執行。 
從2.8版本開始，如果在DirectWriteRolloverStrategy中沒有配置檔名，將使用DefaultRolloverStrategy進行替換。

RollingFileAppender不支援檔案鎖的。

這裡rollover的操作可以理解為：當日志文件大小滿足指定大小後，就生成一個新的檔案。

RollingFileAppender引數

Triggering Policies

Composite Triggering Policy

Composite Triggering Policy組合了多個triggering policies，如果配置的策略中的任何一個返回true，則返回true。CompositeTriggeringPolicy簡單的通過在policies元素包裹其他的policies來配置。 
例如，以下XML片段定義了當JVM啟動時，當日志大小達到二十兆位元組以及當前日期與日誌的開始日期不匹配時滾動日誌的策略。

<Policies>
  <OnStartupTriggeringPolicy />
  <SizeBasedTriggeringPolicy size="20 MB" />
  <TimeBasedTriggeringPolicy />
</Policies>

Cron Triggering Policy

基於cron表示式的CronTriggeringPolicy觸發rollover。

CronTriggeringPolicy 引數

OnStartup Triggering Policy

如果日誌檔案比當前jvm啟動時間更早以及滿足或者超過最小檔案的大小就會觸發rollover

OnStartupTriggeringPolicy 引數說明:

SizeBased Triggering Policy

SizeBased Triggering Policy：一旦檔案大小達到指定大小後，就會發送rollover。 
該策略接受一個interval屬性和modulate布林屬性。其中interval屬性表示的是，基於時間模式應該傳送rollover的頻率。

TimeBasedTriggeringPolicy引數說明：

Rollover Strategies

Default Rollover Strategy

預設的rollover strategy接受一個日期/時間模式和一個整數，其中這個整數，是RollingFileAppender本身指定的filePattern屬性。如果date/time模式存在的話，它將會替換當前日期和時間的值。如果這個模式包含整數的話，它將會在每次發生rollover時，進行遞增。如果模式同時包含date/time和整數，那麼在模式中，整數會遞增直到結果中的data/time模式發生改變。如果檔案模式是以".gz", ".zip", ".bz2", ".deflate", ".pack200", or ".xz"結尾的，將會與字尾相匹配的壓縮方案進行壓縮檔案。格式為：bzip2, Deflate, Pack200 和 XZ需要Apache Commons Compress，此外，XZ需要XZ for Java 
該模式還可以包含可以在執行時解析的查詢引用，如下面的示例所示: 
預設的rollover策略支援三種增加計數的方式。第一種叫做：fixed window策略。為了說明它的工作原理，假設min屬性設定為1，max屬性設定為3，檔名為“foo.log”，檔名模式為：foo-％i.log。

相比之下，當 fileIndex屬性設定了max,其他設定和上面相同，將執行以下操作：

最後，從2.8版本開始，如果fileIndex屬性設定為nomax，那麼最大和最小值，都將會被忽略掉，檔案編號將從1開發增加，並且每次rollover時遞增都從編碼最大開始（專案於max效果），而且沒有檔案數的限制。

DefaultRolloverStrategy引數

DirectWrite Rollover Strategy

DirectWriteRolloverStrategy會將日誌事件會直接寫入檔案模式表示的檔案中去。使用這個策略不會執行檔案重新命名。如果基於大小的觸發策略導致在指定的時間段內寫入多個檔案，則它們將從一個編號開始，並持續遞增，直到發生基於時間的rollover。 
警告：如果檔案模式裡有壓縮的字尾，那麼當應用程式關閉時，當前檔案將不被壓縮。此外，如果時間變化使得檔案模式不再匹配當前檔案，則它也不會在啟動時被壓縮。

DirectWriteRolloverStrategy 引數

①下面是使用RollingFileAppender的一個示例配置，並且是基於時間和大小的觸發策略。其將會根據當前年和月份在未來7天內建立7個壓縮包，並且使用gzip進行壓縮。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
       filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

②第二個例子顯示一個rollover策略，最多保留20個檔案：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
      <DefaultRolloverStrategy max="20"/>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

③下面是使用RollingFileAppender的一個示例配置，並且是基於時間和大小的觸發策略。其將會根據當前年和月份在未來7天內建立7個壓縮包，並且每6小時即被6整除時，會使用gzip進行壓縮每個檔案。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <!--這行區別-->
        <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

④此示例配置使用基於cron和基於大小的觸發策略的RollingFileAppender，並且是無限制檔案數量的直接寫入到歸檔檔案中。cron觸發器是每小時發生rollover並且檔案大小不得超過250M。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" filePattern="logs/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <CronTriggeringPolicy schedule="0 0 * * * ?"/>
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

⑤此示例和上面④大致一樣，但是每小時儲存的檔案數量限制了為10：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" filePattern="logs/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <CronTriggeringPolicy schedule="0 0 * * * ?"/>
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
      <DirectWriteRolloverStrategy maxFiles="10"/>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

Log Archive Retention Policy（日誌存檔保留策略）：Delete on Rollover

log4j-2.5開始引入了刪除操作，使得使用者更有效的的控制在rollover時間內刪除檔案，而不是使用DefaultRolloverStrategy max屬性進行刪除。刪除操作允許使用者配置一個或多個條件，選擇要刪除相對於基本目錄的檔案。 
注意：刪除任何檔案這是允許的操作。不僅僅是rollover時的檔案。所以使用這個操作時，一定要小心。使用testMode引數可以測試您的配置，而不會意外刪除錯誤的檔案。

Delete 引數：

IfFileName 條件引數:

IfLastModified條件引數：

IfAccumulatedFileCount 條件引數

IfAccumulatedFileSize 條件引數

下面這個示例配置使用的是RollingFileAppender，並且使用的是cron觸發策略，是在每天的午夜觸發。歸檔儲存的目錄是基於當前年和月。在rollover時間內匹配刪除基本目錄下所有滿足引數glob等於*/app-*.log.gz和超過60天或更早的檔案。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd}.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
      <DefaultRolloverStrategy>
        <Delete basePath="${baseDir}" maxDepth="2">
          <IfFileName glob="*/app-*.log.gz" />
          <IfLastModified age="60d" />
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

下面的示例配置使用的是RollingFileAppender並且觸發策略是基於時間和檔案大小。在未來100天內會建立100個歸檔，這些歸檔儲存的目錄是基於當前年和月的，並且會以gzip方式進行壓縮每個歸檔，而且rollover是每小時發生一次。這個配置也將會刪除匹配*/app-*.log.gz和超過30天或更早的檔案。但是會保留大小進100G或者最近的10個檔案，先到則為準（whichever comes first.）。我個人理解應該是以檔案建立時間為準。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
      <DefaultRolloverStrategy max="100">
        <!--
        Nested conditions: the inner condition is only evaluated on files
        for which the outer conditions are true.
        -->
        <Delete basePath="${baseDir}" maxDepth="2">
          <IfFileName glob="*/app-*.log.gz">
            <IfLastModified age="30d">
              <IfAny>
                <IfAccumulatedFileSize exceeds="100 GB" />
                <IfAccumulatedFileCount exceeds="10" />
              </IfAny>
            </IfLastModified>
          </IfFileName>
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

ScriptCondition 引數：

Script 引數：

以下示例配置使用RollingFileAppender並且是cron觸發策略，觸發時間為每天午夜。歸檔儲存目錄是基於當前年和月的。該指令碼將返回在基本目錄下，日期為13號並且是星期五的rollover檔案列表。刪除操作將刪除指令碼返回的所有檔案。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="trace" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyyMMdd}.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
      <DefaultRolloverStrategy>
        <Delete basePath="${baseDir}" maxDepth="2">
          <ScriptCondition>
            <Script name="superstitious" language="groovy"><![CDATA[
                import java.nio.file.*;

                def result = [];
                def pattern = ~/\d*\/app-(\d*)\.log\.gz/;

                pathList.each { pathWithAttributes ->
                  def relative = basePath.relativize pathWithAttributes.path
                  statusLogger.trace 'SCRIPT: relative path=' + relative + " (base=$basePath)";

                  // remove files dated Friday the 13th

                  def matcher = pattern.matcher(relative.toString());
                  if (matcher.find()) {
                    def dateString = matcher.group(1);
                    def calendar = Date.parse("yyyyMMdd", dateString).toCalendar();
                    def friday13th = calendar.get(Calendar.DAY_OF_MONTH) == 13 \
                                  && calendar.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY;
                    if (friday13th) {
                      result.add pathWithAttributes;
                      statusLogger.trace 'SCRIPT: deleting path ' + pathWithAttributes;
                    }
                  }
                }
                statusLogger.trace 'SCRIPT: returning ' + result;
                result;
              ]] >
            </Script>
          </ScriptCondition>
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>