基于Spring Boot的Accesslog存储数量控制源码分析

      public static class Accesslog {

	/**
	 * Enable access log.
	 */
	private boolean enabled = false;

	/**
	 * Format pattern for access logs.
	 */
	private String pattern = "common";

	/**
	 * Directory in which log files are created. Can be relative to the tomcat
	 * base dir or absolute.
	 */
	private String directory = "logs";

	/**
	 * Log file name prefix.
	 */
	protected String prefix = "access_log";

	/**
	 * Log file name suffix.
	 */
	private String suffix = ".log";

	/**
	 * Enable access log rotation.
	 */
	private boolean rotate = true;

	/**
	 * Defer inclusion of the date stamp in the file name until rotate time.
	 */
	private boolean renameOnRotate;

	/**
	 * Date format to place in log file name.
	 */
	private String fileDateFormat = ".yyyy-MM-dd";

	/**
	 * Set request attributes for IP address, Hostname, protocol and port used for
	 * the request.
	 */
	private boolean requestAttributesEnabled;

	/**
	 * Buffer output such that it is only flushed periodically.
	 */
	private boolean buffered = true;

          @Getter
          @Setter
}

@Data
@ConfigurationProperties(PREFIX)
public class PurgeProperties implements InitializingBean {

	/**
	 * The constant PREFIX.
	 */
	public static final String PREFIX = "server.accesslog.purge";
	/**
	 * The constant ALLOWED_UNITS.
	 */
	private static final EnumSet<ChronoUnit> ALLOWED_UNITS = of(SECONDS, MINUTES, HOURS,
			DAYS);

	/**
	 * The Enabled.
	 */
	private boolean enabled;
	/**
	 * The Execute on startup.
	 */
	private boolean executeOnStartup;
	/**
	 * The Execution interval.
	 */
	private long executionInterval = 24;
	/**
	 * The Max history.
	 */
	private long maxHistory = 30;
	/**
	 * The Execution interval unit.
	 */
	private ChronoUnit executionIntervalUnit = HOURS;
	/**
	 * The Max history unit.
	 */
	private ChronoUnit maxHistoryUnit = DAYS;

	/**
	 * After properties set.
	 */
	@Override
	public void afterPropertiesSet() {
		isTrue(this.executionInterval > 0, "'executionInterval' must be greater than 0");
		isTrue(this.maxHistory > 0, "'maxHistory' must be greater than 0");
		isTrue(ALLOWED_UNITS.contains(this.executionIntervalUnit),
				"'executionIntervalUnit' must be one of the following units: SECONDS, MINUTES, HOURS, DAYS");
		isTrue(ALLOWED_UNITS.contains(this.maxHistoryUnit),
				"'maxHistoryUnit' must be one of the following units: SECONDS, MINUTES, HOURS, DAYS");
	}
}

@Configuration
@EnableConfigurationProperties(PurgeProperties.class)
@ConditionalOnClass(ServerProperties.class)
@ConditionalOnProperty(prefix = PREFIX, name = "enabled", havingValue = "true")
public class PurgeAccessLogAutoConfiguration {
    /**
     * The type Tomcat purge access log configuration.
     */
    @ConditionalOnClass(AccessLogValve.class)
    @ConditionalOnProperty(name = "server.tomcat.accesslog.enabled", havingValue = "true")
    public static class TomcatPurgeAccessLogConfiguration {

        /**
         * Purge access log customizer embedded servlet container customizer.
         *
         * @param serverProperties the server properties
         * @param purgeProperties  the purge properties
         * @return the embedded servlet container customizer
         */
        @Bean
        public WebServerFactoryCustomizer<TomcatServletWebServerFactory> purgeAccessLogCustomizer(
                final ServerProperties serverProperties,
                final PurgeProperties purgeProperties) {
            return factory -> {
                final Accesslog accesslog = serverProperties.getTomcat().getAccesslog();
                factory.getEngineValves().stream()
                        .filter(valve -> valve instanceof AccessLogValve)
                        .map(valve -> (AccessLogValve) valve).findFirst()
                        .ifPresent(valve -> {
                            final TomcatPurgeAccessLogHolder accessLogHolder = new TomcatPurgeAccessLogHolder(
                                    purgeProperties, Paths.get(accesslog.getDirectory()),
                                    accesslog.getPrefix(), accesslog.getSuffix(), valve);
                            factory.addContextCustomizers(accessLogHolder);
                        });
            };
        }
    }
}

@RequiredArgsConstructor
public abstract class PurgeAccessLogHolder {

	/**
	 * The Purge properties.
	 */
	private final PurgeProperties purgeProperties;
	/**
	 * The Directory.
	 */
	private final Path directory;
	/**
	 * The Prefix.
	 */
	private final String prefix;
	/**
	 * The Suffix.
	 */
	private final String suffix;
	/**
	 * The Current log file name supplier.
	 */
	private final Supplier<String> currentLogFileNameSupplier;

	/**
	 * Creates a scheduled thread pool and schedules the purge task according to the
	 * properties. If executeOnStartup property is false, then the task is scheduled to
	 * midnight of the next day.
	 */
	protected void attachPurgeTask() {
		long initialDelay = 0;

		if (!this.purgeProperties.isExecuteOnStartup()) {
			final LocalDateTime now = now();
			final LocalDateTime midnight = now.plusDays(1).with(MIDNIGHT);
			initialDelay = MILLIS.between(now, midnight);
		}

		final PurgeTask purgeTask = new PurgeTask(this.purgeProperties, this.directory,
				this.prefix, this.suffix, this.currentLogFileNameSupplier);
		final long executionInterval = this.purgeProperties.getExecutionInterval();
		final String executionIntervalUnit = this.purgeProperties
				.getExecutionIntervalUnit().name();

		ThreadFactory threadFactory = r -> new Thread(r, "access-log-purge-worker");
		ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(threadFactory);

		executor.scheduleWithFixedDelay(purgeTask,
										initialDelay,
										executionInterval,
										valueOf(executionIntervalUnit));
	}

}