Logger creation in classes in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of creating a logger in a Spring Boot class?

A logger helps record important events, errors, or information during the program's execution. It is like keeping a diary of what the program does, which helps developers understand and fix issues.

beginner

How do you create a logger instance in a Spring Boot class using SLF4J?

You create a logger by adding this line inside your class:
private static final Logger logger = LoggerFactory.getLogger(YourClassName.class);
This sets up a logger specific to that class.

intermediate

Why do we use LoggerFactory.getLogger(YourClassName.class) instead of just creating a new Logger directly?

LoggerFactory manages logger instances efficiently and ensures each class has its own logger. This avoids creating many unnecessary logger objects and helps organize logs by class.

beginner

What are common log levels you can use with a logger in Spring Boot?

Common log levels include:
- TRACE: Very detailed info
- DEBUG: Useful for debugging
- INFO: General information
- WARN: Something unexpected but not an error
- ERROR: Serious problems that need attention

beginner

How does using a logger improve your Spring Boot application compared to using System.out.println()?

Loggers let you control what messages show up by level, write logs to files, and format messages nicely. System.out.println() just prints to the console and can't be turned off or filtered easily.

Which line correctly creates a logger in a Spring Boot class named MyService?

A Logger logger = new Logger();

B private static final Logger logger = LoggerFactory.getLogger(MyService.class);

C Logger logger = LoggerFactory.createLogger();

D private Logger logger = new Logger(MyService.class);

Option B uses LoggerFactory.getLogger with the class name, which is the correct way to create a logger.

What log level should you use to record serious errors that need immediate attention?

A ERROR

B DEBUG

C TRACE

D INFO

ERROR level is used for serious problems that require attention.

Why is using a logger better than System.out.println() in Spring Boot?

A Logger prints only errors.

B System.out.println() is faster.

C Logger can filter messages by level and write to files.

D System.out.println() can be turned off easily.

Loggers provide filtering, formatting, and output options that System.out.println() does not.

What does the LoggerFactory class do?

A Creates and manages logger instances for classes.

B Prints logs to the console.

C Stores logs in a database.

D Formats log messages automatically.

LoggerFactory creates and manages logger instances, ensuring efficient use.

Which log level is the most detailed and usually used for very fine-grained messages?

A ERROR

B WARN

C INFO

D TRACE

TRACE is the most detailed log level for very fine-grained messages.

Explain how to create and use a logger in a Spring Boot class. Include why it is useful.

Think about how you keep notes about what your program does.

List common log levels in Spring Boot and describe when to use each.

Imagine different urgency levels for messages.

Practice

1. What is the main purpose of creating a logger in a Spring Boot class?

easy

A. To record messages about the program's behavior for debugging and monitoring

B. To store user data permanently

C. To speed up the program execution

D. To create user interface elements automatically

Solution

1. Step 1: Understand the role of a logger

   A logger records messages about what happens inside the program, helping developers see the flow and errors.

2. Step 2: Identify the correct purpose

   Logging is not for storing data, speeding up code, or UI creation, but for tracking program behavior.

3. Final Answer:

   To record messages about the program's behavior for debugging and monitoring -> Option A

4. Quick Check:

   Logger purpose = record messages [OK]

Hint: Loggers track program events and errors clearly [OK]

Common Mistakes:

• Thinking loggers store data permanently
• Confusing loggers with UI components
• Assuming loggers improve speed

2. Which of the following is the correct way to create a logger in a Spring Boot class named MyService?

easy

A. private Logger logger = LoggerFactory.createLogger(MyService);

B. Logger logger = new Logger(MyService);

C. private static final Logger logger = LoggerFactory.getLogger(MyService.class);

D. static Logger logger = LoggerFactory.getLogger("MyService");

Solution

1. Step 1: Recall the standard logger creation syntax

   In Spring Boot, the logger is created using LoggerFactory.getLogger(ClassName.class) and declared static final.

2. Step 2: Match the correct syntax

   private static final Logger logger = LoggerFactory.getLogger(MyService.class); matches the correct pattern: private static final Logger logger = LoggerFactory.getLogger(MyService.class); others use wrong methods or missing keywords.

3. Final Answer:

   private static final Logger logger = LoggerFactory.getLogger(MyService.class); -> Option C

4. Quick Check:

   Logger creation = LoggerFactory.getLogger(ClassName.class) [OK]

