MODULE 10 - Exception Handling and Logging

Welcome to Module 10! 📋

Your application encounters an error... what does the user see? An unreadable Java stack trace? This module teaches you how to handle errors properly and trace what happens in your application.

---

🎓 Learning Objectives

By the end of this module, you will be able to:

1. ✅ Create custom exceptions
2. ✅ Use @ControllerAdvice for global handling
3. ✅ Return structured error responses
4. ✅ Log effectively with SLF4J
5. ✅ Configure Logback for different environments

---

📚 Prerequisites

Before starting this module, you should have:

• ✅ Completed Modules 1 to 9
• ✅ Created REST controllers
• ✅ Understood HTTP codes (4xx, 5xx)
• ✅ Be familiar with Java exceptions

---

🗺️ Module Outline

Theoretical Part (4 chapters)

Chapter 1: Exception Handling

Duration: 45 minutes

Content:

• Custom exceptions
• Exception hierarchy
• Best practices
• Checked vs Unchecked

Why important? The foundation of error handling

---

Chapter 2: @ControllerAdvice

Duration: 1 hour

Content:

• @ControllerAdvice and @RestControllerAdvice
• @ExceptionHandler
• Standardized error responses
• ProblemDetail (RFC 7807)
• ResponseStatusException

Why important? Centralized error handling

---

Chapter 3: Logging with SLF4J

Duration: 45 minutes

Content:

• SLF4J and logging facades
• Log levels (TRACE → ERROR)
• Logger patterns
• MDC (Mapped Diagnostic Context)
• Lombok @Slf4j

Why important? Diagnose issues

---

Chapter 4: Logback Configuration

Duration: 45 minutes

Content:

• logback-spring.xml
• Appenders (Console, File, Rolling)
• Patterns and formatting
• Spring profiles
• JSON logs for production

Why important? Professional configuration

---

Practical Part (2 Labs)

Lab 10.1: Centralized Error Management

Duration: 1h30

Objective: Implement a complete error handling system

You will:

• Create business exceptions
• Implement a GlobalExceptionHandler
• Standardize error responses
• Test with different scenarios

---

Lab 10.2: Logging System

Duration: 1h30

Objective: Configure professional logging

You will:

• Configure Logback
• Create environment-specific logs
• Implement MDC for traceability
• File logs with rotation

---

📊 Total Duration

Type	Duration
Theory	3h15 (4 chapters)
Practice	3h (2 Labs)
Total	6h15 (~2 sessions)

---

🎯 What You Will Understand

Before this Module

// Unhandled error 😰
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
    return userRepository.findById(id).orElseThrow();
    // → 500 Internal Server Error with full stack trace!
}

// No logs
public void processOrder(Order order) {
    // Does it work? Does it fail? No idea...
}

---

After this Module

// Clean error handling ✅
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
    return userService.findById(id);
    // → 404 {"type": "user-not-found", "title": "User not found", ...}
}

// Structured logging
@Slf4j
public class OrderService {
    public void processOrder(Order order) {
        log.info("Processing order {} for user {}", order.getId(), order.getUserId());
        // ...
        log.debug("Order total calculated: {}", total);
    }
}

Clean error response:

{
    "type": "https://api.example.com/errors/user-not-found",
    "title": "User Not Found",
    "status": 404,
    "detail": "User with ID 123 was not found",
    "instance": "/api/users/123",
    "timestamp": "2024-01-15T10:30:00Z"
}

---

🚀 Why This Module is Essential

1. User Experience

Without management:
- Stack trace exposed to client 😱
- Cryptic error messages
- Hard to debug on the frontend

With management:
- Clear and localized messages
- Documented error codes
- Standardized JSON format

2. Debugging in Production

Without logs:
- "The app crashed last night"
- "No idea what happened"
- Impossible to reproduce

With logs:
- Complete event trace
- User context (MDC)
- Filtering by level

3. Compliance with Standards

RFC 7807 - Problem Details for HTTP APIs
├── Standardized format
├── Interoperability
└── Automatic documentation

---

🗺️ Training Progression

Module 10 = Production-ready application!

---

📖 How to Approach This Module

Recommended Progression

1. Chapter 1 → Understand Java exceptions
2. Chapter 2 + Lab 10.1 → Implement global management
3. Chapter 3 → Learn logging
4. Chapter 4 + Lab 10.2 → Configure Logback

---

✅ Self-Assessment

Before starting, answer:

1. Do you know how to create a custom exception? ☐ Yes ☐ No
2. Are you familiar with @ControllerAdvice? ☐ Yes ☐ No
3. Do you use System.out.println for debugging? ☐ Yes ☐ No
4. Do you know how to configure Logback? ☐ Yes ☐ No

If you answered "No" anywhere, this module is for you!

---

🎯 Next Step

Ready to professionalize your error handling?

➡️ Start with Chapter 1: Exception Handling

---

⬅️ Back to Course Outline