SLF4J - 快速指南

---

SLF4J - 概述

SLF4J代表Simple Logging F acade for Java。它提供了 Java 中所有日志框架的简单抽象。因此，它使用户能够使用单一依赖项使用任何日志记录框架，例如 Log4j、Logback 和JUL (java.util.logging)。您可以在运行时/部署时迁移到所需的日志记录框架。

Ceki Gülcü 创建了 SLF4J 作为 Jakarta 公共日志框架的替代方案。

SLF4J的优点

以下是 SLF4J 的优点 -

• 使用SLF4J框架，您可以在部署时迁移到所需的日志记录框架。

• Slf4J 提供了对所有流行日志框架的绑定，例如 log4j、JUL、简单日志记录和 NOP。因此，您可以在部署时切换到任何这些流行的框架。

• SLF4J 提供对参数化日志消息的支持，无论您使用什么绑定。

• 由于 SLF4J 将应用程序和日志框架解耦，因此您可以轻松编写独立于日志框架的应用程序。您无需担心用于编写应用程序的日志记录框架。

• SLF4J 提供了一个简单的 Java 工具，称为迁移器。使用此工具，您可以将使用 Jakarta Commons Logging (JCL) 或 log4j 或 Java.util.logging (JUL) 等日志框架工作的现有项目迁移到 SLF4J。

SLF4J - 日志框架

编程登录是指记录活动/事件。通常，应用程序开发人员应该负责日志记录。

为了使日志记录工作变得更容易，Java 提供了各种框架 - log4J、java.util.logging (JUL)、tiny log、logback 等。

日志框架概述

日志框架通常包含三个元素 -

记录器

捕获消息以及元数据。

格式化程序

格式化记录器捕获的消息。

处理程序

处理程序或附加程序最终通过在控制台上打印、存储在数据库中或通过电子邮件发送来分派消息。

一些框架结合了记录器和附加器元素来加速操作。

记录器对象

为了记录消息，应用程序发送带有名称和安全级别的记录器对象（有时连同异常（如果有））。

严重程度

记录的消息有不同的级别。下表列出了日志记录的一般级别。

SLF4J 与 Log4j

什么是 log4j？

log4j 是一个用 Java 编写的可靠、快速且灵活的日志框架 (API)，根据 Apache 软件许可证分发。

log4j 在运行时可以通过外部配置文件进行高度配置。它按照优先级级别查看日志记录过程，并提供将日志记录信息定向到各种目的地的机制，例如数据库、文件、控制台、UNIX Syslog 等（有关 log4j 的更多详细信息，请参阅我们的教程）。

SLF4J 和 Log4j 的比较

与 log4j 不同，SLF4J ( Simple Logging Facade for Java ) 不是日志框架的实现，它是Java 中所有与log4J 类似的日志框架的抽象。因此，你不能比较两者。然而，在两者之间选择其一总是很困难的。

如果可以选择，日志抽象总是比日志框架更可取。如果您使用日志抽象，特别是 SLF4J，则可以在部署时迁移到您需要的任何日志框架，而无需选择单一依赖项。

观察下图可以更好地理解。

SLF4J - 环境设置

本章将介绍如何在 Eclipse IDE 中设置 SLF4J 环境。在继续安装之前，请确保您的系统中已安装 Eclipse。如果没有，请下载并安装 Eclipse。

有关 Eclipse 的更多信息，请参阅我们的Eclipse 教程

第 1 步：下载依赖 JAR 文件

打开SLF4J网站官方主页，进入下载页面。

现在，根据您的操作系统（如果是 Windows .zip 文件或 Linux tar.gz 文件）下载最新稳定版本的slf4j-XXtar.gz或slf4j-XXzip 。

在下载的文件夹中，您将找到slf4j-api-XXjar。这是所需的 Jar 文件。

步骤2：创建项目并设置构建路径

打开 eclipse 并创建一个示例项目。右键单击该项目，选择选项“构建路径”→“配置构建路径...”，如下所示。

在“库”选项卡的“Java 构建路径”框架中，单击“添加外部 JAR...”

选择下载的slf4j-api.xxjar文件，然后单击“应用并关闭”。

SLF4J 绑定

除了slf4j-api.xxjar文件之外，SLF4J还提供了其他几个 Jar 文件，如下所示。这些称为SLF4J 绑定。

