Module java.logging
Package java.util.logging

Class Logger

java.lang.Object
java.util.logging.Logger
public class Logger extends Object
Logger对象用于记录特定系统或应用程序组件的消息。通常使用命名空间的层次结构点分隔来命名记录器。记录器名称可以是任意字符串，但通常应基于被记录组件的包名或类名，例如java.net或javax.swing。此外，还可以创建未存储在记录器命名空间中的“匿名”记录器。

可以通过调用其中一个getLogger工厂方法来获取Logger对象。这些方法将创建一个新的Logger或返回一个合适的现有Logger。重要的是要注意，通过其中一个getLogger工厂方法返回的Logger如果没有保持对Logger的强引用，可能会在任何时候被垃圾回收。

记录消息将被转发到已注册的Handler对象，这些Handler对象可以将消息转发到各种目的地，包括控制台、文件、操作系统日志等。

每个Logger都会跟踪一个“父”Logger，即其在Logger命名空间中的最近现有祖先。

每个Logger都有与之关联的“Level”。这反映了此记录器关心的最低Level。如果Logger的Level设置为null，则其有效Level将从其父级继承，父级可能会递归地从其父级获取，依此类推。

可以根据日志配置文件中的属性配置日志级别，如LogManager类的描述中所述。但也可以通过调用Logger.setLevel方法动态更改日志级别。如果更改了记录器的级别，则此更改也可能会影响子记录器，因为任何具有null作为其级别的子记录器将从其父级继承其有效级别。

在每次记录调用时，Logger最初会对请求级别（例如，SEVERE或FINE）与记录器的有效日志级别进行廉价检查。如果请求级别低于日志级别，则记录调用将立即返回。

通过此初始（廉价）测试后，Logger将分配一个LogRecord来描述记录消息。然后将调用一个Filter（如果存在）来对记录是否应发布进行更详细的检查。如果通过了检查，然后将将LogRecord发布到其输出Handlers。默认情况下，记录器还会递归地将消息发布到其父级的Handlers。

每个Logger可能与一个ResourceBundle关联。ResourceBundle可以通过名称指定，使用getLogger(java.lang.String, java.lang.String)工厂方法，或通过值指定 - 使用setResourceBundle方法。此bundle将用于本地化记录消息。如果Logger没有自己的ResourceBundle或资源包名称，则将从其父级递归地继承ResourceBundle或资源包名称。

大多数记录器输出方法都接受一个“msg”参数。此msg参数可以是原始值，也可以是本地化键。在格式化期间，如果记录器具有（或继承）本地化ResourceBundle，并且ResourceBundle对msg字符串进行了映射，则msg字符串将被本地化值替换。否则将使用原始msg字符串。通常，格式化程序使用java.text.MessageFormat样式的格式化来格式化参数，因此例如格式字符串“{0} {1}”将两个参数格式化为字符串。

一组方法可以选择使用“msgSupplier”而不是“msg”参数。这些方法接受一个Supplier 函数，仅在基于有效日志级别实际要记录消息时才调用该函数来构造所需的日志消息，从而消除不必要的消息构造。例如，如果开发人员想要记录系统健康状态以进行诊断，使用接受String的版本，代码将如下所示： 



  class DiagnosisMessages {
    static String systemHealthStatus() {
      // 收集系统健康信息
      ...
    }
  }
  ...
  logger.log(Level.FINER, DiagnosisMessages.systemHealthStatus());
使用上述代码，即使在禁用日志级别FINER时也会不必要地收集健康状态。使用接受Supplier的版本如下，只有在启用日志级别FINER时才会收集状态。 


  logger.log(Level.FINER, DiagnosisMessages::systemHealthStatus);

在查找ResourceBundle时，记录器首先查看是否使用setResourceBundle指定了一个bundle，然后再查看是否通过getLogger工厂方法指定了资源包名称。如果找不到ResourceBundle或资源包名称，则将使用从其父级树继承的最近的ResourceBundle或资源包名称。
当继承或通过setResourceBundle方法指定ResourceBundle时，将使用该ResourceBundle。否则，如果记录器只有或继承了资源包名称，则将该资源包名称映射到一个ResourceBundle对象，使用日志记录时的默认Locale。
在将资源包名称映射到ResourceBundle对象时，记录器首先尝试使用线程的context class loader将给定的资源包名称映射到ResourceBundle。如果线程上下文类加载器为null，则将尝试使用系统类加载器。如果仍然找不到ResourceBundle，则将使用调用getLogger工厂方法的第一个调用者的类加载器。