Hint: Use LoggerFactory.getLogger(ClassName.class) with static final [OK]

Common Mistakes:

• Using new Logger() instead of LoggerFactory
• Missing static or final keywords
• Passing string instead of ClassName.class

3. Given the following code snippet in a Spring Boot class:

private static final Logger logger = LoggerFactory.getLogger(App.class);

public void run() {
    logger.info("Start running");
    logger.debug("Debugging info");
    logger.error("An error occurred");
}

What will be the visible output if the logging level is set to INFO?

medium

A. All three messages will be logged

B. No messages will be logged

C. Only "Debugging info" will be logged

D. Only "Start running" and "An error occurred" messages will be logged

Solution

1. Step 1: Understand logging levels and filtering

   Logging levels filter messages: INFO level shows INFO, WARN, ERROR but hides DEBUG messages.

2. Step 2: Apply level filter to messages

   "Start running" is INFO, "Debugging info" is DEBUG (hidden), "An error occurred" is ERROR (shown).

3. Final Answer:

   Only "Start running" and "An error occurred" messages will be logged -> Option D

4. Quick Check:

   INFO level hides DEBUG but shows INFO and ERROR [OK]

Hint: INFO level shows INFO and above, hides DEBUG [OK]

Common Mistakes:

• Assuming DEBUG messages show at INFO level
• Thinking ERROR messages are hidden
• Confusing log levels order

4. Identify the error in the following logger declaration inside a Spring Boot class named OrderService:

private Logger logger = LoggerFactory.getLogger(OrderService);

medium

A. Logger must be declared inside a method, not as a field

B. Missing .class after OrderService in getLogger method

C. LoggerFactory does not have getLogger method

D. Logger should not be private

Solution

1. Step 1: Check the getLogger argument type

   The getLogger method requires a Class object, so it should be OrderService.class, not OrderService.

2. Step 2: Verify other parts of declaration

   Logger can be private and declared as a field; LoggerFactory has getLogger method; no need to declare inside method.

3. Final Answer:

   Missing .class after OrderService in getLogger method -> Option B

4. Quick Check:

   Use ClassName.class in getLogger [OK]

Hint: Always add .class after class name in getLogger() [OK]

Common Mistakes:

• Omitting .class after class name
• Thinking logger cannot be private
• Assuming getLogger method doesn't exist

5. You want to create a logger in a Spring Boot class UserController that logs a warning message only when a user ID is missing. Which of the following code snippets correctly creates the logger and logs the warning message?

hard

A. private static final Logger logger = LoggerFactory.getLogger(UserController.class);

public void checkUser(String userId) {
if (userId == null || userId.isEmpty()) {
logger.warn("User ID is missing");
}
}

B. Logger logger = LoggerFactory.getLogger(UserController);

public void checkUser(String userId) {
if (userId == null) {
logger.error("User ID is missing");
}
}

C. private Logger logger = LoggerFactory.getLogger(UserController.class);

public void checkUser(String userId) {
if (userId.isEmpty()) {
logger.info("User ID is missing");
}
}

D. static final Logger logger = LoggerFactory.getLogger("UserController");

public void checkUser(String userId) {
if (userId == null) {
logger.debug("User ID is missing");
}
}

Solution

1. Step 1: Verify correct logger creation

   private static final Logger logger = LoggerFactory.getLogger(UserController.class); public void checkUser(String userId) { if (userId == null || userId.isEmpty()) { logger.warn("User ID is missing"); } } uses private static final Logger with LoggerFactory.getLogger(UserController.class), which is the standard pattern.

2. Step 2: Check logging condition and level

   private static final Logger logger = LoggerFactory.getLogger(UserController.class); public void checkUser(String userId) { if (userId == null || userId.isEmpty()) { logger.warn("User ID is missing"); } } checks if userId is null or empty and logs a warning with logger.warn(), which matches the requirement.

3. Final Answer:

   private static final Logger logger = LoggerFactory.getLogger(UserController.class); public void checkUser(String userId) { if (userId == null || userId.isEmpty()) { logger.warn("User ID is missing"); } } -> Option A

4. Quick Check:

   Use static final logger and logger.warn() for warnings [OK]

Hint: Use logger.warn() for warnings and check null or empty [OK]

Common Mistakes:

• Not using static final for logger
• Logging wrong level (info, debug, error) for warnings
• Not checking both null and empty strings