Java 类ch.qos.logback.core.rolling.RollingPolicy 实例源码

private Appender<ILoggingEvent> configureAppender(LoggerContext loggerContext, String name, Config config)
        throws ReflectiveOperationException {
    List<Object> children = new ArrayList<>();

    @SuppressWarnings("unchecked")
    Class<Appender<ILoggingEvent>> clazz = (Class<Appender<ILoggingEvent>>) Class
            .forName(config.getString("class"));

    Appender<ILoggingEvent> appender = this.configureObject(loggerContext, clazz, config, children);
    appender.setName(name);

    for (Object child : children) {
        if (child instanceof RollingPolicy) {
            ((RollingPolicy) child).setParent((FileAppender<?>) appender);
        }
        if (child instanceof LifeCycle) {
            ((LifeCycle) child).start();
        }
    }

    appender.start();
    return appender;

}

public static final MetasfreshFileLoggerHelper get(final LoggerContext context)
{
    final Logger rootLogger = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
    final Appender<ILoggingEvent> appender = rootLogger.getAppender(FILEAPPENDER_NAME);
    if (!(appender instanceof RollingFileAppender))
    {
        return NULL;
    }

    final RollingFileAppender<?> rollingFileAppender = (RollingFileAppender<?>)appender;
    final RollingPolicy rollingPolicy = rollingFileAppender.getRollingPolicy();
    if (!(rollingPolicy instanceof MetasfreshTimeBasedRollingPolicy))
    {
        return NULL;
    }

    final MetasfreshTimeBasedRollingPolicy<?> metasfreshRollingPolicy = (MetasfreshTimeBasedRollingPolicy<?>)rollingPolicy;

    return new MetasfreshFileLoggerHelper(rollingFileAppender, metasfreshRollingPolicy);
}

protected FileAppender<ILoggingEvent> createRollingFileAppender(Encoder<ILoggingEvent> encoder,
                                                                LoggerContext context,
                                                                RollingPolicyFactory rollingPolicy) {

    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>();
    appender.setFile(file);
    appender.setContext(context);
    appender.setEncoder(encoder);
    // Setup rolling policy
    RollingPolicy policy = rollingPolicy.createRollingPolicy(context);
    appender.setRollingPolicy(policy);
    policy.setParent(appender);
    // Setup triggering policy
    TriggeringPolicy<ILoggingEvent> triggeringPolicy = rollingPolicy.createTriggeringPolicy(context);
    if (triggeringPolicy != null) {
        appender.setTriggeringPolicy(triggeringPolicy);
        triggeringPolicy.start();
    }
    policy.start();
    appender.start();

    return appender;
}

@Test
public void theActiveFileNameIsWhateverTheAppenderHas() throws Exception {
    RollingPolicy policy = new NoopRollingPolicy();
    policy.setParent(appender);

    assertEquals(logPath, policy.getActiveFileName());
}

public RotatableFileAppender() {
    setTriggeringPolicy(new RotationBasedTriggeringPolicy<E>());
    RollingPolicy rollingPolicy = new NoopRollingPolicy();
    setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(this);
}

/**
 * Creates rolling policy for rotation. This method validates rolling policy
 * properties before creation policy.
 *
 * @param context
 *            a logger context
 * @return a rolling policy for rotation
 * @throws IllegalStateException
 *             if rolling policy properties are incorrect
 */
public RollingPolicy createRollingPolicy(LoggerContext context) {
    getFileNamePatternValidator(context).validate();
    return instantiatePolicy(context);
}

/**
 * Instantiates rolling policy for rotation.
 *
 * @param context
 *            a logger context
 * @return rolling policy for rotation
 */
protected abstract RollingPolicy instantiatePolicy(LoggerContext context);