Spring Boot Microservices with Spring Cloud!

Discover how Spring Boot simplifies building standalone, production-grade Spring applications by auto-handling dependencies, embedded servers, and essential configuration, so you can focus on writing application logic.

Learn to create a Spring Boot project from scratch using the Spring Tool Suite plugin in Eclipse, choosing Maven and jar packaging with embedded Tomcat and Spring Web starter.

Explore a maven project with source and resources, the com.company package, and see how spring boot starter web, the parent pom, and the fat jar plugin manage dependencies and versions.

Choose and integrate a Freemarker template engine, wire the controller, model, and view, and run a Spring Boot app locally to render an index and results page.

Discover how Spring Boot uses a single config annotation to enable auto configuration and component scanning, bootstrapping the application context and producing a fat jar that runs via java -jar.

Spring Boot automates configuration and embedded servers to let you build standalone, production-grade Spring apps with minimal setup, using starter dependencies and externalized configuration.

Discover how to deploy a Spring Boot application as a war on a Tomcat server by switching Maven packaging to war, using provided scope, and configuring startup for Tomcat deployment.

Resolve white label errors by cleaning the server, then run the Spring Boot application as a Java application, and access localhost:8080 to verify the app is running.

Learn how two web services communicate programmatically with rest template to exchange data and perform tasks, using two Spring Boot microservices with a CRUD API on the same host.

Learn to use the Jackson library to retrieve a specific product name by id from a JSON response by reading it as a tree and navigating nested objects.

Demonstrates sending post requests between web services using RestTemplate, including building the request, marshalling a product from JSON, and handling headers and responses.

Learn how to use rest template to perform a put request that updates a product, including marshalling json, setting content-type headers, and handling the response with exchange and response entity.

Explore reactive programming with the Spring framework and Project Reactor concepts. Understand Flux and Mono, back pressure, and the publisher-subscriber model for scalable microservices.

Learn how to implement reactive programming in Spring using Reactor's Flux as the producer and a subscriber, exploring backpressure and streaming data without a database.

Explore back pressure by contrasting pull and push models and how streams throttle and buffer data via subscriber requests in microservices.

Explore reactive response patterns by streaming products from the data store using flux or mono, enabling non-blocking, chunked delivery instead of waiting for all records.

Learn live streaming with reactor programming by delivering unbounded data in real time via text event stream, enabling clients to subscribe to temperature or score feeds while applying back pressure.

Explore the differences between flux and mono, using flux for multiple results like a product list and mono for a single result, ensuring the client receives one element.

Explore parallel streams by splitting a stream into multiple threads, showing four threads processing elements concurrently with Flux and reactor core schedulers, and apply back pressure to limit production rate.

Explore a microservices approach to product data by integrating product, pricing, and inventory services to assemble a json response with product name, description, price, and stock status.

Create a simple product service controller that returns hardcoded product details via a get mapping, using a Lombok-enabled product model and a dedicated Spring Boot port.

Explore assembling product details from multiple microservices by simulating a database with a list, retrieving product info by id, and planning for price and inventory retrieval in later steps.

Create a pricing service in spring boot that returns price and discount data for a product using a price object with product reference, price, and discount.

Build an inventory service in a Spring Boot microservices course that accepts a product idea and returns stock availability as a boolean, via a controller using Lombok annotations.

Replace hard coded values with live data by calling pricing and inventory services via REST template in Spring Boot microservices, configure a REST template bean, and test endpoints with Postman.

Introduce a currency exchange service that provides USD to other currencies exchange rates, enabling the product service to convert and respond with prices based on request origin.

Identify a bug where the product list multiplies with requests and fix it by clearing list on method calls (or in constructor), ensuring consistency in pricing, inventory, and exchange services.

Fix bug where the product list grows with each request by clearing it in the method or initializing in the constructor; introduce a TDD chapter for pricing and exchange services.

Rate and review this course to share your journey, reflect on what you've learned, and comment on the instructor's teaching style to help others decide whether to enroll.

Explore implementing reactive programming with Spring WebFlux, replacing blocking rest templates with WebClient, using Mono and zip to combine product info, price, and inventory into a reactive product package.

Replace blocking rest template with Spring WebFlux web client to enable non-blocking calls and combine product info, price, and inventory using the zip method.

Migrating to reactive programming requires careful planning, as a single blocking operation can stall the entire app and downstream microservices; maximize reactive code and use BlockHound to identify blockers.

Learn a migration strategy to replace blocking API calls with reactive non-blocking libraries. Assess risks, acquire talent, and plan staged migrations with tests and performance checks.

Expose a product list endpoint returning all products with price and stock via a declarative flux stream, and optimize by consolidating pricing and inventory calls.

