log4j2的Strategy、log4j2的DefaultRolloverStrategy、删除过期文件

• 日志文件拆分：按大小拆分(如每10M生成一份文件)、按时间拆分(如按日拆分)
• 日志文件删除：指定日志文件保留或删除策略，如删除100天之前的文件。

关于日志文件拆分，我们在上一篇文章《Log4j2的Policies详解》中已经说明了，接下来讲一下日志文件删除策略

一、DefaultRolloverStrategy

DefaultRolloverStrategy的主要作用是在日志文件达到一定大小或时间间隔时，自动创建新的日志文件，并对旧的日志文件进行归档或删除。

总结一下就是：DefaultRolloverStrategy是对日志文件的归档、删除策略

<RollingFile name="RollInfo"
             fileName="${LOG_HOME}/info.log"
             filePattern="${LOG_HOME}/info_%d{yyyy-MM-dd}_%i.log.gz">
    <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
    <PatternLayout pattern="${LOG_PATTERN}"/>
    <Policies>
        <SizeBasedTriggeringPolicy size="100K"/>
    </Policies>

    <DefaultRolloverStrategy fileIndex="nomax">
        <Delete basePath="${LOG_HOME}" maxDepth="2">
            <IfFileName glob="*.log.gz">
                <IfAny>
                    <IfAccumulatedFileSize exceeds="100M"/>
                    <IfAccumulatedFileCount exceeds="100"/>
                    <IfLastModified age="30d"/>
                </IfAny>
            </IfFileName>
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

1.1、DefaultRolloverStrategy节点

官网地址：https://logging.apache.org/log4j/2.x/manual/appenders/rolling-file.html#DefaultRolloverStrategy

DefaultRolloverStrategy指定了当触发rollover时的默认策略。

DefaultRolloverStrategy是Log4j2提供的默认的rollover策略，即使在log4j2.xml中没有显式指明，也相当于为RollingFile配置下添加了如下语句。DefaultRolloverStrategy默认的max为7。

<DefaultRolloverStrategy max="7"/>

1、max属性

max参数指定了计数器的最大值。一旦计数器达到了最大值，过旧的文件将被删除。

注意：不要认为max参数是需要保留的日志文件的最大数目。

max参数是与filePattern中的计数器%i配合起作用的，其具体作用方式与filePattern的配置密切相关。

1. 如果filePattern中仅含有date/time pattern，每次rollover时，将用当前的日期和时间替换文件中的日期格式对文件进行重命名。max参数将不起作用。

如，filePattern="logs/app-%d{yyyy-MM-dd}.log"

2. 如果filePattern中仅含有整数计数器（即%i），每次rollover时，文件重命名时的计数器将每次加1（初始值为1），若达到max的值，将删除旧的文件。

如，filePattern="logs/app-%i.log"

3. 如果filePattern中既含有date/time pattern，又含有%i，每次rollover时，计数器将每次加1，若达到max的值，将删除旧的文件，直到data/time pattern不再符合，被替换为当前的日期和时间，计数器再从1开始。

如，filePattern="logs/app-%d{yyyy-MM-dd HH-mm}-%i.log"

比如以下设置

<RollingFile name="RollingFileInfo" fileName="/logs/info.log" filePattern="/logs/info_%i.log">
	<DefaultRolloverStrategy max="3"/>
</RollingFile>

这表示/logs目录下最多只能保留3个info_*.log日志文件，当生成第四个文件时会按%i大小顺序删除第一个文件。具体步骤可看下面的fileIndex属性示例。

2、fileIndex属性

fileIndex设值不同，则文件归档及新文件创建及计数器递增方法都不同，计数器递增有三种方式，如下：

• 方式一：fileIndex="max"

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="info_%i.log">
	<DefaultRolloverStrategy max="3"/>
</RollingFile>

<DefaultRolloverStrategy max="3"/> 等同于 <DefaultRolloverStrategy fileIndex="max" max="3" min="1"/>