其中每个绑定都适用于其各自的日志记录框架。

下表列出了 SLF4J 绑定及其相应的框架。

要使 SLF4J 与 slf4l-api-xxjar 一起工作，您需要在项目的类路径（设置构建路径）中添加所需记录器框架的相应 Jar 文件（绑定）。

要从一种框架切换到另一种框架，您需要替换相应的绑定。如果没有找到边界，则默认为无操作模式。

SLF4J 的 Pom.xml

如果您正在创建maven项目，请打开pom.xml并将以下内容粘贴到其中并刷新项目。

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>Sample</groupId>
   <artifactId>Sample</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
      </plugins>
   </build>
   <dependencies>
      <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-api</artifactId>
         <version>1.7.25</version>
      </dependency>
   </dependencies>
</project>

SLF4J - 参考 API

在本章中，我们将讨论本教程后续章节中将使用的类和方法。

记录仪接口

org.slf4j包的记录器接口是 SLF4J API 的入口点。下面列出该接口的重要方法。

LoggerFactory类

org.slf4j包的 LoggerFactory 类是一个实用程序类，用于为各种日志记录 API（例如 log4j、JUL、NOP 和简单记录器）生成记录器。

分析器类

该类属于org.slf4j包，用于分析目的，被称为穷人的分析器。使用它，程序员可以找出执行长时间任务所需的时间。

以下是该类的重要方法。

SLF4J - 你好世界

在本章中，我们将看到一个使用 SLF4J 的简单基本记录器程序。按照下面描述的步骤编写一个简单的记录器。

步骤 1 - 创建 slf4j.Logger 接口的对象

由于slf4j.Logger是 SLF4J API 的入口点，因此首先需要获取/创建它的对象

LoggerFactory类的getLogger ()方法接受表示名称的字符串值，并返回具有指定名称的Logger对象。

Logger logger = LoggerFactory.getLogger("SampleLogger");

第 2 步 - 记录所需的消息

slf4j.Logger接口的info ()方法接受表示所需消息的字符串值，并将其记录在信息级别。

logger.info("Hi This is my first SLF4J program");

例子

以下程序演示了如何使用 SLF4J 在 Java 中编写示例记录器。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger("SampleLogger");

      //Logging the information
      logger.info("Hi This is my first SLF4J program");
   }
}

输出

最初运行以下程序时，您将得到以下输出，而不是所需的消息。

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

由于我们没有将类路径设置为表示日志记录框架的任何绑定，如本教程前面提到的，SLF4J 默认为无操作实现。因此，要查看该消息，您需要在项目类路径中添加所需的绑定。由于我们使用的是 eclipse，因此请设置相应 JAR 文件的构建路径，或者在 pom.xml 文件中添加其依赖项。

例如，如果我们需要使用JUL（Java.util.logging框架），我们需要为jar文件设置构建路径slf4j-jdk14-xxjar。如果我们想使用 log4J 日志框架，我们需要设置构建路径，或者添加 jar 文件slf4j-log4j12-xxjar和log4j.jar的依赖项。

将表示除slf4j-nopx.x.jar之外的任何日志记录框架的绑定添加到项目（类路径）后，您将获得以下输出。

Dec 06, 2018 5:29:44 PM SLF4JExample main
INFO: Hi Welcome to Tutorialspoint

SLF4J - 错误消息

在本章中，我们将讨论使用 SLF4J 时收到的各种错误消息或警告以及这些消息的原因/含义。

无法加载类“org.slf4j.impl.StaticLoggerBinder”。

这是当类路径中没有提供 SLF4J 绑定时引起的警告。

以下是完整的警告 -

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

要解决此问题，您需要添加任一日志记录框架绑定。本教程的“Hello world”章节对此进行了解释。

注意- 这发生在 1.6.0 和 1.8.0-beta2 之间的 SLF4J 版本中。

未找到 SLF4J 提供程序

在 slf4j-1.8.0-beta2 中，上述警告更加明确，表示“未找到 SLF4J 提供程序”。

以下是完整的警告 -

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.

类路径包含针对 1.8 之前的 slf4j-api 版本的 SLF4J 绑定

