1. Lombook插件沒安裝（幾率很?。?/h2>

這個一般是對于低版本Idea可能會出現(xiàn)，可能是idea沒有安裝lombook插件導致的，去plugin里面安裝下Lombok插件就可以了，但是幾率很小.

高版本idea可以直接排除。

2. SpringBoot的項目依賴沖突

排除 原因一 后可能是由于日志實現(xiàn)在springboot的starter中已經(jīng)有了，但是又導入了logback-classic，排除沖突問題。

3. 普通項目

非SpringBoot項目中，用到Lombook，但是只導入了Lombook的依賴，只是導入了日志的門面。

3.1 分析原因

下圖為無info等方法截圖：

<dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.28</version>
    </dependency>
</dependencies>

可以看到，我只導入了lombok的依賴。所以沒有info等方法，所以我們還需要導入日志的實現(xiàn)。也就是logback-classic。(版本號根據(jù)實際而定)

3.2 導入所需依賴

  <dependencies>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.28</version>
    </dependency>

    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.3</version>
    </dependency>
</dependencies>

下圖為導入日志實現(xiàn)的依賴的截圖：

3.3 測試效果

我們新建一個測試類，在類上導入@Slf4j注解，打印日志 “Hello World!”，下面是示例代碼：

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class TestMain {
    public static void main(String[] args) {
        log.info("Hello World!");
    }
}

執(zhí)行上述代碼，你將得到如下輸出：

16:17:32.896 [main] INFO cn.cstor.Main - Hello World!

4. @Slf4j注解介紹

@Slf4j 是 Lombok（一種Java庫）提供的一個注解，它簡化了在 Java 類中添加日志記錄的過程。@Slf4j 注解會自動生成一個名為 log 的 Logger 對象，使得在類中使用日志功能更加便捷。

具體來說，@Slf4j 注解在類上使用時，Lombok會在編譯時自動為該類生成以下代碼：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Slf4j
public class MyClass {
    // 自動生成的 Logger 對象
    private static final Logger log = LoggerFactory.getLogger(MyClass.class);

    // 類的其他代碼...
}

使用 @Slf4j 注解后，你可以直接在類中使用 log 對象進行日志記錄，而無需手動創(chuàng)建 Logger 對象。

例如：

@Slf4j
public class MyClass {
    public void myMethod() {
        log.info("This is an info message");
        log.error("This is an error message");
    }
}

上述代碼中，@Slf4j 注解自動創(chuàng)建了名為 log 的靜態(tài) Logger 對象，你可以使用它調(diào)用日志級別的方法，如 info、error 等。

這樣的自動生成減少了樣板代碼，使得日志的添加和管理更加簡單。

5. SLF4J介紹

Simple Logging Facade for Java (SLF4J) 用作各種日志框架（例如 java.util.logging、log4j 1.x、reload4j 和 logback）的簡單外觀或抽象。SLF4J 允許最終用戶在部署時插入所需的日志記錄框架 。請注意，啟用 SLF4J 的庫/應用程序意味著僅添加一個強制依賴項，即 slf4j-api-2.0.9.jar。

5.1 Maven導入

考慮到 Maven 的傳遞依賴規(guī)則，對于“常規(guī)”項目（不是庫或框架），可以通過單個依賴項聲明來完成聲明日志記錄依賴項。

5.1.1 SLF4J API

SLF4J API 包含在“org.slf4j:slf4j-api”工件中。您可以在pom.xml文件中顯式聲明對其的依賴關系，如下所示。請注意，大多數(shù)日志記錄實現(xiàn)都會自動引入 slf4j-api 作為依賴項。然而，聲明對 slf4j-api 的顯式依賴關系通常是一個好主意，以便借助 Maven 的“最近定義”依賴關系中介規(guī)則修復項目中 slf4j-api 的正確版本。

<dependency> 
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>2.0.9</version>
</dependency>

5.1.2 LOGBACK-CLASSIC 1.3.X (JAVAX EE)

如果您希望使用Javax EE的 logback-classic作為底層日志記錄框架，您需要做的就是將“ch.qos.logback:logback-classic”聲明為依賴項你的 pom.xml文件如下所示。除了 logback-classic-1.3.6.jar之外，這還會將slf4j-api-2.0.9.jar以及l(fā)ogback-core-1.3.6.jar引入您的項目中。

請注意，顯式聲明對logback-core-1.3.6或 slf4j-api-2.0.9.jar的依賴關系 并沒有錯，并且可能需要借助 Maven 的“最近定義”依賴關系中介規(guī)則來強制使用所述工件的正確版本。

<dependency> 
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.3.6</version>
</dependency>

5.1.3 LOGBACK-CLASSIC 1.4.X (JAKARTA EE)