只保留3个日志文件，当到归档第4个文件时，
info-1.log 被删除，
info-2.log 被重命名为 info-1.log，
info-3.log 被重命名为 info-2.log，
info.log   被重命名为 info-3.log。
创建新的   info.log文件并继续写入。

• 方式二：fileIndex="min"

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="info_%i.log">
	<DefaultRolloverStrategy fileIndex="min" max="3"/>
</RollingFile>

只保留3个日志文件，当到归档第4个文件时，
info-3.log 被删除，
info-2.log 重命名为info-3.log，
info-1.log 重命名为info-2.log，
info.log   重命名为info-1.log。
创建新的   info.log文件并继续写入。

• 方式三：fileIndex="nomax"

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="info_%i.log">
	<DefaultRolloverStrategy fileIndex="nomax"/>
</RollingFile>

这里的fileIndex="nomax"属性值表示文件索引没有最大限制

换句话说，当使用%i作为文件名中的占位符时，日志文件将无限滚动，不会因为索引达到某个上限而停止创建新的日志文件。

nomax为2.8新增属性，设置为nomax时，将忽略DefaultRolloverStrategy的最大值和最小值，每次归档生成的新文件相对于前一个文件编号加1，没有最大文件数限制。

1.1.1、filePattern属性

官网地址：https://logging.apache.org/log4j/2.x/manual/appenders/rolling-file.html#attr-filePattern

filePattern属性在log4j2框架中起了至关重要的作用，日志文件的重命名、删除策略都是依赖该配置。

filePattern是RollingFile Appender的一个属性，用于指定根据何种模式生成归档滚动日志文件的名称。filePattern可以使用一些特定的占位符，以便在滚动时自动生成新的日志文件名

filePattern占位符：

• %d：日期格式化器的格式化日期。例如：2018-09-19
• %i ：滚动文件的索引编号，从1开始。
• $${date:}：系统的当前时间

比如我们设置的

filePattern="logs/app-%d{yyyy-MM-dd-HH}-%i.log"

filePattern中的时间占位符%d在滚动时会自动更新为当前时间，索引号%i也会自动递增以避免覆盖先前的日志，所以最终会生成以下的归档文件名

app-2024-12-24-15-1.log
app-2024-12-24-15-2.log
app-2024-12-24-15-3.log

当系统时间过了2024-12-24-15点的时候，计数器又会重新开始。如：

app-2024-12-24-16-1.log
app-2024-12-24-16-2.log

1.1.2、DefaultRolloverStrategy删除原理

问题： DefaultRolloverStrategy是怎么找到文件并删除的？

DefaultRolloverStrategy主要是根据filePattern属性匹配文件并删除文件的。如filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/info_%d{yyyy-MM-dd}_%i.log" 假设当前日期是2024-12-30，则会匹配/LOG_HOME/2024-12-30/info_2024-12-30_*.log的文件，然后按时间顺序删除。所以该策略的缺点就是不会删除其他目录下的文件。

缺点： 从上述原理中我们发现DefaultRolloverStrategy只能根据filePattern属性进行匹配删除，不会删除其他目录下的文件。 因此Log4j 2.5引入了DeleteAction，支持删除其他目录下的文件。

源码分析：
org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy.java

// org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy#rollover
/**
 * Performs the rollover.
 *
 * @param manager The RollingFileManager name for current active log file.
 * @return A RolloverDescription.
 * @throws SecurityException if an error occurs.
 */
