Module 12: Java 8 in Real Projects (Spring Boot Focus)

Phase

Phase 4 – Expert Level

Target Audience

• Java developers working on Spring Boot applications
• Backend engineers building REST APIs and microservices
• Developers refactoring legacy Java codebases

---

1. Objective of This Module

By the end of this module, you will:

• Apply Java 8 features in real Spring Boot projects
• Use Streams, Optional, and Lambdas in layered architecture
• Write clean, readable service and repository code
• Avoid common production-level mistakes

---

2. Where Java 8 Fits in a Typical Spring Boot App

A standard layered architecture:

Controller → Service → Repository → Database

Java 8 features are mainly used in:

• Service layer
• Repository layer
• Utility and helper classes

---

3. Using Streams in Repository Layer

Example: Filtering Data

public List<User> findActiveUsers() {
    return userRepository.findAll()
                         .stream()
                         .filter(User::isActive)
                         .toList();
}

✔ Clear intent
✔ Easy to read

⚠️ Avoid heavy logic inside repositories.

---

4. Using Optional in Repository Layer

public Optional<User> findByEmail(String email) {
    return userRepository.findByEmail(email);
}

✔ Explicit absence handling
✔ Avoid returning null

---

5. Optional in Service Layer

public User getUser(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException(id));
}

✔ Clean error handling
✔ No null checks

---

6. Using Streams in Service Layer

Transforming Data

public List<UserDto> getUserDtos() {
    return userRepository.findAll()
        .stream()
        .map(UserMapper::toDto)
        .toList();
}

---

7. Lambdas for Validation Logic

Predicate<User> isAdult =
    user -> user.getAge() >= 18;

Reusable and testable validation.

---

8. Method References for Clean Code

users.forEach(UserService::logUser);

Improves readability in services and utilities.

---

9. Asynchronous Tasks with Lambdas

@Async
public CompletableFuture<Void> sendEmail(User user) {
    return CompletableFuture.runAsync(() -> emailService.send(user));
}

Lambdas simplify async logic.

---

10. DTO Mapping with Java 8

List<OrderDto> dtos =
    orders.stream()
          .map(OrderMapper::toDto)
          .toList();

Cleaner than loops and null checks.

---

11. Common Production Mistakes

• Overusing Streams in controllers
• Using Optional as method parameters
• Parallel streams in web requests
• Complex stream pipelines hurting readability

---

12. Best Practices Summary

✔ Keep controllers thin
✔ Use Optional at boundaries
✔ Prefer Streams for transformations
✔ Measure before optimizing

---

13. Hands-On Exercises

Exercise 1

Refactor a service method using Streams and Optional.

Exercise 2

Replace null-based repository methods with Optional.

Exercise 3

Clean up controller logic using Java 8 features.

---

14. Summary

• Java 8 shines in service and utility layers
• Clean code matters more than clever code
• Production usage requires discipline

---

15. What’s Next?

➡️ Module 13: Interview & Refactoring Mastery