Logging: SLF4J, Logback & Log4j

Shared core#

The chapter below remains the canonical explanation for both goals. Keep its model, examples, and trade-offs shared; only the deliberate practice changes with the route.

Learn deeply: build evidence#

Use this chapter’s TaskFlow work to make one small, observable change. Run the stated acceptance checks before recording practice.

Prepare for interviews: explain the trade-off#

Without notes, explain the boundary this chapter protects, one concrete implementation decision, and the cost of a tempting shortcut. Then answer one follow-up using the chapter’s own example.

Section 1Facade vs engine — the same split you already met#

Logging has the exact two-part shape as persistence (spec vs implementation). Learn it once, recognise it everywhere.

Section 2Get a logger and use it#

Two ways to obtain a logger. The manual way shows what's happening; the Lombok way is what you'll actually write.

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

public class TaskService {
  private static final Logger log = LoggerFactory.getLogger(TaskService.class);
  // ...
}

import lombok.extern.slf4j.Slf4j;

@Slf4j              // generates the `log` field for you
public class TaskService {
  // `log` just exists now
}

Now narrate the service's work. Add lines to TaskService from Chapter 3/4:

@Slf4j
@Service
public class TaskService {

    private final TaskRepository repository;
    public TaskService(TaskRepository repository) { this.repository = repository; }

    public Task create(String title) {
        log.info("Creating task with title '{}'", title);   // parameterized — see below
        Task saved = repository.save(new Task(title, false));
        log.debug("Saved task id={}", saved.getId());        // detail, off by default
        return saved;
    }

    public Task getById(Long id) {
        return repository.findById(id).orElseThrow(() -> {
            log.warn("Task not found: id={}", id);        // a notable, non-fatal event
            return new TaskNotFoundException(id);
        });
    }
}

Section 3The levels, and when to use each#

A level is the severity/importance of a line. You set a threshold; anything at or above it prints, anything below is silent. From most to least severe:

Section 4Control it all from application.properties#

No code changes — logging is configured, like the database was. Add these and restart:

# turn your own package up to DEBUG, keep the noisy framework at INFO/WARN
logging.level.root=INFO
logging.level.com.example.taskflow=DEBUG
logging.level.org.springframework.web=INFO
logging.level.org.hibernate.SQL=DEBUG        # log the SQL (like show-sql, via logging)

# also write logs to a file, not just the console
logging.file.name=logs/taskflow.log

# customise the console line format (optional)
logging.pattern.console=%d{HH:mm:ss} %-5level %logger{20} - %msg%n

Create a task and watch the levels sort themselves:

Section 5Swapping in Log4j2#

Many teams standardise on Log4j2 (for its performance and config style). Because your code uses the SLF4J facade, the switch is two build changes + one config file — no Java touched.

1. Exclude the default Logback engine

   Spring's starters pull spring-boot-starter-logging (Logback). Exclude it so two engines don't clash.

   pom.xml — on the web starter

   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <exclusions>
       <exclusion>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-logging</artifactId>
       </exclusion>
     </exclusions>
   </dependency>

   Copy
2. Add the Log4j2 starter
   pom.xml

   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-log4j2</artifactId>
   </dependency>

   Copy
3. Add a log4j2.xml

   Put it in src/main/resources. This is Log4j2's own config format (replacing the logging.* properties for advanced control).

   src/main/resources/log4j2.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <Configuration status="WARN">
     <Appenders>
       <Console name="Console" target="SYSTEM_OUT">
   <PatternLayout pattern="%d{HH:mm:ss} %-5level %logger{20} - %msg%n"/>
       </Console>
       <File name="File" fileName="logs/taskflow.log">
   <PatternLayout pattern="%d %-5level %logger - %msg%n"/>
       </File>
     </Appenders>
     <Loggers>
       <!-- your package: verbose -->
       <Logger name="com.example.taskflow" level="debug"/>
       <!-- everything else: info -->
       <Root level="info">
   <AppenderRef ref="Console"/>
   <AppenderRef ref="File"/>
       </Root>
     </Loggers>
   </Configuration>

   Copy

Section 6Exercises#

public void delete(Long id) {
    getById(id);                         // logs WARN + throws 404 if missing
    repository.deleteById(id);
    log.info("Deleted task id={}", id);
}