Java ILoggerFactory類代碼示例

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private Set<Class<? extends ILoggerFactory>> lookUpConfiguredLoggerFactory() {
    final Set<Class<? extends ILoggerFactory>> loggerFactories = new HashSet<>();

    final String configuredLoggerFactory = System.getProperty(ENVIRONMENT_VAR_LOGGER_FACTORY);
    if (StringUtils.isNotBlank(configuredLoggerFactory)) {
        Util.report("Instructed logger factory to use is " + configuredLoggerFactory);
        try {
            final Class clazz = Class.forName(configuredLoggerFactory);
            loggerFactories.add(clazz);
        } catch (final Exception e) {
            Util.report("Could not locate the provided logger factory: " + configuredLoggerFactory + ". Error: " + e.getMessage());
        }
    }

    return loggerFactories;
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private void flushLogs() {
  final long millisToWait = 100;

  LOG.info("Attempting to flush logs and wait {} ...", JavaUtils.durationFromMillis(millisToWait));

  ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
  if (loggerFactory instanceof LoggerContext) {
    LoggerContext context = (LoggerContext) loggerFactory;
    context.stop();
  }

  try {
    Thread.sleep(millisToWait);
  } catch (Exception e) {
    LOG.info("While sleeping for log flush", e);
  }
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
/**
 * Sets references to the LoggerContext. Must be called whenever logging
 * configuration changes between {@link #startCaching()} and {@link #stopAndFlush()}
 */
public static synchronized void initContext() {
	ILoggerFactory iLoggerFactory = LoggerFactory.getILoggerFactory();
	if (!(iLoggerFactory instanceof LoggerContext)) {
		// Not using LogBack, CacheAppender not applicable
		LOGGER.debug("Not using LogBack, aborting CacheLogger");
		loggerContext = null;
		return;
	} else if (!isActive()) {
		LOGGER.error("initContext() cannot be called while isActive() is false");
		return;
	}

	loggerContext = (LoggerContext) iLoggerFactory;
	rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
	disposeOfAppenders();
	detachRootAppenders();
	if (!rootLogger.isAttached(cacheAppender)) {
		rootLogger.addAppender(cacheAppender);
	}
	cacheAppender.setContext(loggerContext);
	cacheAppender.setName("CacheAppender");
	cacheAppender.start();
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private static boolean setContextAndRoot() {
	ILoggerFactory ilf = LoggerFactory.getILoggerFactory();
	if (!(ilf instanceof LoggerContext)) {
		// Not using LogBack.
		// Can't configure the logger, so just exit
		LOGGER.debug("Not using LogBack, aborting LogBack configuration");
		return false;
	}
	loggerContext = (LoggerContext) ilf;
	rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
	if (rootLogger == null) {
		// Shouldn't be possible
		LOGGER.error("Couldn't find root logger, aborting LogBack configuration");
		return false;
	}
	return true;
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
/**
 * Set the log level for the requested logger name.
 *
 * @param loggerName name of the logger
 * @param logLevel the log level to set to.
 * @return the current log level of the given logger. If there is no log level configured for the given logger or
 *         if the logging implementation is not logback, {@code null} will be returned
 */
@Nullable
private String setLogLevel(String loggerName, @Nullable String logLevel) {
  ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
  if (!(loggerFactory instanceof LoggerContext)) {
    LOG.error("LoggerFactory is not a logback LoggerContext, cannot make the log level change");
    return null;
  }
  LoggerContext loggerContext = (LoggerContext) loggerFactory;

  ch.qos.logback.classic.Logger logger = loggerContext.getLogger(loggerName);
  LogEntry.Level oldLogLevel = logger.getLevel() == null ? null :
    LogEntry.Level.valueOf(logger.getLevel().toString());
  LOG.debug("Log level of {} changed from {} to {}", loggerName, oldLogLevel, logLevel);
  logger.setLevel(logLevel == null ? null : Level.toLevel(logLevel, Level.ERROR));

  return oldLogLevel == null ? null : oldLogLevel.name();
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
public static LoggerContext buildLoggerContext(Map<String, String> props) {
    if (loggerContext == null) {
        ILoggerFactory lcObject = LoggerFactory.getILoggerFactory();

        if (!(lcObject instanceof LoggerContext)) {
            throw new LogbackException("Expected LOGBACK binding with SLF4J, but another log system has taken the place: "
                                       + lcObject.getClass().getSimpleName());
        }

        loggerContext = (LoggerContext) lcObject;
        if (props != null) {
            for (Map.Entry<String, String> entry : props.entrySet()) {
                loggerContext.putProperty(entry.getKey(), entry.getValue());
            }
        }
    }

    return loggerContext;
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private void configureLogger() {
  // Check if SLF4J is bound to logback in the current environment
  ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
  if (!(loggerFactory instanceof LoggerContext)) {
    return;
  }

  LoggerContext context = (LoggerContext) loggerFactory;
  context.reset();
  JoranConfigurator configurator = new JoranConfigurator();
  configurator.setContext(context);

  try {
    File twillLogback = new File(Constants.Files.LOGBACK_TEMPLATE);
    if (twillLogback.exists()) {
      configurator.doConfigure(twillLogback);
    }
    new ContextInitializer(context).autoConfig();
  } catch (JoranException e) {
    throw Throwables.propagate(e);
  }
  doConfigure(configurator, getLogConfig(getLoggerLevel(context.getLogger(Logger.ROOT_LOGGER_NAME))));
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private void init() {
    BlockingQueue<ILoggingEvent> queue = new LinkedBlockingDeque<ILoggingEvent>();

    installClient(queue);

    ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
    if (!(loggerFactory instanceof LoggerContext))
        throw new IllegalStateException("This service must be run with Logback Classic");

    LoggerContext loggerContext = (LoggerContext) loggerFactory;
    ch.qos.logback.classic.Logger root = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    String appenderName = getClass().getName();
    Appender<ILoggingEvent> appender = root.getAppender(appenderName);
    if (appender != null)
        throw new IllegalStateException("Appender " + appenderName + " already configured");

    RemoteLoggerAppender remoteAppender = new RemoteLoggerAppender(queue, hostname);
    remoteAppender.setContext(loggerContext);
    remoteAppender.addFilter(MDCFilter.instance);
    remoteAppender.start();
    root.addAppender(remoteAppender);
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
@Before
public void init() throws Exception {
       TimeZone.setDefault(TimeZone.getTimeZone("UTC"));

	request = mock(HttpServletRequest.class);
	response = mock(HttpServletResponse.class);
	registry = new EventLoggingRegistry();
	EventLogDefinition eld = new EventLogDefinition();
	eld.setRegistry(registry);
	eld.setLogName("ACCESS-LOG");
	eld.register();

       loggerFactory = mock(ILoggerFactory.class);
       oldLoggerFactory = HttpRequestLogger.setLoggerFactory(loggerFactory);
       eventLog = mock(Logger.class);
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
@GetMapping
public String init(Model model)
{
	ILoggerFactory iLoggerFactory = LoggerFactory.getILoggerFactory();
	if (!(iLoggerFactory instanceof LoggerContext))
	{
		throw new RuntimeException("Logger factory is not a Logback logger context");
	}
	LoggerContext loggerContext = (LoggerContext) iLoggerFactory;

	List<Logger> loggers = new ArrayList<>();
	for (ch.qos.logback.classic.Logger logger : loggerContext.getLoggerList())
	{
		if (logger.getLevel() != null || logger.iteratorForAppenders().hasNext())
		{
			loggers.add(logger);
		}
	}

	model.addAttribute("loggers", loggers);
	model.addAttribute("levels", LOG_LEVELS);
	model.addAttribute("hasWritePermission", SecurityUtils.currentUserIsSu());
	return "view-logmanager";
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
@PreAuthorize("hasAnyRole('ROLE_SU')")
@PostMapping("/loggers/reset")
@ResponseStatus(HttpStatus.OK)
public void resetLoggers()
{
	ILoggerFactory iLoggerFactory = LoggerFactory.getILoggerFactory();
	if (!(iLoggerFactory instanceof LoggerContext))
	{
		throw new RuntimeException("Logger factory is not a Logback logger context");
	}
	LoggerContext loggerContext = (LoggerContext) iLoggerFactory;
	ContextInitializer ci = new ContextInitializer(loggerContext);
	URL url = ci.findURLOfDefaultConfigurationFile(true);
	loggerContext.reset();
	try
	{
		ci.configureByResource(url);
	}
	catch (JoranException e)
	{
		LOG.error("Error reloading log configuration", e);
		throw new RuntimeException(e);
	}
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
public static ServiceLocator initServiceLocator() {
  DefaultServiceLocator locator = MavenRepositorySystemUtils.newServiceLocator();
  locator.setErrorHandler(
      new DefaultServiceLocator.ErrorHandler() {
        @Override
        public void serviceCreationFailed(Class<?> type, Class<?> impl, Throwable exception) {
          throw new RuntimeException(
              String.format(
                  "Failed to initialize service %s, implemented by %s: %s",
                  type.getName(), impl.getName(), exception.getMessage()),
              exception);
        }
      });
  locator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
  locator.addService(TransporterFactory.class, HttpTransporterFactory.class);
  locator.addService(TransporterFactory.class, FileTransporterFactory.class);
  // Use a no-op logger. Leaving this out would introduce a runtime dependency on log4j
  locator.addService(ILoggerFactory.class, NOPLoggerFactory.class);
  // Also requires log4j
  //    locator.addService(ILoggerFactory.class, Log4jLoggerFactory.class);
  return locator;
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private Set<Class<? extends ILoggerFactory>> scanContextForLoggerFactories() {
    final Set<Class<? extends ILoggerFactory>> loggerFactories;
    final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN);
    final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));

    loggerFactories = reflections.getSubTypesOf(ILoggerFactory.class);
    loggerFactories.remove(this.getClass());
    return loggerFactories;
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
private static ILoggerFactory getLoggerFactoryBeInstantiated(final Class<? extends ILoggerFactory> loggerFactory) {
    try {
        return loggerFactory.newInstance();
    } catch (final Exception e) {
        return null;
    }
}
 

import org.slf4j.ILoggerFactory; //導入依賴的package包/類
/**
 * Instantiates a new Cas logger factory.
 * Configures the reflection scanning engine to be prepared to scan <code>org.slf4j.impl</code>
 * in order to find other available factories.
 */
public CasLoggerFactory() {
    this.loggerMap = new ConcurrentHashMap<>();
    final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN);
    final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));

    final Set<Class<? extends ILoggerFactory>> subTypesOf = reflections.getSubTypesOf(ILoggerFactory.class);
    subTypesOf.remove(this.getClass());

    if (subTypesOf.size() > 1) {
        Util.report("Multiple ILoggerFactory bindings are found on the classpath:");
        for (final Class<? extends ILoggerFactory> c : subTypesOf) {
            Util.report("* " + c.getCanonicalName());
        }
    }

    if (subTypesOf.isEmpty()) {
        final RuntimeException e = new RuntimeException("No ILoggerFactory could be found on the classpath."
                + " CAS cannot determine the logging framework."
                + " Examine the project dependencies and ensure that there is one and only one logging framework available.");

        Util.report(e.getMessage(), e);
        throw e;
    }
    this.realLoggerFactoryClass = subTypesOf.iterator().next();
    Util.report("ILoggerFactory to be used for logging is: " + this.realLoggerFactoryClass.getName());
}