Spring Boot 2 Microservice Messaging in RabbitMQ and AWS SQS

Install essential tools for this section, including the Java Development Kit 8, MySQL, Git, and RabbitMQ, with platform-specific setup guidance for Mac and Windows.

Install and configure JDK8 for the course, including downloading from Oracle, accepting licenses, setting JAVA_HOME, and verifying the Java installation across Windows, macOS, and Linux.

Install and configure MySQL as the relational database for persistence, guiding you through downloading the MySQL community server, running the installer, and completing the setup.

Install and configure Chrome advanced REST client, GitHub, Maven, and Tomcat, and set up environment variables for Maven to prepare the local development environment.

Install rabbitmq on a mac by updating macOS, installing homebrew, running brew update, and brew install rabbitmq, then start the server and open localhost:15672 with a guessed login.

Learn how microservices use push-based service discovery with Eureka, registering healthy instances under logical names to enable dynamic, load-balanced calls without hard-coded IPs.

Learn how real life service discovery mirrors microservice patterns in Spring Cloud, using everyday examples like restaurants and Google search to explain how services locate, register, and update.

Explore push-based service discovery in Spring Cloud with Eureka, where microservices register their IP and port and send health heartbeats to a central registry using logical names.

Create a Spring Boot project to implement a Eureka server for ecommerce service discovery, enabling client-side service discovery in a Spring Cloud environment.

Deploy the Eureka solution for Spring Boot microservices by configuring application.yml and bootstrap.yml, running the server, and inspecting localhost:8761 while comparing Spring Cloud service discovery to real-life discovery.

Explore remote configuration for microservices using two repositories—code and configuration—and a dedicated GitHub properties repo with a Spring Cloud config service to push updates and enable runtime refresh.

Showcases the spring cloud remote config service by wiring a config server with a property repository and minimal production java code. Learn to configure repository paths, ports, and actuator endpoints.

Explore AMQP RabbitMQ concepts, including publishers and consumers, exchanges, queues, and bindings, and learn how routing rules and acknowledgements enable durable, point-to-point messaging.

Learn RabbitMQ messaging concepts: default and direct exchanges, routing keys and bindings, and fanout exchanges for broadcasting to many queues, with order processing and fulfillment examples.

Created a Spring Boot producer project with Gradle, adding core dependencies like web, actuator, MySQL, RabbitMQ, config client, and Eureka discovery, focusing on coding while preparing for the next video.

Add swagger spring boot dependencies to enable live api documentation and testing in the spring boot microservice, using springfox swagger and swagger ui for interactive api exploration.

Create a user entity class for a Spring Boot microservice, mapping to a database table with id, columns, a registration date, and generate getters, constructors, toString, equals, and hashCode.

Create the account and address model classes in a Spring Boot microservice, configuring a one-to-one with user and a one-to-many with addresses, using constructor results and native query mappings.

Complete the account model class and write the address model class by generating getters and setters, constructors, hashCode/equals, and mapping a many-to-one relationship with street address, city, and zip code.

Define the AccountDTO class for result set mapping by generating getters and setters, adding a field-based and blank constructor, and implementing hashCode and equals for Spring compatibility.

Create a dao repository interface for the account entity with a long primary key, extending paging and sorting. Implement a service interface and class to save, update, and delete accounts.

Create an event class for a RabbitMQ listener by extending spring's application event, define account-related fields, generate getters, setters, and toString to support event transmission.

Add a native query and sql result mapping to the account model, mapping results to a data object for messaging, wired via repository and service with logging.

Create a spring-based account message sender and an account event listener to publish messages to RabbitMQ using a rabbit template, account exchange, and routing key.

Create a rest controller for accounts, wired to an account service, handling request mappings with post and get operations and publishing account events to RabbitMQ.

Add a new interface method for paging accounts by page number and size, implement in the accounts service, and wire through the controller to repository.find with descending account numbers.

Complete controller implementation adds get mapping for accounts with paging, update by id via put, and delete by id, using request params, request bodies, and API documentation.

Add the enable discovery client annotation to register your service with the discovery cluster (Eureka) and enable service discovery.

Configure Spring Boot properties for a RabbitMQ messaging setup by defining local host details, exchange name, routing key, and bootstrap metadata to enable a producer and prepare for consumer testing.

Create a dedicated consumer Spring Boot application that receives messages from the producer and sends an email to the user, with web actuator and Eureka discovery client support.

Add the mail Gradle dependency to enable sending emails about new account creation in the Spring Boot microservice.

Create the consumer application's packages, starting with a config package and a model package; copy the same model to the consumer and implement the emailing and receiving logic.

Create a consumer constant class with public static final strings for error, in progress, requesting, and failed, plus the message queue receiver and plan for application listener config.

Create a rabbitmq consumer listener in a spring boot microservice, configure logging, wire a mail sender, and outline receiving messages from a queue to trigger emails.

Develop a complete rabbit listener in Spring Boot to process messages from RabbitMQ and AWS SQS, build and send email, handle exceptions, log results, and re-queue failed messages.

Execute milestone 2 by compiling and running the config server, setting up a producer and RabbitMQ consumer, and validating the remote config service with Eureka and two applications.

Build and run the RabbitMQ producer application against a local RabbitMQ server, showing how to execute the jar and publish messages derived from account queries.

Set up and run the RabbitMQ consumer in a Spring Boot microservice, configure queues in RabbitMQ management, and verify the producer and consumer operate together.

Learn to test both the producer and consumer applications in a RabbitMQ and AWS SQS microservice setup, verify data flow through the database, and confirm registration emails are triggered.

