Java LifeCycle类代码示例

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testFlushAtEndOfBatch() throws Exception {
    final File f = new File("target", "RandomAccessFileAppenderTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Message flushed with immediate flush=false";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 incorrect", line1.contains(msg));

    final String location = "testFlushAtEndOfBatch";
    assertTrue("no location", !line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testFlushAtEndOfBatch() throws Exception {
    final File f = new File("target", "RollingRandomAccessFileAppenderTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Message flushed with immediate flush=false";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    final String location = "testFlushAtEndOfBatch";
    assertTrue("no location", !line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testLocationIncluded() throws Exception {
    final File f = new File("target", "RollingRandomAccessFileAppenderLocationTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Message with location, flushed with immediate flush=false";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    final String location = "testLocationIncluded";
    assertTrue("has location", line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testLocationIncluded() throws Exception {
    final File f = new File("target", "RandomAccessFileAppenderLocationTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Message with location, flushed with immediate flush=false";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    final String location = "testLocationIncluded";
    assertTrue("has location", line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testAdditivity() throws Exception {
    final File f = new File("target", "AsyncLoggerConfigTest.log");
    assertTrue("Deleted old file before test", !f.exists() || f.delete());
    
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Additive logging: 2 for the price of 1!";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    final String line2 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertNotNull("line2", line2);
    assertTrue("line1 correct", line1.contains(msg));
    assertTrue("line2 correct", line2.contains(msg));

    final String location = "testAdditivity";
    assertTrue("location",
            line1.contains(location) || line2.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testAsyncLogWritesToLog() throws Exception {
    final File f = new File("target", "AsyncLoggerTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Async logger msg";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    final String location = "testAsyncLogWritesToLog";
    assertTrue("no location", !line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testAsyncLogWritesToLog() throws Exception {
    final File f = new File("target", "AsyncLoggerLocationTest.log");
    // System.out.println(f.getAbsolutePath());
    f.delete();
    final Logger log = LogManager.getLogger("com.foo.Bar");
    final String msg = "Async logger msg with location";
    log.info(msg);
    ((LifeCycle) LogManager.getContext()).stop(); // stop async thread

    final BufferedReader reader = new BufferedReader(new FileReader(f));
    final String line1 = reader.readLine();
    reader.close();
    f.delete();
    assertNotNull("line1", line1);
    assertTrue("line1 correct", line1.contains(msg));

    final String location = "testAsyncLogWritesToLog";
    assertTrue("has location", line1.contains(location));
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
/**
 * Loads the LoggerContext using the ContextSelector.
 * @param fqcn The fully qualified class name of the caller.
 * @param loader The ClassLoader to use or null.
 * @param externalContext An external context (such as a ServletContext) to be associated with the LoggerContext.
 * @param currentContext If true returns the current Context, if false returns the Context appropriate
 * for the caller if a more appropriate Context can be determined.
 * @param source The configuration source.
 * @return The LoggerContext.
 */
public LoggerContext getContext(final String fqcn, final ClassLoader loader, final Object externalContext,
                                final boolean currentContext, final ConfigurationSource source) {
    final LoggerContext ctx = selector.getContext(fqcn, loader, currentContext, null);
    if (externalContext != null && ctx.getExternalContext() == null) {
        ctx.setExternalContext(externalContext);
    }
    if (ctx.getState() == LifeCycle.State.INITIALIZED) {
        if (source != null) {
            ContextAnchor.THREAD_CONTEXT.set(ctx);
            final Configuration config = ConfigurationFactory.getInstance().getConfiguration(ctx, source);
            LOGGER.debug("Starting LoggerContext[name={}] from configuration {}", ctx.getName(), source);
            ctx.start(config);
            ContextAnchor.THREAD_CONTEXT.remove();
        } else {
            ctx.start();
        }
    }
    return ctx;
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
public void setTriggeringPolicy(final TriggeringPolicy triggeringPolicy) {
    triggeringPolicy.initialize(this);
    final TriggeringPolicy policy = this.triggeringPolicy;
    int count = 0;
    boolean policyUpdated = false;
    do {
        ++count;
    } while (!(policyUpdated = triggeringPolicyUpdater.compareAndSet(this, this.triggeringPolicy, triggeringPolicy))
            && count < MAX_TRIES);
    if (policyUpdated) {
        if (triggeringPolicy instanceof LifeCycle) {
            ((LifeCycle) triggeringPolicy).start();
        }
        if (policy instanceof LifeCycle) {
            ((LifeCycle) policy).stop();
        }
    } else {
        if (triggeringPolicy instanceof LifeCycle) {
            ((LifeCycle) triggeringPolicy).stop();
        }
    }
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testPropertiesConfiguration() {
    final Configuration config = context.getConfiguration();
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 1);
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testPropertiesConfiguration() {
    final Configuration config = context.getConfiguration();
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 1);
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 1);
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testPropertiesConfiguration() {
    final Configuration config = context.getConfiguration();
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 1);
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final Logger logger = LogManager.getLogger(getClass());

    assertEquals("Incorrect level " + logger.getLevel(), Level.DEBUG, logger.getLevel());

    logger.debug("Welcome to Log4j!");
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Test
public void testPropertiesConfiguration() {
    final Configuration config = context.getConfiguration();
    assertNotNull("No configuration created", config);
    assertEquals("Incorrect State: " + config.getState(), config.getState(), LifeCycle.State.STARTED);
    final Map<String, Appender> appenders = config.getAppenders();
    assertNotNull(appenders);
    assertTrue("Incorrect number of Appenders: " + appenders.size(), appenders.size() == 3);
    final Map<String, LoggerConfig> loggers = config.getLoggers();
    assertNotNull(loggers);
    assertTrue("Incorrect number of LoggerConfigs: " + loggers.size(), loggers.size() == 2);
    final Filter filter = config.getFilter();
    assertNotNull("No Filter", filter);
    assertTrue("Not a Threshold Filter", filter instanceof ThresholdFilter);
    final Logger logger = LogManager.getLogger(getClass());
    logger.info("Welcome to Log4j!");
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Override
public void stop() throws LifecycleException {
    log("stopping Context");
    if (!started) {
        throw new LifecycleException("SimpleContext has already stopped");
    }
    this.lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
    started = false;

    if (loader != null && loader instanceof LifeCycle) {
        ((LifeCycle) loader).stop();
    }

    if (pipeline != null && pipeline instanceof LifeCycle) {
        ((LifeCycle) pipeline).stop();
    }

    Container[] children = findChildren();
    for (int i = 0; i < children.length; ++i) {
        if (children[i] instanceof LifeCycle) {
            ((Lifecycle) children[i]).stop();
        }
    }
    this.lifecycle.fireLifecycleEvent(STOP_EVENT, null);

    this.lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
    log("Context stopped");
}
 

import org.apache.logging.log4j.core.LifeCycle; //导入依赖的package包/类
@Override
public void onApplicationEvent(final ContextClosedEvent event) {
    logger.info("Gracefully shutting down application.");
    manager.stop();
    try {
        manager.tearDown();
        logger.info("JOAL gracefully shut down.");
    } catch (final IOException e) {
        logger.error("Failed to gracefully shut down JOAL.", e);
    }

    // Since we disabled log4j2 shutdown hook, we need to handle it manually.
    final LifeCycle loggerContext = (LoggerContext) LogManager.getContext(false);
    loggerContext.stop();
}