Understand service discovery through a central service registry that maps dynamic microservice locations, avoiding hard-coded IPs, with a DNS-like lookup powered by Netflix Eureka.

Replace rest template with Feign client for inter-service calls among product, pricing, and inventory, enabling declarative requests via Spring Cloud OpenFeign and auto-injection.

Set up the Utica server as a Spring Boot microservice, add the Utica server dependency, and enable the Eureka server to register clients and launch successfully.

Register Eureka clients by adding the Spring Cloud dependency, configure the application name, and use the client library to register, deregister, and discover services via the Eureka server.

Learn how to build a resilient Eureka server with multiple registry instances across locations, using peer communication and data replication to ensure continuous service discovery.

Create multiple server profiles using properties files to launch three Yureka server instances on different ports, enabling registry replication and cross-server communication.

Launch server instances by activating profiles via Eclipse run configurations or a command, configure eureka.instance.hostname, and simulate dns with the hosts file for multi-node replicas.

Learn how data replication synchronizes microservice instances in a Spring Boot with Spring Cloud setup. Configure services to register with multiple instances and test resilience using Postman and Eureka.

The lecture explains how the client caches service registry data and periodically refreshes it from the server, improving efficiency, with configurable update intervals and lease expiration.

Explore how to gain fine-grained control over Eureka microservices by injecting the Eureka client to list applications, fetch instances by ID or name, and select regional servers for optimized discovery.

Adopt non-blocking reactive feign to build clients that return mono or flux, using a builder, and integrate with cloud providers, instead of blocking rest templates.

Learn how load balancing distributes requests across multiple microservice instances to prevent overload, enhance throughput, and enable horizontal scalability, including client-side balancing with Netflix Ribbon.

Demonstrate how load balancing distributes requests across inventory service instances using Ribbon and Eureka. Show how to configure ports, test with Postman, and observe round-robin traffic across 8003 and 9006.

Learn how to implement Ribbon load balancing without Eureka by disabling service discovery, configuring Ribbon with a list of inventory servers, and enabling load balanced RestTemplate.

Explore how to customize the ribbon load balancer by choosing IRule implementations like round robin, random, and weighted response time, and wiring custom rules through a config bean.

Explore client-side versus server-side discovery and load balancing in microservices, and learn how a dedicated load balancer decouples discovery from the service client by using the service registry.

Explore api gateway theory in microservices, centralizing service routing, caching, authentication, monitoring, and rate limiting to simplify clients and improve performance.

Create a gateway to centralize routing for product, pricing, and inventory services and configure routes so all client requests go through a single gateway registered with Eureka.

Configure gateway routes with a Java class that builds a RouteLocator to forward /price/* to localhost:8002 and add an inventory route, with gateway discovery and port 9001.

Configure and test a Spring Boot gateway by wiring the gateway service as the target, resolving bean name conflicts, enabling actuator routes, and validating routing to pricing and inventory services.

Configure routes using predicates, including cookie predicates with name and regex, and time-based predicates such as after and between. Examine the predicate factory class for routing logic.

Gateway filters centralize cross-cutting concerns like security, logging, and metrics, ensuring consistent enforcement across microservices. Pre filters modify requests before routing; post filters log, audit, and validate responses before sending.

Explore built-in filters in Spring Cloud to manipulate requests and responses, including adding headers, modifying the body, rewriting paths, and redirecting, plus rate limiting and custom response headers.

Create custom gateway filters to enforce authorization and manipulate requests across microservices. Implement pre-filters, post-filters, and global filters to control routing.

Explore how the circuit breaker pattern protects microservices from cascading failures by breaking the circuit when a service times out, enabling a fallback mechanism and preserving overall app availability.

Implement the Hystrix circuit breaker pattern in Spring Boot microservices, configure a one-second execution timeout, and define a fallback that returns a default product.

Build resilience in microservices by detecting failures early, limiting impact, recovering quickly, and resuming normal operations, as cascading failures from an unresponsive payment gateway can stall orders and disrupt notifications.

Apply the circuit breaker pattern in microservices to prevent cascading failures from unreliable downstream services, using open, half-open, and closed states with strategic fallbacks.

Implement a circuit breaker in Spring Boot with Spring Cloud by configuring sliding window size, failure rate threshold, and open/half-open states, using a fallback for unreliable external calls.

Explore retry strategies in resilience for Spring Boot, including fixed and exponential backoff with a randomized delay, maximum retry attempts configured in application.yaml, and the functional API with fallback handling.

Combine circuit breaker and retry to protect external calls, configuring a 50% failure threshold and 10-second open state with five retries and 2-second delays, via decorate and annotation approaches.