SLF4J and Logback basics in Spring Boot - Step-by-Step Execution

Concept Flow - SLF4J and Logback basics

Start Application

↓

Create Logger Instance

↓

Call Logger Method (e.g., info)

↓

SLF4J Formats Message

↓

Logback Receives Log Event

↓

Logback Applies Configuration

↓

Log Message Written to Output (Console/File)

↓

End

This flow shows how a Spring Boot app uses SLF4J to send log messages that Logback formats and writes to console or files.

Execution Sample

Spring Boot

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

Logger logger = LoggerFactory.getLogger(MyClass.class);
int userCount = 5;
logger.info("App started with {} users", userCount);

This code creates a logger and logs an info message with a dynamic user count.

Execution Table

Step	Action	Input/Method	Output/Result
1	Create Logger	LoggerFactory.getLogger(MyClass.class)	Logger instance for MyClass created
2	Call Logger Method	logger.info("App started with {} users", userCount=5)	SLF4J formats message: "App started with 5 users"
3	Send to Logback	Formatted message	Logback receives log event
4	Apply Config	Logback config (e.g., console appender, pattern)	Message formatted with timestamp and level
5	Write Output	Formatted log message	Message printed to console or written to file
6	End	No further logs	Logging cycle complete

💡 No more log calls, application continues running

Variable Tracker

Variable	Start	After Step 2	After Step 5
logger	null	Logger instance created	Logger instance reused for logging
userCount	5	5	5
formattedMessage	null	"App started with 5 users"	"App started with 5 users"

Key Moments - 3 Insights

Why do we use LoggerFactory.getLogger instead of creating Logger directly?

LoggerFactory.getLogger creates a logger tied to the class name, ensuring consistent naming and integration with SLF4J and Logback, as shown in step 1 of the execution_table.

How does SLF4J handle the message with placeholders like {}?

SLF4J replaces {} with provided arguments before sending the formatted message to Logback, as seen in step 2 where the message becomes "App started with 5 users".

What decides where the log message goes (console or file)?

Logback configuration controls output destinations and formats, applied in step 4, so changing config changes where logs appear.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after step 2?

A Message printed to console

B Logger instance created

C "App started with 5 users" formatted message

D Logback config applied

💡 Hint

Check the 'Output/Result' column for step 2 in the execution_table

At which step does Logback apply its configuration to the log message?

A Step 4

B Step 3

C Step 1

D Step 5

💡 Hint

Look for 'Apply Config' action in the execution_table

If userCount changes to 10, how does the formattedMessage change at step 2?

A "App started with 5 users"

B "App started with 10 users"

C "App started with {} users"

D No change, message stays the same

💡 Hint

Refer to variable_tracker for formattedMessage changes after step 2

Concept Snapshot

SLF4J is a logging interface used in Spring Boot.
Use LoggerFactory.getLogger(Class) to create a logger.
Call logger methods like info(), debug() with messages.
Use {} placeholders for dynamic values.
Logback is the default logger implementation.
It formats and writes logs based on config (console/file).

Full Transcript

In Spring Boot, SLF4J provides a simple way to log messages. You create a logger using LoggerFactory.getLogger with your class. When you call logger.info or other methods with a message and placeholders, SLF4J formats the message by replacing placeholders with actual values. Then, Logback receives this formatted message. Logback applies its configuration, which decides how the message looks and where it goes, like console or file. Finally, the message is output. This process repeats for each log call. Understanding this flow helps you control logging in your app.