Create a new Gradle project to implement a fan-out messaging setup with a sales order producer and consumer using RabbitMQ for a Spring Boot microservice architecture.

Create a Java package structure for a Spring Boot microservice, including aspects, config, events, exceptions, listeners, models, controllers, and services. Establish an empty package hierarchy before coding.

Reuse existing basic classes, including the rest controller, configuration, exceptions, and listeners, and then create unique classes in the next video.

Create the address model class as a JPA entity with identity-generated id and fields for name, street address, state, and zip code; map many-to-one relations to account and employee.

Create an employee model class with employee number, first name, last name, sex, type, and start date, and map one-to-many relationships to addresses and contacts with lazy loading.

Create an employee contact model class with fields for contact number, contact type, contact name, description, is primary, and a key to employee id; generate getters, setters, and blank constructor.

Generate getters, setters, constructors, toString, equals, and hashCode for the employee and address classes, verify compilation, and prepare the models for the next steps.

Create the item master model class with fields such as sku, upc code, item name, descriptions, size, color, manufacturer, shipped by, and implement getters, setters, constructor, toString, equals, and hashCode.

Create a non-JPA sales order dto to support querying orders, defining fields like id, order number, total amount, special instruction, ship method, estimated delivery date, and quantity.

Define a sales order model class with fields like order number, total amount, special instructions, and shipping method, mapping to employee and order details with lazy one-to-one fetch.

Create a sales order dao repository interface by extending the base repository and defining a query method to find all orders and order results.

Implement a Spring service implementation class annotated as a service, using a sales order repository to handle create, get by id, update, and delete by id operations.

Create a sales order controller in a Spring Boot microservice, wiring an abstract controller, rest controller, post mapping, order service, and sales order created event publishing.

Create a sales order event in spring boot by extending application event, adding event type and sales order fields, constructors and getters/setters, and wiring it into the controller.

Create properties files and bootstrap.yaml for a Spring Boot microservice; configure the application and routing key, prepare the producer, delete unused files, and get ready for testing.

Create a finance API consumer within a Spring Boot microservice setup, configuring JPA persistence, web client, Eureka, and necessary dependencies.

Create Java packages in the finance consumer application, including consumer config, model, RabbitMQ consumer, Spring Boot, and service, to establish the project structure ahead of class creation.

Create a data access object repository for accounts receivable in the finance consumer application, extending the repository interface, renaming entities, and configuring native queries.

Create a service interface and its implementation for accounts receivable, including save, find by id, find by page, update, and delete methods, wired to a repository and logger.

Create and configure a RabbitMQ listener for finance messages, processing sales orders into accounts receivable, logging transaction details, and handling errors to ensure reliable consumption.

Create Java configuration classes for the finance consumer, defining application constants, account receiver listener config, and bindings to a fan out exchange for accounts receivable messages.

Create a fulfillment consumer project and define fulfillment model class in Spring Boot, with fields for order number, shipping method, estimated delivery, item UPC code, name, quantity, and shipping address.

Create dao and service classes for the fulfillment module, wire to the fulfillment repository, and implement get by id and save to the database.

Implement a complete fulfillment listener in a Spring Boot microservice, parsing order details such as order number, shipping method, estimated delivery date, item UPC, quantity, color, size, and shipping address.

Rename the fulfillment API config to fulfillment listener config, update accounts receivable to fulfillment, and configure the fulfillment queue and exchange bindings.

Configure and verify the remote config repositories for the conflict service and its fan-out consumers, ensuring bootstrap properties, correct folder names, and consistent property files across all three repositories.

Create a folder, clone the repository, and run maven clean install to build the eureka server and verify it runs as a prerequisite for the fan out apps.

Execute milestone three by running the config service and Eureka server, set up producer and two consumers, and verify the same message reaches both consumers.

Create the listed Rolling Stone database tables, including employee, employee contacts, item, and related tables for accounts receivable, password, consumer, fulfillment, and address, and seed them with test data.

Start the RabbitMQ broker from the command line, verify six plugins load, and complete milestone 5 by validating Eureka and the conflict service in Spring Boot 2 microservice messaging course.

Run the sales order producer rest api, clone the repo, and build the jar. Start the producer and verify the RabbitMQ broker and database readiness.

Open a new window, build the finance CPI consumer, and run the first fanout consumer application. Demonstrate connecting three producer-consumer components to the same database for a classroom demonstration.

Test the producer and multiple consumers in a microservice messaging setup. Validate the flow across sales order, accounts receivable, and fulfillment queues and verify 200 OK responses.

Demystify the cloud by explaining virtualization, shared hardware and hypervisors, then introduce containers and Docker as lightweight, efficient deployment models.

Explore how AWS regions and availability zones enable high availability and disaster recovery through geographically distributed resources. Compare single-region deployments to multi-region strategies for resilient architectures.

Understand classless inter domain routing (CIDR) and how IPv4 addresses are split into network and host parts using a /24 prefix, guiding routers and subnetting in cloud and on-prem networks.

Explore how AWS VPC provides virtual private cloud networking with public and private subnets, route tables, an internet gateway, and NAT services to secure cloud applications.

Learn how to launch and configure AWS EC2 instances, from selecting the operating system and instance size to setting up storage, security groups, VPC and subnet, and key pairs.

Amazon RDS provides a managed relational database service with backups, licensing, upgrades, and scaling, offering read replicas, multi-AZ failover, and secure subnets and ACLs.

Explore how AWS SQS enables durable, secure messaging at scale, offering at-least-once delivery for standard queues and exactly-once delivery for FIFO queues, with high availability and cost efficiency.