@Override
public RolloverDescription rollover(final RollingFileManager manager) throws SecurityException {
    int fileIndex;
    // 默认 minIndex=1
    if (minIndex == Integer.MIN_VALUE) {
        final SortedMap<Integer, Path> eligibleFiles = getEligibleFiles(manager);
        fileIndex = eligibleFiles.size() > 0 ? eligibleFiles.lastKey() + 1 : 1;
    } else {
        if (maxIndex < 0) {
            return null;
        }
        final long startNanos = System.nanoTime();
        // 删除case1: 获取符合条件的文件数，同时清理掉大于  max 配置的日志文件
        // 如配置 max=5, 当前只有4个满足时, 不会立即清理文件, 但也不会阻塞后续流程
        // 只要没有出现错误, fileIndex 不会小于0
        fileIndex = purge(minIndex, maxIndex, manager);
        if (fileIndex < 0) {
            return null;
        }
        if (LOGGER.isTraceEnabled()) {
            final double durationMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos);
            LOGGER.trace("DefaultRolloverStrategy.purge() took {} milliseconds", durationMillis);
        }
    }
    // 进入此区域即意味着，必然有文件需要滚动，重新命名了
    final StringBuilder buf = new StringBuilder(255);
    manager.getPatternProcessor().formatFileName(strSubstitutor, buf, fileIndex);
    final String currentFileName = manager.getFileName();

    String renameTo = buf.toString();
    final String compressedName = renameTo;
    Action compressAction = null;

    FileExtension fileExtension = manager.getFileExtension();
    if (fileExtension != null) {
        renameTo = renameTo.substring(0, renameTo.length() - fileExtension.length());
        compressAction = fileExtension.createCompressAction(renameTo, compressedName,
                true, compressionLevel);
    }
    // 未发生文件重命名情况，即文件未被重命名未被滚动
    // 该种情况应该不太会发生
    if (currentFileName.equals(renameTo)) {
        LOGGER.warn("Attempt to rename file {} to itself will be ignored", currentFileName);
        return new RolloverDescriptionImpl(currentFileName, false, null, null);
    }
    // 新建一个重命令的 action, 返回待用
    final FileRenameAction renameAction = new FileRenameAction(new File(currentFileName), new File(renameTo),
                manager.isRenameEmptyFiles());
    // 异步处理器，会处理用户配置的异步action，如本文配置的 DeleteAction
    // 它将会在稍后被提交到异步线程池中运行
    final Action asyncAction = merge(compressAction, customActions, stopCustomActionsOnError);
    // 封装Rollover返回, renameAction 是同步方法, 其他用户配置的动态action 则是异步方法
    // 删除case2: 封装异步返回action
    return new RolloverDescriptionImpl(currentFileName, false, renameAction, asyncAction);
}
private int purge(final int lowIndex, final int highIndex, final RollingFileManager manager) {
    // 默认使用 accending 的方式进行清理文件
    return useMax ? purgeAscending(lowIndex, highIndex, manager) : purgeDescending(lowIndex, highIndex, manager);
}
// org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy#purgeAscending
/**
 * Purges and renames old log files in preparation for rollover. The oldest file will have the smallest index, the
 * newest the highest.
 *
 * @param lowIndex low index. Log file associated with low index will be deleted if needed.
 * @param highIndex high index.
 * @param manager The RollingFileManager
 * @return true if purge was successful and rollover should be attempted.
 */
