jdk14loggeradapter.java

Java开发最新的日志记录工具slf4j的源码

   * arguments.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the INFO level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param argArray
   *          an array of arguments
   */
  public void info(String format, Object[] argArray) {
    if (logger.isLoggable(Level.INFO)) {
      String msgStr = MessageFormatter.arrayFormat(format, argArray);
      log(SELF, Level.INFO, msgStr, null);
    }
  }

  /**
   * Log an exception (throwable) at the INFO level with an accompanying
   * message.
   * 
   * @param msg
   *          the message accompanying the exception
   * @param t
   *          the exception (throwable) to log
   */
  public void info(String msg, Throwable t) {
    if (logger.isLoggable(Level.INFO)) {
      log(SELF, Level.INFO, msg, t);
    }
  }

  /**
   * Is this logger instance enabled for the WARNING level?
   * 
   * @return True if this Logger is enabled for the WARNING level, false
   *         otherwise.
   */
  public boolean isWarnEnabled() {
    return logger.isLoggable(Level.WARNING);
  }

  /**
   * Log a message object at the WARNING level.
   * 
   * @param msg -
   *          the message object to be logged
   */
  public void warn(String msg) {
    if (logger.isLoggable(Level.WARNING)) {
      log(SELF, Level.WARNING, msg, null);
    }
  }

  /**
   * Log a message at the WARNING level according to the specified format and
   * argument.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the WARNING level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param arg
   *          the argument
   */
  public void warn(String format, Object arg) {
    if (logger.isLoggable(Level.WARNING)) {
      String msgStr = MessageFormatter.format(format, arg);
      log(SELF, Level.WARNING, msgStr, null);
    }
  }

  /**
   * Log a message at the WARNING level according to the specified format and
   * arguments.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the WARNING level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param arg1
   *          the first argument
   * @param arg2
   *          the second argument
   */
  public void warn(String format, Object arg1, Object arg2) {
    if (logger.isLoggable(Level.WARNING)) {
      String msgStr = MessageFormatter.format(format, arg1, arg2);
      log(SELF, Level.WARNING, msgStr, null);
    }
  }

  /**
   * Log a message at level WARNING according to the specified format and
   * arguments.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the WARNING level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param argArray
   *          an array of arguments
   */
  public void warn(String format, Object[] argArray) {
    if (logger.isLoggable(Level.WARNING)) {
      String msgStr = MessageFormatter.arrayFormat(format, argArray);
      log(SELF, Level.WARNING, msgStr, null);
    }
  }

  /**
   * Log an exception (throwable) at the WARNING level with an accompanying
   * message.
   * 
   * @param msg
   *          the message accompanying the exception
   * @param t
   *          the exception (throwable) to log
   */
  public void warn(String msg, Throwable t) {
    if (logger.isLoggable(Level.WARNING)) {
      log(SELF, Level.WARNING, msg, t);
    }
  }

  /**
   * Is this logger instance enabled for level SEVERE?
   * 
   * @return True if this Logger is enabled for level SEVERE, false otherwise.
   */
  public boolean isErrorEnabled() {
    return logger.isLoggable(Level.SEVERE);
  }

  /**
   * Log a message object at the SEVERE level.
   * 
   * @param msg -
   *          the message object to be logged
   */
  public void error(String msg) {
    if (logger.isLoggable(Level.SEVERE)) {
      log(SELF, Level.SEVERE, msg, null);
    }
  }

  /**
   * Log a message at the SEVERE level according to the specified format and
   * argument.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the SEVERE level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param arg
   *          the argument
   */
  public void error(String format, Object arg) {
    if (logger.isLoggable(Level.SEVERE)) {
      String msgStr = MessageFormatter.format(format, arg);
      log(SELF, Level.SEVERE, msgStr, null);
    }
  }

  /**
   * Log a message at the SEVERE level according to the specified format and
   * arguments.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the SEVERE level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param arg1
   *          the first argument
   * @param arg2
   *          the second argument
   */
  public void error(String format, Object arg1, Object arg2) {
    if (logger.isLoggable(Level.SEVERE)) {
      String msgStr = MessageFormatter.format(format, arg1, arg2);
      log(SELF, Level.SEVERE, msgStr, null);
    }
  }

  /**
   * Log a message at level SEVERE according to the specified format and
   * arguments.
   * 
   * <p>
   * This form avoids superfluous object creation when the logger is disabled
   * for the SEVERE level.
   * </p>
   * 
   * @param format
   *          the format string
   * @param argArray
   *          an array of arguments
   */
  public void error(String format, Object[] argArray) {
    if (logger.isLoggable(Level.SEVERE)) {
      String msgStr = MessageFormatter.arrayFormat(format, argArray);
      log(SELF, Level.SEVERE, msgStr, null);
    }
  }

  /**
   * Log an exception (throwable) at the SEVERE level with an accompanying
   * message.
   * 
   * @param msg
   *          the message accompanying the exception
   * @param t
   *          the exception (throwable) to log
   */
  public void error(String msg, Throwable t) {
    if (logger.isLoggable(Level.SEVERE)) {
      log(SELF, Level.SEVERE, msg, t);
    }
  }

  /**
   * Log the message at the specified level with the specified throwable if any.
   * This method creates a LogRecord and fills in caller date before calling
   * this instance's JDK14 logger.
   * 
   * See bug report #13 for more details.
   * 
   * @param level
   * @param msg
   * @param t
   */
  private void log(String callerFQCN, Level level, String msg, Throwable t) {
    // millis and thread are filled by the constructor
    LogRecord record = new LogRecord(level, msg);
    record.setLoggerName(getName());
    record.setThrown(t);
    fillCallerData(callerFQCN, record);
    logger.log(record);

  }

  static String SELF = JDK14LoggerAdapter.class.getName();
  static String SUPER = MarkerIgnoringBase.class.getName();

  /**
   * Fill in caller data if possible.
   * 
   * @param record
   *          The record to update
   */
  final private void fillCallerData(String callerFQCN, LogRecord record) {
    StackTraceElement[] steArray = new Throwable().getStackTrace();

    int selfIndex = -1;
    for (int i = 0; i < steArray.length; i++) {
      final String className = steArray[i].getClassName();
      if (className.equals(callerFQCN) || className.equals(SUPER)) {
        selfIndex = i;
        break;
      }
    }

    int found = -1;
    for (int i = selfIndex + 1; i < steArray.length; i++) {
      final String className = steArray[i].getClassName();
      if (!(className.equals(callerFQCN) || className.equals(SUPER))) {
        found = i;
        break;
      }
    }

    if (found != -1) {
      StackTraceElement ste = steArray[found];
      // setting the class name has the side effect of setting
      // the needToInferCaller variable to false.
      record.setSourceClassName(ste.getClassName());
      record.setSourceMethodName(ste.getMethodName());
    }
  }
 
  public void log(Marker marker, String callerFQCN, int level, String message,
      Throwable t) {
    Level julLevel;
    switch (level) {
    case LocationAwareLogger.TRACE_INT:
      julLevel = Level.FINEST;
      break;
    case LocationAwareLogger.DEBUG_INT:
      julLevel = Level.FINE;
      break;
    case LocationAwareLogger.INFO_INT:
      julLevel = Level.INFO;
      break;
    case LocationAwareLogger.WARN_INT:
      julLevel = Level.WARNING;
      break;
    case LocationAwareLogger.ERROR_INT:
      julLevel = Level.SEVERE;
      break;
    default:
      throw new IllegalStateException("Level number " + level
          + " is not recognized.");
    }
    // the logger.isLoggable check avoids the unconditional 
    // construction of location data for disabled log
    // statements. As of 2008-07-31, callers of this method 
    // do not perform this check. See also 
    // http://bugzilla.slf4j.org/show_bug.cgi?id=90
    if(logger.isLoggable(julLevel)) {
      log(callerFQCN, julLevel, message, t);
    }
  }
}