Practical World Java Spring Microservices

Install the JDK, a database, a source control manager, and Apache Miren and Gernot to prepare for building and running the application.

Install the Java development kit by downloading the Oracle JDK for your OS, accepting the license, and running the installer. Then set JAVA_HOME and verify the setup with java -version.

Install MySQL community server by downloading the full installer from the official site, then run the setup, accept files, click next and finish, and configure the server.

Install chrome advanced rest client, Git SCM client, Maven, and Apache Tomcat; configure PATH and Maven home, then verify installations as you set up your Java Spring microservices development environment.

Explore the problems of monolithic applications, including why testing and error detection are hard, examine motivations for a microservices architecture, and view the monolithic model as not realistic.

Clone the monolithic grocery service and import it into Spring Tool Suite, then set up the workspace and prepare the migration of monolithic services to microservices.

Analyze the structure of a monolithic e-commerce service with controllers, interfaces, models, and databases, and learn how to migrate it to a microservices architecture.

Explain the testing pain of monolithic applications when a single change touches many APIs, requiring full regression testing and delaying time to market.

Explore why monolithic apps with 20–50 APIs suffer costly bugs, like memory leaks in production, and how adopting microservices isolates failures to protect others.

Explore how microservices deliver efficiency by isolating work so a single absent developer doesn't halt the project. Contrast this with the monolithic testing pains highlighted in the lecture.

Explore Spring Boot 2 fundamentals with a focus on the actuator features, building a simple REST API, and understanding changes in the actuator endpoints.

Migrate a monolithic app to spring boot microservices using Spring Initializr. Add spring boot starter web and actuator and prepare the todo rest api microservice template.

Compare springboard and legacy spring apps, and learn how a parent pom in springboard inherits dependencies and plugins, delivering ready starters like actuator and test with convention over configuration.

Learn how Spring Boot streamlines setup by adding a default class, enabling an embedded Tomcat, and exposing a REST controller with a simple hello world endpoint via get mapping.

Learn to run a Spring Boot application from the command line by cleaning, packaging, and executing the generated jar file, noting the standard jar and the Tomcat-enabled jar.

Explore Spring Boot actuator by wiring a dedicated management port, adding a properties file, and accessing /actuator endpoints such as health and info to observe application health.

Configure spring boot actuator to expose more endpoints and explore health, metrics, mappings, and environment properties, including adding custom business metrics to monitor items sold.

Migrate the product API from a monolithic architecture to microservices by creating a new microservice, defining a new packet structure, migrating classes, and testing the API.

Learn to scaffold a new microservice project with Spring, select Maven, and add web, JPA, and MySQL dependencies to build a product API for migration from springboard.

Enhance the Maven POM to support a microservices migration, review the BOM, and add Jackson and Swagger integration for live API documentation with Spring Boot 2.0 and MySQL.

Create the package structure for a Spring microservices project by defining domain, repository, service, and controller packages. Compare approaches with monolithic structure and note Spring legacy considerations.

Migrate the model classes from a legacy monolithic application to a microservice API, focusing on product and category entities. Establish one-to-one relationships and JPA mappings.

Learn to migrate DAO interfaces to a Spring Data repository, replacing monolithic persistence with a paging and sorting repository that provides save, find, update, and delete operations automatically.

This lecture covers migrating the service interface and class from legacy app, removing redundant code, and substituting the logging framework with a decoupled solution while clarifying JPA and Hibernate roles.

This lecture guides migrating the service save method in a practical Java Spring microservices setup, adjusting the product repository and controller to return a product instead of a long.

Migrate the service get method by switching to the repository's find by id and returning an optional, updating the interface and imports to align with Java 8 best practices.

Migrate the service list method to support pagination and sorting by product code, introducing get products by page with page number, page size, and descending criteria.

Migrate the service update method to use the Spring Data repository save, which updates when an id exists and inserts when it does not.

Migrate the service delete method and resolve the renamed method in the Spring Data repository. Ensure all classes compile and ask for help if questions arise.

Migrate the product controller into the micro service controller package after completing surveys migration and model setup, then address compilation errors by fixing methods step by step.

Migrate the controller save method by updating the product service to return a saved product, aligning with a spring microservices workflow and setting up future get-method fixes.

Fix the controller get method by handling an optional product returned from the service and extracting the actual product before returning it.

Fix the controller list method to support paging by exposing get products by page with page number and page size, defaulting to 0 and 20, and returning paged products.

Learn to build and run a Spring microservice by configuring application properties, wiring the database, and testing a product API with post, get, and delete operations.

Add an aspect oriented class to the product API, introducing a rest controller aspect and a micrometer counter for product creation with before and after returning advice.

