Build Microservices with Spring Boot, REST & MySQL

Download java from oracle.com and choose a version compatible with Spring Boot (Java 11 in course). Install on Windows and verify with java in cmd, then set PATH and restart.

download and install MySQL Workbench by selecting your operating system on dev.mysql.com, then install and note the default username and password for login.

Download Eclipse from the official page, click the download button for the latest version, and install the software; if downloads stall, use a mirror.

Download and install Postman by visiting the official Postman page, choosing your operating system, downloading the executable, and completing the installation.

Explore microservices architecture as a method to break a complex program into independent, manageable chunks that can be operated on and communicate independently, contrasting it with monolithic architecture's obstacles.

Explore monolithic architecture as a self-contained, tightly coupled, single-tier application with large code bases. Learn why tight coupling complicates changes and deployment, and how microservices address these issues.

Compare microservices and monolithic architecture with a demonstration using modules M1, M2, and M3; monolithic uses a single database, while microservices own databases and deploy independently.

Compare monolithic and microservices architectures across deployment, scalability, testing, and development, showing how independent modules affect deployment complexity and end to end testing for each component.

Explore a two-microservice setup with a movie service and a genre service, demonstrating how an API gateway and service discovery enable inter-service communication.

Explore how an api gateway sits between clients and microservices, enabling single authentication and routing to services like genre and movie.

Discover how service discovery centralizes microservice locations by registering each instance with its IP and port, enabling visibility, up/down status checks, and easier debugging with Eureka and Spring Gateway.

Create two separate databases for the movie and genre microservices, then build a movie table with id, name, year, and genre_id, and a genre table with id and name.

Add data to the genre and movie tables by inserting four genres and eight movies, using both insert queries and a GUI interface to populate the microservice database.

Generate a Spring Boot microservice project using start.spring.io, configure Maven, and import it into Eclipse with dependencies such as Eureka Client, Spring Data JDBC, MySQL Connector, and Spring Web.

Create the movie pojo class in the model package with id, name, year, and genreId, and generate constructors and getters and setters for the upcoming dao and service layer.

update application properties to set a non-default port and define the spring application name, then configure the MySQL data source (url, username, password) for the movie micro service.

Builds the DAO layer for movies, defining a DAO interface and implementation that uses Spring JDBC template to fetch all movies and by genre, mapping rows to movie objects.

Define a movie service interface and implementation in a service layer, autowire a movie, and call get all movies and get movie by genre ID to decouple from Dow layer.

Create a rest controller with a common request mapping, exposing get all movies and get movie by genre via the service layer, avoiding direct dao calls.

Run a movie microservice using spring boot, resolve bean recognition by annotating the service with @Service and @Repository, then access endpoints on localhost:9010 and test with Postman.

Generate a genre micro service project with spring initializer, import into eclipse via maven, and include spring web, dev tools, spring jdbc, MySQL connector, and Eureka client.

Create genre and movie pojo classes by setting up a simple package, importing, and generating no-arg and all-args constructors with getters and setters for a streamlined microservice.

Implement the dao layer for genres using jdbc template and bean property row mapper, exposing methods to fetch all genres and a genre by id.

Build the service layer by creating a shortener service interface and its implementation, autowiring the DAO, and annotating the classes as service and repository; next, proceed to the controller.

Develop a rest controller for the genre resource with endpoints to get all genres and get a genre by id, autowiring the genre service to fetch data.

Configure application.properties for the shortener microservice with a unique port 8090 and distinct spring application name, keeping credentials unchanged, then run the genre service to observe its behavior.

Run the genre microservice and observe its independence from the movie service. Prepare for api gateway and service discovery to enable genre lists with their movie data.

Configure a Spring Boot API gateway using Spring Cloud Gateway and Eureka discovery client, define routes with predicates, enable load balancing, and run to verify genre and movie service connectivity.