如果您希望使用Jakarta EE的 logback-classic作為底層日志框架，您需要做的就是將“ch.qos.logback:logback-classic”聲明為依賴項你的 pom.xml文件如下所示。除了 logback-classic-1.4.6.jar之外，這還會將slf4j-api-2.0.9.jar以及l(fā)ogback-core-1.4.6.jar 引入您的項目中。

請注意，顯式聲明對logback-core-1.4.6 或slf4j-api-2.0.9.jar的依賴關系并沒有錯，并且可能需要借助 Maven 的“最近定義”依賴關系中介規(guī)則來強制使用所述工件的正確版本。

<dependency> 
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.4.6</version>
</dependency>

5.1.4 RELOAD4J

如果您希望使用 reload4j 作為底層日志框架，您所需要做的就是在 pom.xml 文件中聲明“org.slf4j:slf4j-reload4j”作為依賴項， 如下所示。除了 slf4j-reload4j-2.0.9.jar之外，這還會將slf4j-api-2.0.9.jar以及reload4j-1.2.25.jar引入您的項目中。

請注意，顯式聲明對reload4j-1.2.25.jar或 slf4j-api-2.0.9.jar 的依賴關系 并沒有錯，并且可能需要借助 Maven 的“最近定義”依賴關系中介規(guī)則來強制使用所述工件的正確版本。

<dependency> 
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-reload4j</artifactId>
  <version>2.0.9</version>
</dependency>

5.1.5 LOG4J 1.2.X

從 SLF4J 版本 1.7.36 開始，聲明依賴于 Maven 指令的 org.slf4j:slf4j-log4j12重定向 org.slf4j:slf4j-reload4j。

<dependency> 
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>2.0.9</version>
</dependency>

5.1.6 JAVA.UTIL.LOGGING

如果您希望使用 java.util.logging 作為底層日志框架，您需要做的就是在 pom.xml 文件中聲明“org.slf4j:slf4j-jdk14”作為依賴項，如下 所示。除了 slf4j-jdk14-2.0.9.jar之外，這還會將slf4j-api-2.0.9.jar引入您的項目中。

請注意，顯式聲明對slf4j-api-2.0.9.jar的依賴關系 并沒有錯，并且可能需要借助 Maven 的“最近定義”依賴關系中介規(guī)則來強制使用所述工件的正確版本。

<dependency> 
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jdk14</artifactId>
  <version>2.0.9</version>
</dependency>

5.1.7 SLF4J SIMPLE

如果您希望使用 org.slf4j.simple 作為底層日志記錄實現(xiàn)，您所需要做的就是在 pom.xml 文件中聲明“org.slf4j:slf4j-simple”作為依賴項，如下所示 。除了 slf4j-simple-2.0.9.jar之外，這還會將slf4j-api-2.0.9.jar引入您的項目中。

請注意，顯式聲明對slf4j-api-2.0.9.jar的依賴關系 并沒有錯，并且可能需要借助 Maven 的“最近定義”依賴關系中介規(guī)則來強制使用所述工件的正確版本。

<dependency> 
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-simple</artifactId>
  <version>2.0.9</version>
</dependency>

5.2 HelloWorld

按照編程傳統(tǒng)的慣例，下面的示例說明了使用 SLF4J 輸出“Hello world”的最簡單方法。

