Java ConfigurationSource.NULL_SOURCE属性代码示例

/**
 * Ctor. The configuration is built using instance of
 * {@link Spec}:
 * 
 * <ul>
 * <li>The name is set to {@link Spec#getName()}.
 * <li>Appenders from the parent object are cleared.
 * <li>{@link Appender}s are created
 * {@link #buildAppenders(Spec)}.
 * <li>{@link LoggerConfig}s are created using
 * {@link #buildLoggerConfigs(Spec)}.
 * <li>Every {@link LoggerConfig} is configured with its
 * {@link Appender} using
 * {@link #configureLoggerAppenders(Spec, Map, Map)}.
 * <li>Root loggers are configured.
 * </ul>
 * 
 * @param spec
 */
EmbeddedConfiguration(Spec spec) {
  super(ConfigurationSource.NULL_SOURCE);
  setName(spec.getName());

  // Clean up first
  getAppenders().clear();
  getRootLogger().getAppenders().clear();

  // Build Appenders
  final Map<String, Appender> appenders = buildAppenders(spec);
  final Map<String, SyslogAppender> syslogAppenders = buildSyslogAppenders(spec);

  // Build Logger Configs
  final Map<String, LoggerConfig> loggers = buildLoggerConfigs(spec);

  // Configure loggers with appenders
  configureLoggerAppenders(spec, appenders, loggers);

  // Configure root logger appenders
  configureRootLogger(spec, appenders, syslogAppenders);
}
 

public BasicConfiguration() {
    super(null, ConfigurationSource.NULL_SOURCE);

    final LoggerConfig root = getRootLogger();
    final String name = System.getProperty(DEFAULT_LEVEL);
    final Level level = (name != null && Level.getLevel(name) != null) ? Level.getLevel(name) : Level.ERROR;
    root.setLevel(level);
}
 

@Override
public Configuration getConfiguration(LoggerContext loggerContext, ConfigurationSource source) {
    if (source != null && source != ConfigurationSource.NULL_SOURCE) {
        if (LoggingSystem.get(loggerContext.getClass().getClassLoader()) != null) {
            return new DefaultConfiguration();
        }
    }
    return null;
}
 

public BasicConfiguration(final LoggerContext loggerContext) {
    super(loggerContext, ConfigurationSource.NULL_SOURCE);

    final LoggerConfig root = getRootLogger();
    setName("BasicConfiguration");
    final String levelName = System.getProperty(DEFAULT_LEVEL);
    final Level level = (levelName != null && Level.getLevel(levelName) != null) ? Level.getLevel(levelName)
            : Level.DEBUG;
    root.setLevel(level);
}
 

/**
 * Construct the ComponsiteConfiguration.
 *
 * @param configurations The List of Configurations to merge.
 */
public CompositeConfiguration(final List<? extends AbstractConfiguration> configurations) {
    super(configurations.get(0).getLoggerContext(), ConfigurationSource.NULL_SOURCE);
    rootNode = configurations.get(0).getRootNode();
    this.configurations = configurations;
    final String mergeStrategyClassName = PropertiesUtil.getProperties().getStringProperty(MERGE_STRATEGY_PROPERTY,
            DefaultMergeStrategy.class.getName());
    try {
        mergeStrategy = LoaderUtil.newInstanceOf(mergeStrategyClassName);
    } catch (ClassNotFoundException | IllegalAccessException | NoSuchMethodException | InvocationTargetException |
            InstantiationException ex) {
        mergeStrategy = new DefaultMergeStrategy();
    }
    for (final AbstractConfiguration config : configurations) {
        mergeStrategy.mergeRootProperties(rootNode, config);
    }
    final StatusConfiguration statusConfig = new StatusConfiguration().withVerboseClasses(VERBOSE_CLASSES)
            .withStatus(getDefaultStatus());
    for (final Map.Entry<String, String> entry : rootNode.getAttributes().entrySet()) {
        final String key = entry.getKey();
        final String value = getStrSubstitutor().replace(entry.getValue());
        if ("status".equalsIgnoreCase(key)) {
            statusConfig.withStatus(value.toUpperCase());
        } else if ("dest".equalsIgnoreCase(key)) {
            statusConfig.withDestination(value);
        } else if ("shutdownHook".equalsIgnoreCase(key)) {
            isShutdownHookEnabled = !"disable".equalsIgnoreCase(value);
        } else if ("shutdownTimeout".equalsIgnoreCase(key)) {
            shutdownTimeoutMillis = Long.parseLong(value);
        } else if ("verbose".equalsIgnoreCase(key)) {
            statusConfig.withVerbosity(value);
        } else if ("packages".equalsIgnoreCase(key)) {
            pluginPackages.addAll(Arrays.asList(value.split(Patterns.COMMA_SEPARATOR)));
        } else if ("name".equalsIgnoreCase(key)) {
            setName(value);
        }
    }
    statusConfig.initialize();
}
 

