Encountering the “Cannot find symbol log” error when building with Lombok’s @Slf4j and IntelliJ is a common frustration for many Java developers. This seemingly perplexing issue often arises when Project Lombok, a powerful library designed to reduce boilerplate code, isn’t fully integrated or recognized by your IntelliJ IDEA environment. While Lombok successfully generates the logger fields at compile time, the IDE’s internal analysis might not properly reflect these changes, leading to red squiggly lines and compilation errors. Understanding the underlying mechanisms of Lombok’s annotation processing and IntelliJ’s build system is crucial to effectively debug and resolve this persistent problem, ensuring a smoother development workflow and accurate code analysis within your IDE.

Understanding Project Lombok and @Slf4j

Project Lombok is a popular Java library that plugs into your build process to automatically generate boilerplate code, such as getters, setters, constructors, and even logging instances. Its primary goal is to make your code cleaner, more concise, and easier to read by reducing verbosity. Instead of writing repetitive methods, you simply add an annotation like @Getter or @Setter, and Lombok handles the rest during compilation.

The @Slf4j annotation is a prime example of Lombok’s utility. When you place @Slf4j on a class, Lombok automatically injects a static, final Logger log field into that class. This field is initialized with an instance of SLF4J’s Logger, allowing you to use log.info(), log.debug(), and other logging methods directly without manually declaring and initializing the logger. This automation saves significant time and ensures consistent logging practices across your codebase, aligning with best practices for application observability.

The magic behind Lombok lies in its use of Java’s annotation processing API. During the compilation phase, Lombok acts as an annotation processor, inspecting your source code for its annotations. When it finds @Slf4j, it modifies the Abstract Syntax Tree (AST) of your Java code in memory, effectively adding the log field before the Java compiler generates the bytecode. This means the log field never exists in your source file but is present in the compiled .class file, ready for runtime execution. This compile-time code generation is powerful but can sometimes create discrepancies with IDEs like IntelliJ IDEA if they aren’t configured to fully understand this process.

The Root Cause: Why “Cannot Find Symbol Log”?

The “Cannot find symbol log” error, when Building with Lombok’s @Slf4j and IntelliJ, typically occurs because IntelliJ IDEA’s internal code analysis and compilation pipeline are not fully aware of the code transformations performed by Lombok. While your build tool (like Maven or Gradle) might successfully compile your project because Lombok processes the annotations during its build phase, IntelliJ’s default settings might not enable its annotation processor for Lombok. This means the IDE itself doesn’t “see” the generated log field, leading to syntax errors in the editor even if the project compiles externally.

The core of the problem lies in the distinction between how your external build system compiles the code and how IntelliJ IDEA analyzes it for real-time error checking and code completion. IntelliJ has its own built-in compiler and code analysis engine. For Lombok to work correctly within the IDE, IntelliJ needs to run Lombok’s annotation processor during its incremental compilation process. If this is not enabled, or if the Lombok plugin for IntelliJ is missing or outdated, the IDE will report that the log symbol cannot be found because it hasn’t been added to the AST during its internal analysis.

The “Cannot find symbol log” error when using Lombok’s @Slf4j in IntelliJ IDEA primarily stems from the IDE’s failure to recognize the log field generated by Lombok’s annotation processor. This happens because IntelliJ’s internal compiler or its Lombok plugin might not be correctly configured to enable annotation processing, leading to a discrepancy between the IDE’s understanding of the code and the actual compiled output produced by your build tool.

Furthermore, classpath issues or conflicts with other plugins can sometimes contribute to this error. If the Lombok dependency is not correctly added to your project’s build file (pom.xml for Maven or build.gradle for Gradle), or if there are multiple versions of Lombok or conflicting logging dependencies present, IntelliJ might struggle to resolve the necessary annotations and generate the log field. Ensuring your project’s dependencies are clean and correctly declared is a vital step in preventing such symbol resolution failures.

Resolving the “Cannot find symbol log” error in IntelliJ IDEA when working with Lombok’s @Slf4j often involves a few key configuration adjustments. Following these steps systematically will help ensure your IDE correctly recognizes the generated logger field and eliminates the persistent error messages in your editor.

1. Enable Annotation Processing in IntelliJ IDEA:

   This is the most common fix. IntelliJ needs explicit permission to run Lombok’s annotation processor. Navigate to File > Settings (or IntelliJ IDEA > Preferences on macOS). In the dialog, search for “Annotation Processors” under Build, Execution, Deployment > Compiler. Check the box for “Enable annotation processing”. Click “Apply” and then “OK”. This tells IntelliJ to execute Lombok during its compilation cycle, ensuring the log field is generated for the IDE’s awareness.

2. Add Lombok as a Dependency:

   Ensure that Project Lombok is correctly added as a dependency in your project’s build file. For Maven, this typically goes into your pom.xml. For Gradle, it’s in your build.gradle. It’s crucial to include it with the provided scope for Maven or compileOnly for Gradle, as Lombok is only needed during compilation and not at runtime. Don’t forget to re-import your Maven/Gradle project after adding the dependency.

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

   // Gradle build.gradle example dependencies { compileOnly 'org.projectlombok:lombok:1.18.28' // Use the latest stable version annotationProcessor 'org.projectlombok:lombok:1.18.28' } 
   

   The annotationProcessor configuration for Gradle is particularly important as it explicitly tells Gradle to use Lombok as an annotation processor.

3. Install/Update Lombok Plugin for IntelliJ:

   While enabling annotation processing is key, having the official Lombok plugin for IntelliJ IDEA can enhance IDE support, providing better code completion, navigation, and refactoring for Lombok-generated code. Go to File > Settings > Plugins, search for “Lombok Plugin”, and install or update it. After installation, you might be prompted to restart your IDE.

4. Invalidate Caches and Restart IntelliJ:

   Sometimes, IntelliJ’s internal caches can get out of sync. To clear them, go to File > Invalidate Caches / Restart.... Select “Invalidate and Restart”. This will clear IntelliJ’s internal caches and re-index your project, which often resolves lingering symbol resolution issues after configuration changes. This is a common troubleshooting step Question & Answer :

   I have a maven project that builds with no problems from the command line. However, when I build it with IntelliJ, I get the error:

   java: FileName.java:89: cannot find symbol symbol : variable log 
   

   There is no log defined or imported in the java file, but there is a

   @Slf4j final public class FileName { 
   

   statement before the class body which should define the log class.

   In the project structure window, classes for:

   Maven: org.slf4j:jcl-over-slf4j:1.6.1 Maven: org.slf4j:slf4j-api:1.6.6 Maven: org.slf4j:slf4j-log4j12:1.6.6 Maven: org.slf4j:slf4j-simple:1.6.6 
   

   are listed under libraries and are indicated as having been downloaded and available.

   Any idea why this would build with maven through the command line, but not through IntelliJ and how to resolve the issue?

   In addition to having Lombok plugin installed, also make sure that the “Enable annotation processing” checkbox is ticked under:

   Preferences > Compiler > Annotation Processors 
   

   Note: starting with IntelliJ 2017, the “Enable Annotation Processing” checkbox has moved to:

   Settings > Build, Execution, Deployment > Compiler > Annotation Processors