在Java 9模块中使用SLF的测试项目技术问询

Hey there! Let me walk through your Java 9 module-based SLF4J test project setup and share some crucial tips and insights for working with SLF4J in this context:

First, here's your project structure formatted clearly:

.
├── build.gradle
└── src
    ├── main
    │   └── java
    │       ├── module-info.java
    │       └── slfTest
    │           └── Main.java
    └── test
        └── java
            └── slfTest
                └── MainTest.java

Your Main and MainTest classes use standard SLF4J logging code:

Logger logger = LoggerFactory.getLogger(Main.class);
logger.info("Hello World");

Great to hear gradle run is working as expected! Below are key SLF4J-related points tailored to your Java 9 module setup:

• Module Declaration: Make sure your module-info.java explicitly declares a dependency on SLF4J, since Java 9 modules require explicit requires statements. It should look something like this:

  module slfTest {
      requires org.slf4j;
      // If using a binding like Logback, you might also need:
      // requires ch.qos.logback.classic;
  }
  

  Without this, the module system won't allow your code to access SLF4J's API.

• SLF4J is a Facade (Not a Full Logging Implementation): Remember that SLF4J itself only provides a logging interface—you need a concrete binding (like Logback, Log4j 2, or SimpleLogger) to actually see log output. In your Gradle build, you'll need to include both the SLF4J API and your chosen binding as dependencies. For example:

  dependencies {
      implementation 'org.slf4j:slf4j-api:2.0.7'
      // Add your preferred binding; Logback is a common choice
      implementation 'ch.qos.logback:logback-classic:1.2.11'
      
      // Test dependencies
      testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.2'
      testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
  }
  

• Testing Logging: For your MainTest.java, the same rules apply—ensure your test classpath includes the SLF4J API and binding. Gradle's testImplementation and testRuntimeOnly configurations handle this automatically if you've set up the dependencies correctly. If you run into silent logs in tests, double-check that the binding is included in the test classpath.

• Logger Initialization Best Practices: Your current approach LoggerFactory.getLogger(Main.class) is the standard and recommended way to initialize loggers in SLF4J. In a module environment, this works seamlessly as long as the SLF4J module is accessible via your module declaration.

• Avoiding Binding Conflicts: If you ever add multiple logging dependencies, you might hit binding conflicts (SLF4J will warn you about this in the console). To fix this, use Gradle's exclude rule to remove unwanted bindings. For example, if a dependency pulls in an old SLF4J binding you don't want:

  implementation('some-dependency') {
      exclude group: 'org.slf4j', module: 'slf4j-simple'
  }
  

If you have specific questions (like troubleshooting log output issues, optimizing your module setup, or choosing the right logging binding), feel free to dive deeper into those details!

内容的提问来源于stack exchange，提问作者michas