private int purgeAscending(final int lowIndex, final int highIndex, final RollingFileManager manager) {
    final SortedMap<Integer, Path> eligibleFiles = getEligibleFiles(manager);
    final int maxFiles = highIndex - lowIndex + 1;

    boolean renameFiles = false;
    // 依次迭代 eligibleFiles, 删除
    while (eligibleFiles.size() >= maxFiles) {
        try {
            LOGGER.debug("Eligible files: {}", eligibleFiles);
            Integer key = eligibleFiles.firstKey();
            LOGGER.debug("Deleting {}", eligibleFiles.get(key).toFile().getAbsolutePath());
            // 调用nio的接口删除文件
            Files.delete(eligibleFiles.get(key));
            eligibleFiles.remove(key);
            renameFiles = true;
        } catch (IOException ioe) {
            LOGGER.error("Unable to delete {}, {}", eligibleFiles.firstKey(), ioe.getMessage(), ioe);
            break;
        }
    }
    final StringBuilder buf = new StringBuilder();
    if (renameFiles) {
        // 针对未完成删除的文件，继续处理
        // 比如使用 匹配的方式匹配文件, 则不能被正常删除
        // 还有些未超过maxFiles的文件
        for (Map.Entry<Integer, Path> entry : eligibleFiles.entrySet()) {
            buf.setLength(0);
            // LOG4J2-531: directory scan & rollover must use same format
            manager.getPatternProcessor().formatFileName(strSubstitutor, buf, entry.getKey() - 1);
            String currentName = entry.getValue().toFile().getName();
            String renameTo = buf.toString();
            int suffixLength = suffixLength(renameTo);
            if (suffixLength > 0 && suffixLength(currentName) == 0) {
               renameTo = renameTo.substring(0, renameTo.length() - suffixLength);
            }
            Action action = new FileRenameAction(entry.getValue().toFile(), new File(renameTo), true);
            try {
                LOGGER.debug("DefaultRolloverStrategy.purgeAscending executing {}", action);
                if (!action.execute()) {
                    return -1;
                }
            } catch (final Exception ex) {
                LOGGER.warn("Exception during purge in RollingFileAppender", ex);
                return -1;
            }
        }
    }
    // 此处返回的 findIndex 一定是 >=0 的
    return eligibleFiles.size() > 0 ?
            (eligibleFiles.lastKey() < highIndex ? eligibleFiles.lastKey() + 1 : highIndex) : lowIndex;
}

1.2、Delete节点

Log4j 2.5引入了DeleteAction，允许用户自定义删除文件的策略，而不仅仅是通过DefaultRolloverStrategy默认的删除最旧文件的策略。使用DeleteAction时需要注意谨慎，以避免误删重要文件。

注意：可以删除任何文件，而不仅仅是删除日志文件，因此请谨慎使用此操作！使用testMode参数，可以测试配置，而不会意外删除错误的文件。

maxDepth用于指定清理或删除日志文件时搜索的目录深度,值是一个整数，表示从basePath开始向下搜索的目录层级数

• 如果maxDepth=“0”，则只会考虑basePath所指向的目录本身，不包括任何子目录。
• 如果maxDepth=“1”，则会考虑basePath所指向的目录及其直接子目录。
• 如果maxDepth=“2”，则会考虑basePath所指向的目录、其直接子目录以及这些子目录下的子目录（即二级子目录）。

内置的PathCondition条件

• IfFileName 如果文件名与此参数匹配则结果为true，此参数为正则表达式或 glob的文件。
• IfLastModified 最后修改时间早于或等于此参数则结果为true，此参数为duration。
• IfAccumulatedFileCount 文件数超过指定个数则结果为true，此参数为整型。
• IfAccumulatedFileSize 所有文件总大小达到此参数则结果为true，此参数为KB、MB、GB。
• IfAll 如果此标签下的所有条件都配置成功（逻辑与），则结果为true。
• IfAny 如果此标签下的任何一个条件匹配成功（逻辑或），则结果为true。
• IfNot 如果此标签下的所有条件都不匹配（逻辑非），则结果为true。

以下是几个示例：

<RollingFile name="RollInfo"
             fileName="${LOG_HOME}/info.log"
             filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/info_%d{yyyy-MM-dd}_%i.log.gz">
	<DefaultRolloverStrategy fileIndex = "nomax">
	    <Delete basePath="${LOG_HOME}" maxDepth="2">
	        <!--由于filePattern中的格式是${baseDir}/$${date:yyyy-MM-dd}，所以glob前面必须有*/相当于日期这一层级-->
	        <IfFileName glob="*/*.log.gz"/>
	        <IfLastModified age="7d"/>              
	    </Delete>
	</DefaultRolloverStrategy>
</RollingFile>

删除7天前的${LOG_HOME}文件夹下，两层路径以内的所有.log.gz文件。其中，Delete子标签中的IfFileName和IfLastModified子标签用于指定删除条件，只有同时满足两个条件才进行删除操作

注意：

• 当maxDepth设置的深度是2时，需要注意下边删除规则glob中日志名字前需要加*/，表示外一层目录，不加的话日志滚动时不会删除过期日志文件。相反，如果深度是1，删除当前目录时是不需要加的。