如果您使用的是 SLF4J 1.8 版本，并且类路径中有以前版本的绑定，但没有 1.8 的绑定，您将看到如下所示的警告。

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
SLF4J: Class path contains SLF4J bindings targeting slf4j-api versions prior to
1.8.
SLF4J: Ignoring binding found at
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#ignoredBindings for an explanation.

NoClassDefFoundError：org/apache/commons/logging/LogFactory

如果您正在使用slf4j-jcl并且类路径中只有slf4j-jcl.jar，您将收到如下所示的异常。

Exception in thread "main" java.lang.NoClassDefFoundError:
org/apache/commons/logging/LogFactory
   at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:77)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:358)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.ClassNotFoundException:
org.apache.commons.logging.LogFactory
   at java.net.URLClassLoader.findClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   ... 3 more

要解决此问题，您需要将commons-logging.jar添加到类路径中。

在类路径上检测到 jcl-over-slf4j.jar 和绑定的 slf4j-jcl.jar。

绑定slf4j-jcl.jar将 slf4j 记录器的调用重定向到 JCL，而jcl-over-slf4j.jar将 JCL 记录器的调用重定向到 slf4j。因此，您不能将两者都包含在项目的类路径中。如果这样做，您将遇到如下所示的异常。

SLF4J: Detected both jcl-over-slf4j.jar AND bound slf4j-jcl.jar on the class
path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#jclDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:71)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:42)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both jcl-over-slf4j.jar
AND bound slf4j-jcl.jar on the class path, preempting StackOverflowError. See
also http://www.slf4j.org/codes.html#jclDelegationLoop for more details.
   at org.slf4j.impl.JCLLoggerFactory.<clinit>(JCLLoggerFactory.java:54)
   ... 7 more

要解决此问题，请删除任一 jar 文件。

检测到记录器名称不匹配

您可以通过以下方式创建 Logger 对象：

• 将要创建的记录器的名称作为参数传递给getLogger()方法。

• 将类作为参数传递给此方法。

如果您尝试通过传递类作为参数来创建记录器工厂对象，并且已将系统属性slf4j.detectLoggerNameMismatch设置为 true，则您作为参数传递给getLogger()方法的类的名称和您使用的类应该相同，否则您将收到以下警告 -

“检测到记录器名称不匹配。

考虑以下示例。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      System.setProperty("slf4j.detectLoggerNameMismatch", "true");
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Hi Welcome to Tutorilspoint");
   }
}

在这里，我们将slf4j.detectLoggerNameMismatch属性设置为 true。我们使用的类的名称是SLF4JExample，我们传递给 getLogger() 方法的类名称是Sample，因为它们不相等，我们将收到以下警告。

SLF4J: Detected logger name mismatch. Given name: "Sample"; computed name:
"SLF4JExample".
SLF4J: See http://www.slf4j.org/codes.html#loggerNameMismatch for an
explanation
Dec 10, 2018 12:43:00 PM SLF4JExample main
INFO: Hi Welcome to Tutorilspoint

注意- 这发生在 slf4j 1.7.9 之后

类路径包含多个 SLF4J 绑定。

类路径中应该只有一个绑定。如果您有多个绑定，您将收到一条警告，其中列出了绑定及其位置。

假设，如果我们在类路径中有绑定slf4j-jdk14.jar和slf4j-nop.jar，我们将收到以下警告。

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-nop-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an
explanation.
SLF4J: Actual binding is of type [org.slf4j.helpers.NOPLoggerFactory]

在类路径上检测到 log4j-over-slf4j.jar 和绑定的 slf4j-log4j12.jar

要将 log4j 记录器调用重定向到 slf4j，您需要使用log4j-over-slf4j.jar绑定，如果要将 slf4j 调用重定向到 log4j，则需要使用slf4j-log4j12.jar绑定。

因此，类路径中不能同时存在两者。如果这样做，您将得到以下异常。

SLF4J: Detected both log4j-over-slf4j.jar AND bound slf4j-log4j12.jar on the
class path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:72)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:45)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:383)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both log4j-over-slf4j.jar
AND bound slf4j-log4j12.jar on the class path, preempting StackOverflowError.
See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more details.

SLF4J - 参数化日志记录

正如本教程前面所讨论的，SLF4J 提供对参数化日志消息的支持。

您可以在消息中使用参数，并稍后在同一语句中将值传递给它们。

句法