格式化（包括本地化）是输出Handler的责任，输出Handler通常会调用Formatter。

请注意，格式化不一定需要同步进行。它可以延迟到LogRecord实际写入外部接收器时才进行。

记录方法分为五个主要类别：

  • 有一组“log”方法，接受一个日志级别、一个消息字符串，以及可选的消息字符串参数。

  • 有一组“logp”方法（用于“log precise”），类似于“log”方法，但还接受一个显式的源类名和方法名。

  • 有一组“logrb”方法（用于“log with resource bundle”），类似于“logp”方法，但还接受一个显式的用于本地化日志消息的资源包对象。

  • 有用于跟踪方法进入（“entering”方法）、方法返回（“exiting”方法）和抛出异常（“throwing”方法）的便利方法。

  • 最后，有一组用于在非常简单的情况下使用的便利方法，当开发人员只想要以给定的日志级别记录一个简单字符串时。这些方法以标准Level名称（“severe”、“warning”、“info”等）命名，并接受一个参数，即消息字符串。

对于不接受显式源名称和方法名称的方法，日志框架将尽力确定调用日志方法的类和方法。但重要的是要意识到，此自动推断的信息可能只是近似的（甚至可能是完全错误的！）。虚拟机在JIT时允许进行广泛的优化，并且可能完全删除堆栈帧，从而无法可靠地定位调用类和方法。

Logger上的所有方法都是多线程安全的。

子类信息：请注意，LogManager类可以为命名空间中的任何点提供自己的命名记录器实现。因此，Logger的任何子类（除非它们与新的LogManager类一起实现）都应注意从LogManager类获取Logger实例，并应将“isLoggable”和“log(LogRecord)”等操作委托给该实例。请注意，为了拦截所有日志输出，子类只需覆盖log(LogRecord)方法。所有其他记录方法都是对此log(LogRecord)方法的调用。