<RollingFile name="RollInfo"
             fileName="${LOG_HOME}/info.log"
             filePattern="${LOG_HOME}/info_%d{yyyy-MM-dd}_%i.log.gz">
	<DefaultRolloverStrategy fileIndex = "nomax">
	    <Delete basePath="${LOG_HOME}" maxDepth="1">
	        <IfFileName glob="*.log.gz">
	            <IfLastModified age="7d">
	                <IfAny>
	                	<!--文件总大小超过100M，进行删除-->
	                    <IfAccumulatedFileSize exceeds="100M"/>
	                    <!--文件总数量超过100，进行删除-->
	                    <IfAccumulatedFileCount exceeds="100"/>
	                </IfAny>
	            </IfLastModified>
	        </IfFileName>
	    </Delete>
	</DefaultRolloverStrategy>
</RollingFile>

<DefaultRolloverStrategy fileIndex="nomax">
    <!--basePath：从此处扫描需要删除的日志基本路径，maxDepth:要访问的日志目录最大级别数，默认是1  -->
    <!--例如我们的日志是/data/logs/app/app-info.log，basePath=/data/logs,maxDepth=2 恰好能访问到app-info.log -->
    <Delete basePath="${BASE_LOG_PATH}/${SERVER_NAME}" maxDepth="2">
        <!--删除，正则匹配到文件名-->
        <IfFileName glob="*-info.*.log.gz"/>
        <!--删除，日志距离现在多长事件，P1D代表是1天-->
        <!--http://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/rolling/action/Duration.html-->
        <IfLastModified age="P1D"/>
    </Delete>
</DefaultRolloverStrategy>

下面是多个Delete配置示例：

<!-- 删除策略配置 -->
<DefaultRolloverStrategy max="5000">
    <Delete basePath="logs/app/history" maxDepth="1">
        <!-- 配置且关系 -->
        <IfFileName glob="*.log.gz"/>
        <IfLastModified age="7d"/>
    </Delete>
    <!-- 配置或关系 -->
    <Delete basePath="logs/app/history" maxDepth="1">
        <IfFileName glob="*.docx"/>
    </Delete>
</DefaultRolloverStrategy>

1.2.1、maxDepth属性

maxDepth用于指定清理或删除日志文件时搜索的目录深度,值是一个整数，表示从basePath开始向下搜索的目录层级数

• 如果maxDepth=“0”，则只会考虑basePath所指向的目录本身，不包括任何子目录。
• 如果maxDepth=“1”，则会考虑basePath所指向的目录及其直接子目录。
• 如果maxDepth=“2”，则会考虑basePath所指向的目录、其直接子目录以及这些子目录下的子目录（即二级子目录）。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration >
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM-dd}/app-%d{yyyy-MM-dd}_%i.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
      <DefaultRolloverStrategy>
        <Delete basePath="${baseDir}" maxDepth="2">
          <!--由于filePattern中的格式是${baseDir}/$${date:yyyy-MM-dd}，所以glob前面必须有*/相当于日期这一层级-->
          <IfFileName glob="*/app-*.log.gz" />
          <IfLastModified age="60d" />
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

上述配置文件中，Delete部分便是配置DeleteAction的删除策略，指定了当触发rollover时，删除baseDir文件夹或其子文件下面的文件名符合app-*.log.gz且距离最后的修改日期超过60天的文件。

其中，basePath指定了扫描开始路径，为baseDir文件夹。maxDepth指定了目录扫描深度，为2表示扫描baseDir文件夹及其子文件夹。

注意： 上述示例中IfFileName的glob属性前面一定要加*/ ， 因为日志文件的存储格式是/logs/2024-12-30/app-2024-12-30_1.log.gz， 如果glob属性前面没有*/，则只会匹配/logs/app-2024-12-30_1.log.gz文件，缺少了日期这一层级。

二、知识扩展