如下所示，您需要在消息（字符串）中的任何需要的地方使用占位符（{}），稍后您可以以对象形式传递占位符的值，用逗号分隔消息和值。

Integer age;
Logger.info("At the age of {} ramu got his first job", age);

例子

以下示例演示了使用 SLF4J 的参数化日志记录（使用单个参数）。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(PlaceHolders.class);
      Integer age = 23;
      
      //Logging the information
      logger.info("At the age of {} ramu got his first job", age);
   }
}

输出

执行后，上述程序生成以下输出 -

Dec 10, 2018 3:25:45 PM PlaceHolders main
INFO: At the age of 23 Ramu got his first job

参数化日志记录的优点

在 Java 中，如果我们需要在语句中打印值，我们将使用连接运算符：

System.out.println("At the age of "+23+" ramu got his first job");

这涉及到将整数值 23 转换为字符串并将该值与其周围的字符串连接起来。

如果它是一个日志记录语句，并且如果您的语句的特定日志级别被禁用，那么所有这些计算将毫无用处。

在这种情况下，您可以使用参数化日志记录。在这种格式中，SLF4J 最初会确认是否启用了特定级别的日志记录。如果是这样，它将用相应的值替换消息中的占位符。

例如，如果我们有这样的语句

Integer age;
Logger.debug("At the age of {} ramu got his first job", age);

仅当启用调试时，SLF4J 才会将年龄转换为整数并将其与字符串连接，否则不执行任何操作。因此，当禁用日志级别时，会产生参数构造的成本。

两个参数变体

您还可以在消息中使用两个参数：

logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);

例子

以下示例演示了参数化日志记录中两个占位符的用法。

import java.util.Scanner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PlaceHolders {
   public static void main(String[] args) {
      Integer oldWeight;
      Integer newWeight;
      Scanner sc = new Scanner(System.in);
      System.out.println("Enter old weight:");
      oldWeight = sc.nextInt();

      System.out.println("Enter new weight:");
      newWeight = sc.nextInt();

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);
 
      //Logging the information
      logger.info("After the program weight reduced is: "+(oldWeight-newWeight));
   }
}

输出

执行后，上述程序会生成以下输出。

Enter old weight:
85
Enter new weight:
74
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: Old weight is 85. new weight is 74.
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: After the program weight reduced is: 11

多参数变体

您还可以使用两个以上的占位符，如下例所示 -

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      Integer age = 24;
      String designation = "Software Engineer";
      String company = "Infosys";

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("At the age of {} ramu got his first job as a {} at {}", age, designation, company);
   }
}

输出

执行后，上述程序生成以下输出 -

Dec 10, 2018 4:23:52 PM PlaceHolders main
INFO: At the age of 24 ramu got his first job as a Software Engineer at Infosys

SLF4J - 迁移器

如果您在 Jakarta Commons Logging (JCL) 或 log4j 或 java.util.logging (JUL) 中有一个项目，并且想要将这些项目转换为 SLF4J，则可以使用 SLF4J 发行版中提供的迁移器工具来执行此操作。

运行 SLF4J 迁移器

SLF4J 是一个简单的单个 jar 文件 (slf4j-migrator.jar)，您可以使用 java –jar 命令运行它。

要运行它，请在命令提示符下浏览包含此 jar 文件的目录并执行以下命令。

java -jar slf4j-migrator-1.8.0-beta2.jar
Starting SLF4J Migrator

这将启动迁移器，您可以看到一个独立的 java 应用程序：

根据窗口中的指定，您需要检查要执行的迁移类型并选择项目目录，然后单击“将项目迁移到 SLF4J”按钮。

该工具会转到您提供的源文件并执行简单的修改，例如将导入行和记录器声明从当前日志记录框架更改为 SLF4j。

例子

例如，假设我们在 Eclipse 中有一个示例log4j(2)项目，其中包含一个文件，如下所示 -

import org.apache.log4j.Logger;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(Sample.class.getName());

   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

要将示例log4j(2)项目迁移到 slf4j，我们需要选中从 log4j 到 slf4j的单选按钮，并选择项目的目录，然后单击退出进行迁移。

迁移者将上述代码更改如下。在这里，如果您观察到 import 和 logger 语句已被修改。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   static Logger log = LoggerFactory.getLogger(Sample.class.getName());
   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

