Master RESTful APIs with Spring Boot 2 in 100 Steps

It looks like you're following a comprehensive curriculum on Spring Boot, covering various advanced topics. Here's a brief overview of what each step entails based on the structure you've provided:

Module 07: Spring Boot - HATEOAS

• Step 00: Learn about HATEOAS (Hypermedia as the Engine of Application State) and its importance in RESTful APIs.
• Step 00: Create a new git branch to work on HATEOAS features without affecting the main codebase.
• Step 01: Add the necessary dependency for HATEOAS in your pom.xml file.
• Step 02: Extend your User and Order entities with ResourceSupport to add hypermedia capabilities.
• Step 03: Create new controllers or modify existing ones to handle HATEOAS aspects like self links.
• Step 04: Implement self links in methods that retrieve resources by ID.
• Step 05: Implement both self and relationship links in methods that return collections of resources.
• Step 06: Commit your changes, push them to the remote repository, and merge them into the master branch once you're done.

Module 08: Spring Boot - Internationalisation

• Step 00: Learn about internationalization in Spring Boot and how to handle multiple languages.
• Step 00: Create a new git branch for internationalization features.
• Step 01: Configure beans such as LocaleResolver and ResourceBundleMessageSource for locale resolution and message globalization.
• Step 02: Implement internationalization in your RESTful services, allowing them to respond in different languages based on the client's locale.
• Step 03: Commit your changes, push them to the remote repository, and merge them into the master branch.

Module 09: Spring Boot - Filtering

• Step 01: Learn how to filter out unnecessary or sensitive data from API responses using @JsonIgnore and @JsonIgnoreProperties.
• Step 02: Implement dynamic filtering using MappingJacksonValue, which allows for filtering on a per-request basis.
• Step 03: Further explore dynamic filtering with MappingJacksonValue combined with @RequestParam.
• Step 04: Perform dynamic filtering with MappingJacksonValue and demonstrate how to use it in a real scenario.
• Step 05: Introduce @JsonView for filtering, which allows you to define different views of your data.
• Step 06: Implement filtering using @JsonView and show how it can be used to include or exclude parts of an object based on the view requested.

Module 10: Spring Boot - DTOS - Data Transfer Objects

• Step 01: Explore ModelMapper as a tool for mapping between objects.
• Step 02: Add the modelmapper dependency to your pom.xml and configure it.
• Step 03 and beyond: Use ModelMapper to map between entities and DTOs in your application.

Module 11: Spring Boot - Validation

• Step 00: Learn about validation in Spring Boot and its importance for data integrity.
• Step 01: Add the necessary dependency for validation, such as spring-boot-starter-validation.
• Step 02 to beyond: Use annotations like @NotNull, @Size, @Min, etc., to enforce constraints on your model attributes.
• Step 03: Handle validation errors gracefully in your RESTful services, returning meaningful error messages to the client.

Module 12: Spring Boot - Web Flux

• Step 00: Understand reactive programming and its benefits for handling asynchronous operations and backpressure.
• Step 01 to beyond: Refactor your controllers and services to use WebFlux and the reactive stack, which includes Mono and Flux.

Module 13: Spring Boot - Actuator & Admin

• Step 00: Learn about Spring Boot Actuator and its out-of-the-box management features.
• Step 01 to beyond: Add the necessary Actuator dependencies to your pom.xml and expose endpoints like /health, /info, /metrics, etc.
• Step 03: Set up Spring Boot Admin to provide a user interface for monitoring and managing your applications.
• Step 04 to beyond: Connect your Spring Boot client application to the Spring Boot Admin server and explore its features for application management.

Module 14: Spring Boot - Actuator & Micrometer

• Step 00: Learn about Micrometer as a tool for observability metrics and monitoring.
• Step 01 to beyond: Add the necessary Micrometer dependencies to your pom.xml and integrate with JMX or other instrumentation frameworks.
• Step 02 to beyond: Export metrics to monitoring services like AppOptics, Datadog, or Prometheus and create dashboards to visualize them.

This curriculum covers a wide range of topics that will help you build robust, scalable, and observable Spring Boot applications with a rich set of features. Each module builds upon the knowledge gained in the previous ones, so it's important to understand each concept before moving on to the next one. Good luck!