2.1、DefaultRolloverStrategy与Delete会冲突吗？

我们知道DefaultRolloverStrategy是有自己的删除策略的，Delete标签也是删除策略，假设同时配置了DefaultRolloverStrategy与Delete属性，当两者冲突时，谁会生效？

2.1.1、场景一：DefaultRolloverStrategy先满足条件

1、场景说明
假如我们配置了DefaultRolloverStrategy的max属性最多保留3个文件，同时配置了Delete属性总文件超过15GB进行删除。当文件已经超过3个但是大小未超过15G（DefaultRolloverStrategy先满足条件）,即两者的策略冲突，最后谁会生效？

<!--配置当前目录下最多留3个文件 -->
 <DefaultRolloverStrategy  max="3">
    <Delete basePath="${FILE_PATH}">
    	<!--FILE_PATH下文件总大小超过15GB，进行删除-->
        <IfAccumulatedFileSize exceeds="15GB"/>
    </Delete>
</DefaultRolloverStrategy>

2、测试结果
上述这个场景中，DefaultRolloverStrategy属性会生效，即只保留3个文件，当归档文件超过3个时按fileIndex="max"策略进行删除

2.1.2、场景二：DefaultRolloverStrategy保留3个，Delete删除所有

1、场景说明
当DefaultRolloverStrategy设置了最多保留3个文件，Delete标签中设置了删除所有文件，那么是会保留3个文件，还是删除所有文件？

<DefaultRolloverStrategy max="3" >
   <Delete basePath="${FILE_PATH}" maxDepth="2" >
        <IfFileName  glob="*/info*.log"/>
    </Delete>
</DefaultRolloverStrategy>

注意：不要有这种配置。
在测试环境用了这种配置，发现文件有可能会增长到第三个，然后当第四个文件归档时删除之前所有的文件。

2.2、testMode不生效？

测试环境配置如下，本来以为配置了testMode="true"之后会开启测试模式，日志文件不会删除，但是最后发现当前日期目录下还是只有3个文件，即<DefaultRolloverStrategy max="3">属性生效了，那么testMode真的没效果么？

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/$${date:yyyy-MM-dd}/info-%d{yyyy-MM-dd}_%i.log.gz">
	<!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
	<ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
	<PatternLayout pattern="${LOG_PATTERN}"/>
	<Policies>
		<SizeBasedTriggeringPolicy size="2KB"/>
	</Policies>
	<DefaultRolloverStrategy  max="3">
		<Delete basePath="${FILE_PATH}" maxDepth="2" testMode="true">
		   <IfFileName  glob="*/*.log.gz"/>
		</Delete>
	</DefaultRolloverStrategy>
</RollingFile>

上述配置的效果是：

• 假设当前日期是2024-12-30，那么当前日期目录下最多只会保留3个文件（<DefaultRolloverStrategy max="3">生效了）。
• 但是其他日期目录下的文件不会删除（testMode=true生效了）。

DefaultRolloverStrategy

<DefaultRolloverStrategy max="5"/>

DefaultRolloverStrategy表示log4j2每单位时间内最多能保存多少个日志切割文件，一般与SizeBasedTriggeringPolicy结合使用；

max:表示保存的最大值，默认为7；

例如：你的log4j2.xml设置如下：fileName="e:/log.out" filePattern="e:/app-%d{yyyy-MM-dd_HH-mm}-%i.out"
那么在每分钟内，你可以保留2个日志切割文件，多余的日志进行覆盖；

三、总结

DefaultRolloverStrategy： 删除策略单一，只能基于filePattern属性保证当前这个目录下的文件数量，不能删除其他文件夹的文件
Delete: 可以删除任意目录下的文件，并提供多种条件配置方式。

参考、推荐文章：
https://blog.csdn.net/bluuusea/article/details/104763368
https://www.cnblogs.com/yougewe/p/13407812.html
https://www.jianshu.com/p/c13ba3f5dd99

创作不易，欢迎打赏，你的鼓励将是我创作的最大动力。