public StandaloneLoggerConfiguration() {
    this(ConfigurationSource.NULL_SOURCE);
}
 

protected Log4J2Configuration(ConfigurationSource configurationSource)
{
	super(ConfigurationSource.NULL_SOURCE);
	
	  setName("Default");
	   PatternLayout layout = PatternLayout.newBuilder().withPattern(Log4J2.DEFALT_LAYOUT).withConfiguration(this).build();
        Appender appender = ConsoleAppender.createDefaultAppenderForLayout(layout);
        appender.start();
        addAppender(appender);
        
        String fileName = Config.getProperty(Log4J2.class,"file","");
        String append = Boolean.TRUE.toString();
        String locking = Boolean.TRUE.toString();
        
        String immediateFlush = Boolean.TRUE.toString();
        String ignore = Boolean.TRUE.toString();
        String bufferedIo = Boolean.TRUE.toString();
        String bufferSizeStr = "8192";
        Filter filter = null;
        String advertise = null;
        String advertiseUri = null;
        
        Appender fileAppender = null;
        if(fileName.length() >  0)
        {
        	String name = Config.getProperty(Log4J2.class,"name","default");
        	
        	 fileAppender = FileAppender.createAppender(fileName, append, locking, name, immediateFlush, ignore,
        			bufferedIo, bufferSizeStr, layout, filter, advertise, advertiseUri, this);
        	 
	        fileAppender.start();
	        addAppender(fileAppender);
	  
        }
        	   
        LoggerConfig root = getRootLogger();
        root.addAppender(appender, null, null);
        if(fileAppender != null)
        {
        	root.addAppender(fileAppender, null, filter);	
        }
        
        String levelName = PropertiesUtil.getProperties().getStringProperty("org.apache.logging.log4j.level");
        Level level = levelName == null || Level.valueOf(levelName) == null ? Level.DEBUG : Level.valueOf(levelName);
        root.setLevel(level);
}
 

public CustomConfiguration(final LoggerContext loggerContext) {
    this(loggerContext, ConfigurationSource.NULL_SOURCE);
}
 

@Override
public T build(final boolean initialize) {
    T configuration;
    try {
        if (source == null) {
            source = ConfigurationSource.NULL_SOURCE;
        }
        final Constructor<T> constructor = clazz.getConstructor(LoggerContext.class, ConfigurationSource.class, Component.class);
        configuration = constructor.newInstance(loggerContext, source, root);
        configuration.setMonitorInterval(monitorInterval);
        configuration.getRootNode().getAttributes().putAll(root.getAttributes());
        if (name != null) {
            configuration.setName(name);
        }
        if (level != null) {
            configuration.getStatusConfiguration().withStatus(level);
        }
        if (verbosity != null) {
            configuration.getStatusConfiguration().withVerbosity(verbosity);
        }
        if (destination != null) {
            configuration.getStatusConfiguration().withDestination(destination);
        }
        if (packages != null) {
            configuration.setPluginPackages(packages);
        }
        if (shutdownFlag != null) {
            configuration.setShutdownHook(shutdownFlag);
        }
        if (shutdownTimeoutMillis > 0) {
            configuration.setShutdownTimeoutMillis(shutdownTimeoutMillis);
        }
        if (advertiser != null) {
            configuration.createAdvertiser(advertiser, source);
        }
    } catch (final Exception ex) {
        throw new IllegalArgumentException("Invalid Configuration class specified", ex);
    }
    configuration.getStatusConfiguration().initialize();
    if (initialize) {
        configuration.initialize();
    }
    return configuration;
}