自版本:
1.4

  • Field Details

    • GLOBAL_LOGGER_NAME

      public static final String GLOBAL_LOGGER_NAME
      GLOBAL_LOGGER_NAME是全局记录器的名称。
      自版本:
      1.6
      参见:

    • global

      @Deprecated public static final Logger global
      Deprecated.
      Initialization of this field is prone to deadlocks. The field must be initialized by the Logger class initialization which may cause deadlocks with the LogManager class initialization. In such cases two class initialization wait for each other to complete. The preferred way to get the global logger object is via the call Logger.getGlobal(). For compatibility with old JDK versions where the Logger.getGlobal() is not available use the call Logger.getLogger(Logger.GLOBAL_LOGGER_NAME) or Logger.getLogger("global").
      "global" Logger对象作为Logging包的便利提供给那些偶尔使用Logging包的开发人员。那些严肃使用日志包（例如在产品中）的开发人员应该创建并使用自己的Logger对象，并使用适当的名称，以便可以在适当的每个记录器粒度上控制日志记录。开发人员还需要保持对其Logger对象的强引用，以防止它们被垃圾回收。

  • Constructor Details

    • Logger

      protected Logger(String name, String resourceBundleName)
      用于为命名子系统构造记录器的受保护方法。

      记录器将最初配置为具有空级别和useParentHandlers设置为true。

      参数:
      name - 记录器的名称。这应该是一个点分隔的名称，通常应基于子系统的包名称或类名称，例如java.net或javax.swing。对于匿名记录器，可以为null。
      resourceBundleName - 用于本地化此记录器消息的ResourceBundle的名称。如果没有消息需要本地化，则可以为null。
      抛出:
      MissingResourceException - 如果resourceBundleName不为null且找不到相应的资源。

  • Method Details

    • getGlobal

      public static final Logger getGlobal()
      返回名称为Logger.GLOBAL_LOGGER_NAME的全局记录器对象。
      返回:
      全局记录器对象
      自版本:
      1.7

    • getLogger

      public static Logger getLogger(String name)
      查找或创建一个命名子系统的记录器。如果已经使用给定名称创建了记录器，则返回该记录器。否则，将创建一个新的记录器。

      如果创建了一个新的记录器，其日志级别将根据LogManager配置进行配置，并且将配置为将日志输出发送到其父处理程序。它将在LogManager全局命名空间中注册。

      注意：LogManager可能仅保留对新创建的Logger的弱引用。重要的是要理解，如果程序中没有对Logger的强引用，那么以前创建的具有给定名称的Logger可能随时被垃圾回收。特别是，这意味着像getLogger("MyLogger").log(...)这样的连续调用可能会使用具有不同Logger对象名称"MyLogger"，如果程序中没有对Logger名称"MyLogger"的强引用。

      参数:
      name - 记录器的名称。这应该是一个点分隔的名称，通常应基于子系统的包名称或类名称，例如java.net或javax.swing
      返回:
      一个合适的记录器
      抛出:
      NullPointerException - 如果名称为null。

    • getLogger

      public static Logger getLogger(String name, String resourceBundleName)
      查找或创建一个命名子系统的记录器。如果已经使用给定名称创建了记录器，则返回该记录器。否则，将创建一个新的记录器。

      如果创建了一个新的记录器，其日志级别将根据LogManager配置进行配置，并且将配置为将日志输出发送到其父处理程序。它将在LogManager全局命名空间中注册。

      注意：LogManager可能仅保留对新创建的Logger的弱引用。重要的是要理解，如果程序中没有对Logger的强引用，那么以前创建的具有给定名称的Logger可能随时被垃圾回收。特别是，这意味着像getLogger("MyLogger", ...).log(...)这样的连续调用可能会使用具有不同Logger对象名称"MyLogger"，如果程序中没有对Logger名称"MyLogger"的强引用。

      如果命名的Logger已经存在且尚未具有本地化资源包，则使用给定的资源包名称。如果已经存在具有不同资源包名称的命名Logger，则抛出IllegalArgumentException。

      参数:
      name - 记录器的名称。这应该是一个点分隔的名称，通常应基于子系统的包名称或类名称，例如java.net或javax.swing
      resourceBundleName - 用于本地化此记录器消息的ResourceBundle的名称。如果没有消息需要本地化，则可以为null。
      返回:
      一个合适的记录器
      抛出:
      MissingResourceException - 如果resourceBundleName不为null且找不到相应的资源。
      IllegalArgumentException - 如果记录器已经存在并使用不同的资源包名称；或者如果resourceBundleName为null，但命名记录器已设置资源包。
      NullPointerException - 如果名称为null。

    • getAnonymousLogger

      public static Logger getAnonymousLogger()
      创建一个匿名记录器。新创建的记录器不会在LogManager命名空间中注册。对记录器的更新不会进行访问检查。

      此工厂方法主要用于从小程序中使用。由于生成的记录器是匿名的，因此可以由创建类保持私有。这消除了对正常安全检查的需求，从而允许不受信任的小程序代码更新记录器的控制状态。例如，小程序可以对匿名记录器执行setLevel或addHandler操作。

      即使新记录器是匿名的，它仍配置为具有根记录器("")作为其父记录器。这意味着默认情况下，它会从根记录器继承其有效级别和处理程序。通过setParent方法更改其父记录器仍然需要该方法指定的安全权限。

      返回:
      一个新创建的私有记录器

    • getAnonymousLogger

      public static Logger getAnonymousLogger(String resourceBundleName)
      创建一个匿名记录器。新创建的记录器未在LogManager命名空间中注册。对记录器的更新不会进行访问检查。

      此工厂方法主要用于从小程序中使用。由于生成的记录器是匿名的，可以由创建类保持私有。这消除了正常安全检查的需要，从而允许不受信任的小程序代码更新记录器的控制状态。例如，小程序可以对匿名记录器执行setLevel或addHandler操作。

      即使新记录器是匿名的，它也被配置为将根记录器("")作为其父记录器。这意味着默认情况下，它会从根记录器继承其有效级别和处理程序。通过setParent方法更改其父记录器仍然需要该方法指定的安全权限。

      参数:
      resourceBundleName - 用于本地化此记录器消息的ResourceBundle的名称。如果没有消息需要本地化，则可以为null。
      返回:
      一个新创建的私有记录器
      抛出:
      MissingResourceException - 如果resourceBundleName不为null且找不到相应的资源。

    • getResourceBundle

      public ResourceBundle getResourceBundle()
      检索此记录器的本地化资源包。此方法将返回一个ResourceBundle，该资源包是通过setResourceBundle方法设置的，或者通过当前默认区域设置的getLogger工厂方法设置的资源包名称进行映射。
      请注意，如果结果为null，则记录器将使用从其父记录器继承的资源包或资源包名称。
      返回:
      本地化资源包（可能为null）

    • getResourceBundleName

      public String getResourceBundleName()
      检索此记录器的本地化资源包名称。这是通过getLogger工厂方法指定的名称，或者通过通过setResourceBundle方法设置的ResourceBundle的基本名称。
      请注意，如果结果为null，则记录器将使用从其父记录器继承的资源包或资源包名称。
      返回:
      本地化资源包名称（可能为null）

    • setFilter

      public void setFilter(Filter newFilter) throws SecurityException
      设置用于控制此记录器输出的过滤器。

      在通过初始“级别”检查后，记录器将调用此过滤器以检查是否真的应该发布日志记录。

      参数:
      newFilter - 一个过滤器对象（可能为null）
      抛出:
      SecurityException - 如果存在安全管理器，此记录器不是匿名的，并且调用者没有LoggingPermission("control")。

    • getFilter

      public Filter getFilter()
      获取此记录器的当前过滤器。
      返回:
      一个过滤器对象（可能为null）

    • log

      public void log(LogRecord record)
      记录一个LogRecord。

      此类中的所有其他记录方法都通过此方法实际执行任何记录。子类可以重写此单个方法以捕获所有日志活动。

      参数:
      record - 要发布的LogRecord

    • log

      public void log(Level level, String msg)
      记录一条消息，不带参数。

      如果记录器当前启用给定消息级别，则将给定消息转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      msg - 字符串消息（或消息目录中的键）

    • log

      public void log(Level level, Supplier<String> msgSupplier)
      记录一条消息，仅在日志级别使得消息实际被记录时才构造。

      如果记录器当前启用给定消息级别，则通过调用提供的供应商函数构造消息，并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      msgSupplier - 一个函数，调用时生成所需的日志消息
      自1.8起:
      1.8

    • log

      public void log(Level level, String msg, Object param1)
      记录一条消息，带一个对象参数。

      如果记录器当前启用给定消息级别，则将创建相应的LogRecord并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      msg - 字符串消息（或消息目录中的键）
      param1 - 消息的参数

    • log

      public void log(Level level, String msg, Object[] params)
      记录一条消息，带一组对象参数。

      如果记录器当前启用给定消息级别，则将创建相应的LogRecord并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      msg - 字符串消息（或消息目录中的键）
      params - 消息的参数数组

    • log

      public void log(Level level, String msg, Throwable thrown)
      记录一条消息，带相关的Throwable信息。

      如果记录器当前启用给定消息级别，则给定的参数将存储在一个LogRecord中，该LogRecord将转发到所有注册的输出处理程序。

      请注意，抛出的参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性。因此，它由输出格式化程序特殊处理，并且不被视为LogRecord消息属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      msg - 字符串消息（或消息目录中的键）
      thrown - 与日志消息关联的Throwable

    • log

      public void log(Level level, Throwable thrown, Supplier<String> msgSupplier)
      记录一个延迟构造的消息，带相关的Throwable信息。

      如果记录器当前启用给定消息级别，则通过调用提供的供应商函数构造消息。然后，消息和给定的Throwable存储在一个LogRecord中，该LogRecord将转发到所有注册的输出处理程序。

      请注意，抛出的参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性。因此，它由输出格式化程序特殊处理，并且不被视为LogRecord消息属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      thrown - 与日志消息关联的Throwable
      msgSupplier - 一个函数，调用时生成所需的日志消息
      自1.8起:
      1.8

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg)
      记录一条消息，指定源类和方法，不带参数。

      如果记录器当前启用给定消息级别，则将给定消息转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类的名称
      sourceMethod - 发出日志请求的方法的名称
      msg - 字符串消息（或消息目录中的键）

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, Supplier<String> msgSupplier)
      记录一个延迟构造的消息，指定源类和方法，不带参数。

      如果记录器当前启用给定消息级别，则通过调用提供的供应商函数构造消息，并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类的名称
      sourceMethod - 发出日志请求的方法的名称
      msgSupplier - 一个函数，调用时生成所需的日志消息
      自1.8起:
      1.8

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1)
      记录一条消息，指定源类和方法，带一个对象参数到日志消息。

      如果记录器当前启用给定消息级别，则将创建相应的LogRecord并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类的名称
      sourceMethod - 发出日志请求的方法的名称
      msg - 字符串消息（或消息目录中的键）
      param1 - 日志消息的参数

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object[] params)
      记录一条消息，指定源类和方法，带一组对象参数。

      如果记录器当前启用给定消息级别，则将创建相应的LogRecord并将其转发到所有注册的输出处理程序对象。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类的名称
      sourceMethod - 发出日志请求的方法的名称
      msg - 字符串消息（或消息目录中的键）
      params - 消息的参数数组

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown)
      记录一条消息，指定源类和方法，带相关的Throwable信息。

      如果记录器当前启用给定消息级别，则给定的参数将存储在一个LogRecord中，该LogRecord将转发到所有注册的输出处理程序。

      请注意，抛出的参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性。因此，它由输出格式化程序特殊处理，并且不被视为LogRecord消息属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      msg - 字符串消息（或消息目录中的键）
      thrown - 与日志消息关联的Throwable

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, Throwable thrown, Supplier<String> msgSupplier)
      记录一个延迟构造的消息，指定源类和方法，并附带Throwable信息。

      如果记录器当前已启用给定的消息级别，则通过调用提供的供应函数构造消息。然后，消息和给定的Throwable被存储在一个LogRecord中，然后转发到所有已注册的输出处理程序。

      请注意，thrown参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性中。因此，它由输出格式化程序特殊处理，并不被视为LogRecord消息属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      thrown - 与日志消息关联的Throwable
      msgSupplier - 一个函数，调用时生成所需的日志消息
      自版本:
      1.8

    • logrb

      @Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg)
      Deprecated.
      Use logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.util.ResourceBundle, java.lang.String, java.lang.Object...) instead.
      记录一条消息，指定源类、方法和资源包名称，不带参数。

      如果记录器当前已启用给定的消息级别，则给定的消息将转发到所有已注册的输出处理程序。

      使用命名资源包本地化msg字符串。如果资源包名称为null、空字符串或无效，则不对msg字符串进行本地化。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundleName - 用于本地化msg的资源包名称，可以为null
      msg - 字符串消息（或消息目录中的键）

    • logrb

      @Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object param1)
      Deprecated.
      Use logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.util.ResourceBundle, java.lang.String, java.lang.Object...) instead
      记录一条消息，指定源类、方法和资源包名称，并带有单个对象参数的日志消息。

      如果记录器当前已启用给定的消息级别，则将创建相应的LogRecord并转发到所有已注册的输出处理程序。

      使用命名资源包本地化msg字符串。如果资源包名称为null、空字符串或无效，则不对msg字符串进行本地化。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundleName - 用于本地化msg的资源包名称，可以为null
      msg - 字符串消息（或消息目录中的键）
      param1 - 日志消息的参数

    • logrb

      @Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object[] params)
      Deprecated.
      Use logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.util.ResourceBundle, java.lang.String, java.lang.Object...) instead.
      记录一条消息，指定源类、方法和资源包名称，并带有对象参数数组的日志消息。

      如果记录器当前已启用给定的消息级别，则将创建相应的LogRecord并转发到所有已注册的输出处理程序。

      使用命名资源包本地化msg字符串。如果资源包名称为null、空字符串或无效，则不对msg字符串进行本地化。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundleName - 用于本地化msg的资源包名称，可以为null
      msg - 字符串消息（或消息目录中的键）
      params - 消息的参数数组

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, ResourceBundle bundle, String msg, Object... params)
      记录一条消息，指定源类、方法和资源包，带有可选的消息参数列表。

      如果记录器当前已启用给定的消息级别，则将创建相应的LogRecord并转发到所有已注册的输出Handler对象。

      使用给定的资源包对msg字符串进行本地化。如果资源包为null，则不对msg字符串进行本地化。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundle - 用于本地化msg的资源包，可以为null
      msg - 字符串消息（或消息目录中的键）
      params - 消息的参数（可选，可能没有）
      自版本:
      1.8

    • logrb

      public void logrb(Level level, ResourceBundle bundle, String msg, Object... params)
      记录一条消息，指定源类、方法和资源包，带有可选的消息参数列表。

      如果记录器当前已启用给定的消息level，则将创建相应的LogRecord并转发到所有已注册的输出Handler对象。

      使用给定的资源包对msg字符串进行本地化。如果资源包为null，则不对msg字符串进行本地化。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      bundle - 用于本地化msg的资源包；可以为null
      msg - 字符串消息（或消息目录中的键）
      params - 消息的参数（可选，可能没有）
      自版本:
      9

    • logrb

      @Deprecated public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Throwable thrown)
      Deprecated.
      Use logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.util.ResourceBundle, java.lang.String, java.lang.Throwable) instead.
      记录一条消息，指定源类、方法和资源包名称，并附带Throwable信息。

      如果记录器当前已启用给定的消息级别，则给定的参数将存储在一个LogRecord中，然后转发到所有已注册的输出处理程序。

      使用命名资源包本地化msg字符串。如果资源包名称为null、空字符串或无效，则不对msg字符串进行本地化。

      请注意，thrown参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性中。因此，它由输出格式化程序特殊处理，并不被视为LogRecord消息属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundleName - 用于本地化msg的资源包名称，可以为null
      msg - 字符串消息（或消息目录中的键）
      thrown - 与日志消息关联的Throwable

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, ResourceBundle bundle, String msg, Throwable thrown)
      记录一条消息，指定源类、方法和资源包，并附带Throwable信息。

      如果记录器当前已启用给定的消息level，则给定的参数将存储在一个LogRecord中，然后转发到所有已注册的输出处理程序。

      使用给定的资源包对msg字符串进行本地化。如果资源包为null，则不对msg字符串进行本地化。

      请注意，thrown参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性中。因此，它由输出Formatter对象特殊处理，并不被视为LogRecord的message属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      sourceClass - 发出日志请求的类名
      sourceMethod - 发出日志请求的方法名
      bundle - 用于本地化msg的资源包，可以为null
      msg - 字符串消息（或消息目录中的键）
      thrown - 与日志消息关联的Throwable
      自版本:
      1.8

    • logrb

      public void logrb(Level level, ResourceBundle bundle, String msg, Throwable thrown)
      记录一条消息，指定源类、方法和资源包，并附带Throwable信息。

      如果记录器当前已启用给定的消息level，则给定的参数将存储在一个LogRecord中，然后转发到所有已注册的输出处理程序。

      使用给定的资源包对msg字符串进行本地化。如果资源包为null，则不对msg字符串进行本地化。

      请注意，thrown参数存储在LogRecord的thrown属性中，而不是LogRecord的parameters属性中。因此，它由输出Formatter对象特殊处理，并不被视为LogRecord的message属性的格式化参数。

      参数:
      level - 消息级别标识符之一，例如，SEVERE
      bundle - 用于本地化msg的资源包；可以为null
      msg - 字符串消息（或消息目录中的键）
      thrown - 与日志消息关联的Throwable
      自版本:
      9

    • entering

      public void entering(String sourceClass, String sourceMethod)
      记录一个方法入口。

      这是一个方便的方法，可用于记录方法的入口。将记录一条消息为"ENTRY"，日志级别为FINER，并记录给定的sourceMethod和sourceClass。

      参数:
      sourceClass - 发出日志请求的类名
      sourceMethod - 正在进入的方法的名称

    • entering

      public void entering(String sourceClass, String sourceMethod, Object param1)
      Log a method entry, with one parameter.

      This is a convenience method that can be used to log entry to a method. A LogRecord with message "ENTRY {0}", log level FINER, and the given sourceMethod, sourceClass, and parameter is logged.

      Parameters:
      sourceClass - name of class that issued the logging request
      sourceMethod - name of method that is being entered
      param1 - parameter to the method being entered

    • entering

      public void entering(String sourceClass, String sourceMethod, Object[] params)
      Log a method entry, with an array of parameters.

      This is a convenience method that can be used to log entry to a method. A LogRecord with message "ENTRY" (followed by a format {N} indicator for each entry in the parameter array), log level FINER, and the given sourceMethod, sourceClass, and parameters is logged.

      Parameters:
      sourceClass - name of class that issued the logging request
      sourceMethod - name of method that is being entered
      params - array of parameters to the method being entered

    • exiting

      public void exiting(String sourceClass, String sourceMethod)
      Log a method return.

      This is a convenience method that can be used to log returning from a method. A LogRecord with message "RETURN", log level FINER, and the given sourceMethod and sourceClass is logged.

      Parameters:
      sourceClass - name of class that issued the logging request
      sourceMethod - name of the method

    • exiting

      public void exiting(String sourceClass, String sourceMethod, Object result)
      Log a method return, with result object.

      This is a convenience method that can be used to log returning from a method. A LogRecord with message "RETURN {0}", log level FINER, and the gives sourceMethod, sourceClass, and result object is logged.

      Parameters:
      sourceClass - name of class that issued the logging request
      sourceMethod - name of the method
      result - Object that is being returned

    • throwing

      public void throwing(String sourceClass, String sourceMethod, Throwable thrown)
      Log throwing an exception.

      This is a convenience method to log that a method is terminating by throwing an exception. The logging is done using the FINER level.

      If the logger is currently enabled for the given message level then the given arguments are stored in a LogRecord which is forwarded to all registered output handlers. The LogRecord's message is set to "THROW".

      Note that the thrown argument is stored in the LogRecord thrown property, rather than the LogRecord parameters property. Thus it is processed specially by output Formatters and is not treated as a formatting parameter to the LogRecord message property.

      Parameters:
      sourceClass - name of class that issued the logging request
      sourceMethod - name of the method.
      thrown - The Throwable that is being thrown.

    • severe

      public void severe(String msg)
      Log a SEVERE message.

      If the logger is currently enabled for the SEVERE message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • warning

      public void warning(String msg)
      Log a WARNING message.

      If the logger is currently enabled for the WARNING message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • info

      public void info(String msg)
      Log an INFO message.

      If the logger is currently enabled for the INFO message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • config

      public void config(String msg)
      Log a CONFIG message.

      If the logger is currently enabled for the CONFIG message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • fine

      public void fine(String msg)
      Log a FINE message.

      If the logger is currently enabled for the FINE message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • finer

      public void finer(String msg)
      Log a FINER message.

      If the logger is currently enabled for the FINER message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • finest

      public void finest(String msg)
      Log a FINEST message.

      If the logger is currently enabled for the FINEST message level then the given message is forwarded to all the registered output Handler objects.

      Parameters:
      msg - The string message (or a key in the message catalog)

    • severe

      public void severe(Supplier<String> msgSupplier)
      Log a SEVERE message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the SEVERE message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • warning

      public void warning(Supplier<String> msgSupplier)
      Log a WARNING message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the WARNING message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • info

      public void info(Supplier<String> msgSupplier)
      Log a INFO message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the INFO message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • config

      public void config(Supplier<String> msgSupplier)
      Log a CONFIG message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the CONFIG message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • fine

      public void fine(Supplier<String> msgSupplier)
      Log a FINE message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the FINE message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • finer

      public void finer(Supplier<String> msgSupplier)
      Log a FINER message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the FINER message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • finest

      public void finest(Supplier<String> msgSupplier)
      Log a FINEST message, which is only to be constructed if the logging level is such that the message will actually be logged.

      If the logger is currently enabled for the FINEST message level then the message is constructed by invoking the provided supplier function and forwarded to all the registered output Handler objects.

      Parameters:
      msgSupplier - A function, which when called, produces the desired log message
      Since:
      1.8

    • setLevel

      public void setLevel(Level newLevel) throws SecurityException
      Set the log level specifying which message levels will be logged by this logger. Message levels lower than this value will be discarded. The level value Level.OFF can be used to turn off logging.

      If the new level is null, it means that this node should inherit its level from its nearest ancestor with a specific (non-null) level value.

      Parameters:
      newLevel - the new value for the log level (may be null)
      Throws:
      SecurityException - if a security manager exists, this logger is not anonymous, and the caller does not have LoggingPermission("control").

    • getLevel

      public Level getLevel()
      Get the log Level that has been specified for this Logger. The result may be null, which means that this logger's effective level will be inherited from its parent.
      Returns:
      this Logger's level

    • isLoggable

      public boolean isLoggable(Level level)
      Check if a message of the given level would actually be logged by this logger. This check is based on the Loggers effective level, which may be inherited from its parent.
      Parameters:
      level - a message logging level
      Returns:
      true if the given message level is currently being logged.

    • getName

      public String getName()
      Get the name for this logger.
      Returns:
      logger name. Will be null for anonymous Loggers.

    • addHandler

      public void addHandler(Handler handler) throws SecurityException
      Add a log Handler to receive logging messages.

      By default, Loggers also send their output to their parent logger. Typically the root Logger is configured with a set of Handlers that essentially act as default handlers for all loggers.

      Parameters:
      handler - a logging Handler
      Throws:
      SecurityException - if a security manager exists, this logger is not anonymous, and the caller does not have LoggingPermission("control").

    • removeHandler

      public void removeHandler(Handler handler) throws SecurityException
      移除一个日志处理器。

      如果未找到给定的处理器或处理器为空，则静默返回。

      参数:
      handler - 一个日志处理器
      抛出:
      SecurityException - 如果存在安全管理器，此记录器不是匿名的，并且调用者没有LoggingPermission("control")。

    • getHandlers

      public Handler[] getHandlers()
      获取与此记录器关联的处理器。
      返回:
      所有已注册处理器的数组

    • setUseParentHandlers

      public void setUseParentHandlers(boolean useParentHandlers)
      指定此记录器是否应将其输出发送到其父记录器。这意味着任何LogRecords也将被写入父处理器，并且可能递归地写入其父记录器的处理器。
      参数:
      useParentHandlers - 如果要将输出发送到记录器的父级，则为true。
      抛出:
      SecurityException - 如果存在安全管理器，此记录器不是匿名的，并且调用者没有LoggingPermission("control")。

    • getUseParentHandlers

      public boolean getUseParentHandlers()
      发现此记录器是否将其输出发送到其父记录器。
      返回:
      如果要将输出发送到记录器的父级，则为true

    • setResourceBundle

      public void setResourceBundle(ResourceBundle bundle)
      在此记录器上设置资源包。所有消息将使用给定的资源包记录其特定的locale。
      参数:
      bundle - 此记录器将使用的资源包。
      抛出:
      NullPointerException - 如果给定的资源包为null。
      IllegalArgumentException - 如果给定的资源包没有基本名称，或者如果此记录器已经设置了资源包但给定的资源包具有不同的基本名称。
      SecurityException - 如果存在安全管理器，此记录器不是匿名的，并且调用者没有LoggingPermission("control")。
      自版本:
      1.8

    • getParent

      public Logger getParent()
      返回此记录器的父记录器。

      此方法返回命名空间中最近存在的父记录器。因此，如果一个记录器被称为"a.b.c.d"，并且已创建一个名为"a.b"的记录器，但不存在记录器"a.b.c"，那么在记录器"a.b.c.d"上调用getParent将返回记录器"a.b"。

      如果在命名空间中的根记录器上调用它，则结果将为null。

      返回:
      最近存在的父记录器

    • setParent

      public void setParent(Logger parent)
      为此记录器设置父记录器。当命名空间更改时，LogManager使用此方法更新记录器。

      不应从应用程序代码中调用此方法。

      参数:
      parent - 新的父记录器
      抛出:
      SecurityException - 如果存在安全管理器，并且调用者没有LoggingPermission("control")。