首先獲取名為“HelloWorld”的記錄器。該記錄器又用于記錄消息“Hello World”。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {

  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

要運行此示例，您首先需要獲取 slf4j工件。完成后，將文件 slf4j-api-2.0.9.jar添加到類路徑中。

編譯并運行HelloWorld將在控制臺上打印以下輸出：

SLF4J：未找到 SLF4J 提供程序。
SLF4J：默認為無操作 (NOP) 記錄器實現(xiàn)
SLF4J：請參閱 https://www.slf4j.org/codes.html#noProviders 了解更多詳細信息。

如果您使用的是 SLF4J 1.7 或更早版本，則消息將為：

SLF4J：無法加載類“org.slf4j.impl.StaticLoggerBinder”。
SLF4J：默認為無操作 (NOP) 記錄器實現(xiàn)
SLF4J：請參閱 https://www.slf4j.org/codes.html#StaticLoggerBinder 了解更多詳細信息。

打印此警告是因為在類路徑上找不到 slf4j 提供程序（或綁定）。

一旦您將提供程序添加到類路徑中，該警告就會消失。假設您添加 slf4j-simple-2.0.9.jar以便您的類路徑包含：

• slf4j-api-2.0.9.jar
• slf4j-simple-2.0.9.jar

編譯并運行HelloWorld現(xiàn)在將在控制臺上產(chǎn)生以下輸出：

0 [主要] INFO HelloWorld - 你好世界

5.3 典型使用模式

下面的示例代碼說明了 SLF4J 的典型使用模式。請注意第 15 行中 {} 占位符的使用。

 1: import org.slf4j.Logger;
 2: import org.slf4j.LoggerFactory;
 3: 
 4: public class Wombat {
 5:  
 6:   final Logger logger = LoggerFactory.getLogger(Wombat.class);
 7:   Integer t;
 8:   Integer oldT;
 9:
10:   public void setTemperature(Integer temperature) {
11:    
12:     oldT = t;        
13:     t = temperature;
14:
15:     logger.debug("Temperature set to {}. Old value was {}.", t, oldT);
16:
17:     if(temperature.intValue() > 50) {
18:       logger.info("Temperature has risen above 50 degrees.");
19:     }
20:   }
21: } 

5.4 流暢的日志記錄 API

• SINCE 2.0.0 SLF4J API version 2.0.0 requires Java 8 and introduces a backward-compatible fluent logging API. By backward-compatible, we mean that existing logging frameworks do not have to be changed in order for the user to benefit from the fluent logging API.
• The idea is to build a logging event piece by piece with a LoggingEventBuilder and to log once the event is fully built. The atTrace(), atDebug(), atInfo(), atWarn() and atError() methods, all new in the org.slf4j.Logger interface, return an instance of LoggingEventBuilder. For disabled log levels, the returned LoggingEventBuilder instance does nothing, thus preserving the nanosecond level performance of the traditional logging interface.
• When using the fluent API, you must terminate the invocation chain by calling one of the log() method variants. Forgetting to call any of the log() method variants will result in no logging regardless of the logging level. Fortunately, if this happens, some IDEs will alert you with a compiler warning.

以下是一些使用示例：

• The statement

logger.atInfo().log("Hello world.");

• is equivalent to:

logger.info("Hello world.");

以下日志語句在其輸出中是等效的（對于默認實現(xiàn)）：

int newT = 15;
int oldT = 16;

// using traditional API
logger.debug("Temperature set to {}. Old value was {}.", newT, oldT);

// using fluent API, log message with arguments
logger.atDebug().log("Temperature set to {}. Old value was {}.", newT, oldT);
   
// using fluent API, add arguments one by one and then log message
logger.atDebug().setMessage("Temperature set to {}. Old value was {}.").addArgument(newT).addArgument(oldT).log();

// using fluent API, add one argument with a Supplier and then log message with one more argument.
// Assume the method t16() returns 16.
logger.atDebug().setMessage("Temperature set to {}. Old value was {}.").addArgument(() -> t16()).addArgument(oldT).log();

流暢的日志記錄 API 允許指定許多不同類型的數(shù)據(jù)，而org.slf4j.Logger 不會導致接口中方法數(shù)量的組合爆炸Logger。

現(xiàn)在可以傳遞多個Markers 、傳遞供應商參數(shù) 或傳遞多個鍵值對。鍵值對與可以自動解釋它們的日志數(shù)據(jù)分析器結(jié)合使用特別有用。

以下日志語句是等效的：

int newT = 15;
int oldT = 16;

// using classical API
logger.debug("oldT={} newT={} Temperature changed.", oldT, newT);

// using fluent API 
logger.atDebug().setMessage("Temperature changed.").addKeyValue("oldT", oldT).addKeyValue("newT", newT).log();

API 的鍵值對變體將鍵值對存儲為單獨的對象。org.slf4j.Logger當前類 中的默認實現(xiàn)將鍵值對作為消息的前綴。日志后端是免費的，甚至鼓勵提供更可定制的行為。

5.5 二進制兼容性

SLF4J 提供程序/綁定指定一個工件，例如 slf4j-jdk14.jar或slf4j-reload4j.jar ，用于將 slf4j綁定到底層日志記錄框架，例如 java.util.logging 和 reload4j。

混合不同版本的slf4j-api.jar和 SLF4J 提供程序/綁定可能會導致問題。

例如，如果您使用 slf4j-api-2.0.9.jar，那么您還應該使用 slf4j-simple-2.0.9.jar，使用 slf4j-simple-1.5.5.jar 將不起作用。

然而，從客戶端的角度來看，SLF4J API（更具體地說是包中的類）org.slf4j向后兼容所有版本。

對于任何 N 和 M ，使用 slf4j-api-N.jar編譯的客戶端代碼都可以與slf4j-api-M.jar完美運行。

您只需確保提供程序/綁定的版本與 slf4j-api 的版本匹配。罐。您不必擔心項目中給定依賴項使用的 slf4j-api.jar 版本。

您始終可以使用任何版本的slf4j-api.jar，只要slf4j-api.jar的版本及其提供者/綁定匹配，就應該沒問題。

5.6 Executive summary

總結(jié)

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。