Logger creation in classes in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

📝 Syntax

intermediate

Correct Logger Declaration in a Spring Boot Class

Which option correctly declares a logger in a Spring Boot class using SLF4J?

Spring Boot

public class MyService {
    // Logger declaration here
}

A private Logger logger = LoggerFactory.getLogger();

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

C public static Logger logger = new Logger(MyService.class);

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

💡 Hint

Remember to use LoggerFactory and pass the class type for proper logger creation.

Option B correctly uses LoggerFactory.getLogger with the class type and declares the logger as private static final, which is the recommended pattern in Spring Boot.

❓ component_behavior

intermediate

Logger Output Behavior in Spring Boot

Given a Spring Boot class with a logger declared as in option A of the previous question, what will be the output when calling logger.info("Hello World") if the logging level is set to WARN?

Spring Boot

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

public void greet() {
    logger.info("Hello World");
}

A An error will occur because the logger is not initialized.

B The message will be logged but only in the debug log file.

C The message 'Hello World' will be printed to the console.

D No output will be shown because INFO is lower than WARN level.

💡 Hint

Check the logging level hierarchy: ERROR > WARN > INFO > DEBUG.

Since the logging level is set to WARN, INFO messages are ignored and not printed.

🔧 Debug

advanced

Identify the Logger Initialization Error

What error will occur when running this Spring Boot class code snippet?

Spring Boot

public class UserService {
    private static Logger logger = LoggerFactory.getLogger();

    public void process() {
        logger.info("Processing user");
    }
}

A No error, logs 'Processing user' correctly.

B NullPointerException at runtime because logger is null.

C Compilation error: getLogger() requires a Class or String argument.

D IllegalArgumentException because logger name is empty.

💡 Hint

Check the LoggerFactory.getLogger method signature.

LoggerFactory.getLogger() requires a parameter to specify the logger name or class. Omitting it causes a compilation error.

❓ state_output

advanced

Logger Instance Identity in Multiple Class Instances

If you create two instances of a Spring Boot class with a static logger declared as private static final Logger logger = LoggerFactory.getLogger(MyClass.class);, how many distinct logger instances exist in memory?

Spring Boot

public class MyClass {
    private static final Logger logger = LoggerFactory.getLogger(MyClass.class);

    public void log() {
        logger.info("Logging");
    }
}

MyClass a = new MyClass();
MyClass b = new MyClass();

A One single logger instance shared by both class instances.

B No logger instances until log() is called.

C Two separate logger instances, one per class instance.

D A new logger instance is created each time logger.info is called.

💡 Hint

Static fields belong to the class, not to instances.

Static final logger means one logger instance per class, shared by all instances.

🧠 Conceptual

expert

Best Practice for Logger Declaration in Spring Boot

Which statement best explains why logger fields are declared as private static final in Spring Boot classes?

A To ensure a single shared logger per class, improve performance, and prevent modification.

B To allow each instance to have its own logger with different configurations.

C To enable logger injection by Spring's dependency injection container.

D To make the logger accessible from other classes without creating an instance.

💡 Hint

Think about memory usage and immutability of logger objects.

Declaring logger as private static final ensures one immutable logger per class, improving performance and consistency.

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