由于您的项目中已经有log4j.jar，因此需要将slf4j-api.jar和slf4jlog12.jar文件添加到项目中才能执行。

SLF4JMigrator 的局限性

以下是 SLF4J 迁移器的限制。

• Migrator 不会修改 ant、maven 和 ivy 等构建脚本，您需要自己修改。

• Migrator 不支持字符串类型以外的消息。

• 迁移器不支持 FATAL 级别。

• 使用 log4j 时，迁移器不会迁移对 PropertyConfigurator 或 DomConfigurator 的调用。

SLF4J - 分析

SLF4J Distribution 提供了slf4j-ext.jar，其中包含用于分析、扩展日志记录、事件日志记录和使用 java 代理进行日志记录等功能的 API。

分析

有时，程序员想要测量一些属性，例如内存的使用、时间复杂度或程序特定指令的使用，以测量该程序的实际功能。这种对程序的测量称为分析。分析使用动态程序分析来进行此类测量。

SLF4J在org.slf4j.profiler包中提供了一个名为Profiler的类用于分析目的。这被称为穷人的分析器。使用它，程序员可以找出执行长时间任务所需的时间。

使用 Profiler 类进行分析

探查器包含秒表和子秒表，我们可以使用探查器类提供的方法启动和停止它们。

要使用探查器类继续进行探查，请按照以下步骤操作。

第 1 步 - 实例化分析器类

通过传递表示探查器名称的字符串值来实例化探查器类。当我们实例化 Profiler 类时，将启动一个全局秒表。

//Creating a profiler
Profiler profiler = new Profiler("Sample");

第 2 步 - 启动儿童秒表

当我们调用start()方法时，它将启动一个新的子秒表（已命名），并停止较早的子秒表（或时间仪器）。

通过传递表示要创建的子秒表名称的字符串值来调用Profiler类的start()方法。

//Starting a child stopwatch and stopping the previous one.
profiler.start("Task 1");
obj.demoMethod1();

创建这些秒表后，您可以执行任务或调用那些运行任务的方法。

第 3 步：启动另一个子秒表（如果您愿意）

如果需要，请使用start()方法创建另一个秒表并执行所需的任务。如果这样做，它将启动一个新的秒表并停止前一个秒表（即任务 1）。

//Starting another child stopwatch and stopping the previous one.
profiler.start("Task 2");
obj.demoMethod2();

第四步：停止手表

当我们调用stop()方法时，它将停止最近的子秒表和全局秒表并返回当前的时间仪器。

// Stopping the current child stopwatch and the global stopwatch.
TimeInstrument tm = profiler.stop();

步骤5：打印时间仪器的内容。

使用print()方法打印当前时间仪器的内容。

//printing the contents of the time instrument
tm.print();

例子

以下示例演示了使用 SLF4J 的 Profiler 类进行分析。这里我们采取了两个示例任务，打印从 1 到 10000 的数字的平方和，打印从 1 到 10000 的数字的和。我们试图获取这两个任务所花费的时间。

import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample obj = new ProfilerExample();

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();
 
      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //printing the contents of the time instrument
      tm.print();
   }
}

输出

执行后，上述程序生成以下输出 -

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000
+ Profiler [BASIC]
|-- elapsed time [Task 1] 2291.827 microseconds.
|-- elapsed time [Task 2] 225.802 microseconds.
|-- Total [BASIC] 3221.598 microseconds.

记录分析器信息

您不需要打印分析器的结果来记录此信息，而是需要 -

• 使用LoggerFactory类创建记录器。

• 通过实例化 Profiler 类来创建探查器。

• 通过将创建的记录器对象传递给Profiler类的setLogger()方法，将记录器与探查器关联起来。

• 最后，使用log()方法打印探查器的信息，而不是打印日志。

例子

在下面的示例中，与前一个示例（而不是打印）不同，我们尝试记录时间仪器的内容。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample_logger {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample_logger obj = new ProfilerExample_logger();

      //Creating a logger
      Logger logger = LoggerFactory.getLogger(ProfilerExample_logger.class);

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Adding logger to the profiler
      profiler.setLogger(logger);

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();

      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //Logging the contents of the time instrument
      tm.log();
   }
}

输出

执行后，上述程序会生成以下输出。

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000