Explore aspect-oriented programming in Spring by defining aspects, configuring pointcuts and execution, and running before and after advices to trigger cross-cutting behavior in services.

Create a dedicated core package for HTTP 400 and HTTP 404 exception classes and implement an abstract controller for centralized exception handling across all microservices.

Learn to build an abstract controller in a Spring microservices project, implement exception handling, and integrate an application event publisher to manage rest error responses.

Learn to add an event publisher method by implementing an interface that lets spring supply an application event publisher, and use it in a controller to send messages to listeners.

Add a checkResource method that validates the resource is not null before get, update, or delete operations, throwing an exception if null, and extend an abstract class in future videos.

Extend the abstract controller by wiring a product service via constructor, rename endpoints to create, get, update, and delete product, and prepare for testing in a Spring microservices context.

Create a product event class in a new events package with a string field and a product object, including getters, setters, and a no-args constructor.

Create an event listener in spring by turning a class into a component, log events, and handle onApplicationEvent asynchronously to decouple tasks like emailing after order receipt.

Create a single application file to configure the actuator, open the management server, and expose all endpoints by default in Spring.

Configure the actuator health endpoint in Spring, review default behavior, and plan to implement a custom health endpoint for tailored status reporting.

Add code to send product events from the controller by building a product event object and publishing it with the event publisher, then adjust endpoints and prepare tests.

Test Spring microservice endpoints using a rest client to verify product creation, retrieval, update, delete, and related event listeners. Validate that crud operations trigger expected responses and events.

Test Spring Boot actuator endpoints for health and metrics in a practical microservices setup. See how enabling health details shows a healthy status and how metrics values can be accessed.

Explore service discovery from real-life approaches like Google and Spring Cloud, compare their methods, and implement a practical discovery solution using Eureka, then build and test it.

Explore how real-life service discovery concepts map to Spring Cloud microservice design patterns and learn to apply discovery patterns through practical analogies.

Explore push-based service discovery in microservices, where monolithic boundaries dissolve as services register with a registry using a logical name and health heartbeats to reveal healthy instances.

Explore how service discovery decouples microservice clients from services, enabling load balancing and high availability, while serving as a hub for health data and patterns like declarative client and Hystrix.

Start a Spring Boot starter project, configure Spring Cloud Eureka for a discovery service, and set up the e-commerce client with a web application.

Add annotations to the main program to enable production-ready behavior. Import Spring Cloud Netflix components and prepare to implement property changes in the next video.

Deploy the Eureka service discovery by configuring bootstrap.yml and application.yml, running a Spring Boot server, and exploring the Eureka dashboard at localhost:8761 to understand registered services.

Explore integrating the product API with the client service registration, showing microservices registering with the service resolver and configuring a client service registrar with the mobile dependency.

Enable client-side service discovery by registering the product API with Eureka in a Spring Cloud microservices setup, and align server and client configurations for compatibility.

Explore the remote configuration service in spring cloud microservices, detail properties problems, and build a remote config repository. Then test the setup using a browser.

Explore remote config to loosen coupling by moving properties to a central spring cloud config service and using profiles to fetch environment-specific settings for each microservice.

Learn to create a remote config repository for Spring Cloud, organizing properties per microservice with a hierarchical folder structure, bootstrap properties, and per profile yaml files for the product API.

Create a remote config microservice by starting a new Spring project, setting up a config server, wiring a Git repository, and configuring bootstrap and application properties.

Test remote config service in a browser on port 9000 by passing service name and profile as path variables. Validate product, category, and pricing properties for Rollingstone e-commerce product API.

Connect the product api to receive properties from the spring cloud remote config service, verify remote config usage, remove local property files, and test.

Enable actuator properties in remote config and test by configuring the management server port and endpoints, then review metrics and health details and customize health information for services.

Add the config client to the product API using Spring Cloud Config and bootstrap, so each microservice loads remote config. Start the remote config service and sanity test product endpoints.

Refactor the category API from the product API, reuse the product API patterns across microservices, and test the updated category API to ensure consistency and functionality.

Refactor the product API into a category API by reusing controllers, services, models, and discovery configurations, while aligning with Spring Cloud components like config client and Eureka.

Demonstrates end-to-end testing of a category API in a Java Spring microservice, including fixing a mapping typo and validating create, read, and update operations.

Verify that the actuator and discovery dashboard function, show discovery client status and Eureka config, and confirm the category API is registered with endpoints showing up or down.

Add swagger 2 for API documentation in a Spring Boot microservice, configure Springfox, create a swagger config with a docket and request handler selection for a testable rest client.