Microservices With Spring Boot and Spring Cloud

Develop a Spring Boot microservice called person service, backed by JPA and Hibernate, to perform create, read, update, delete operations and map its components including application, controller, service, repository, Swagger.

Explains Spring Boot startup and runtime flow for the person service, from application startup to a get all persons request via controller, service, repository, and json conversion.

Explore how a Spring Boot and Spring Cloud based person service creates a person via a sequence diagram, from controller to service to repository, with event listener and event publishing.

Explore how the person service is structured in class diagrams, showing controller–service delegation, a shared abstract rest controller, a Spring Data runtime repository, and event publishing to a listener.

Get a quick start with spring boot by setting up the person service project. Clone, build, run with active profiles, and verify the application using the provided video walkthrough.

Introduce a Spring Boot microservices template project for Spring Boot and Spring Cloud, showing how to set up, run, and test CRUD operations with active profiles.

Import an existing maven project into Spring Tool Suite by selecting import. Copy and rename the template to create the person service, and inspect the package structure.

Modify and explain the maven pom.xml for a Spring Boot microservice. Leverage the Spring Boot starter parent and essential dependencies like web, actuator, and Jackson, with memory database profiles.

Modify the person domain pojo to persist with JPA and Hibernate by configuring id generation, column mappings, constructors, toString, and equals/hashCode for reliable entity identity.

Create a JPA repository using Spring Data in Spring Boot and Spring Cloud, extending the repository to enable CRUD operations, custom queries, and paging and sorting for a person entity.

Configure service properties with spring boot actuator for health checks on the person service and implement events for create, update, and delete as the events propagate to listeners.

Create a person event listener to react to person events, persisting the person and optionally sending an email, while explaining synchronous and asynchronous processing in Spring for responsive microservices.

Create a custom health indicator for the person service by wiring service properties and actuator health to determine overall app health and report it via the health endpoint.

Refactor the existing service into a person service, update the person repository, wire the service into the controller, and validate compilation using a Spring Boot and Spring Cloud template approach.

Build a create api for the person controller in a spring boot microservice, handling 400 and 404 errors, with rest mappings, a person service, and event publishing.

Implement get, getAll, update, and delete endpoints for the person controller using class and method level request mappings. Validate existence and use the person service with default paging.

Explain the abstract rest handler superclass for person controllers, covering the application event publisher, global exception handling, and shared behavior across controllers in a Spring Boot microservice.

Explore aspect oriented programming concepts in spring, including before, after, after returning, and after throwing advice, applied to rest controllers. Understand join points, pointcuts, and how aspects intercept controller methods.

Add a Spring Boot main class to bootstrap the simple service and enable component scanning of the package, using annotations for the repository and service to configure automatically.

Refactor and clean up a multi-person microservice by removing pending to-dos, ensuring compilation, and consolidating resources into the person service and its controller.

Configure per environment microservices by using application properties and bootstrap files, set distinct server ports, and manage profile-specific databases with actuator and security considerations.

Build, run, and test the get all persons api using spring boot and spring cloud. Verify controller execution with AOP logs and ensure correct results.

Test the get person API by calling the single get method with a path variable ID, showing how Spring maps the request to the controller and invokes find.

Test create person api demonstrates posting a new person, saving to the repository, and publishing a person created event that is consumed by a listener to confirm end-to-end event-driven behavior.

Build update and delete person endpoints in Spring Boot, using put for update by id and id conversion, and verify delete method not allowed with Swagger testing.

Explore Spring Boot Actuator by inspecting custom health, health endpoint details, metrics, and logs; learn to expose management endpoints, track counters, and use trace and dump for diagnostics.

Learn to enable active api documentation with Swagger in Spring Boot using Springfox annotations, and explore viewing and testing get, post, and delete operations in the Swagger UI.

Explore the concept of Spring Cloud service discovery, and see how a service registry and runtime discovery of running service instances enable scalable microservices in cloud environments.

Set up the /etc/hosts file with multiple hostnames for the same IP, then create a spring cloud service discovery project and add dependencies via spring cloud dependency management (camden).

Learn to create and configure Spring Boot properties files, define profiles for high availability, and set up a service discovery registry with Eureka to enable inter-service communication.

Build the project and run two microservice instances using Maven clean package, then start both services and verify Eureka registration and inter-service communication.

Explore viewing Spring Boot actuator endpoints to monitor microservices with Spring Cloud discovery, production-level metrics, and an analytics dashboard across services.

Explore how service discovery decouples clients from services via a central registry, enabling load balancing and high availability with Spring Cloud, Eureka server, and client-side registration.

Create a Spring Cloud Config repository project, then set up profiles and property files for dev, default, and production, showing how to organize and copy properties per environment.

Set up ssh keys for the spring config repository by generating an rsa key in your home directory and adding the public key to your GitHub account.

Learn how to create a GitHub repository, initialize a local git project, commit changes, and push to a remote repository using origin master, with readme and gitignore considerations.

Discover how spring cloud config server centralizes and securely stores application properties in a repository, using application path and profile to deliver environment-specific configurations with a refresh scope.

Create a new Spring starter project for a Spring Cloud config service, configure dependencies and versions, and prepare for properties and program elements in the next video.

Add properties and bootstrap config, set up a Spring Cloud config server, and centralize configuration in a repository for the customer service during a microservices setup.

Learn to test the Spring Cloud config service by building, packaging, and running the config server, verifying properties across profiles, and validating external service access to the config data.

Discover how spring cloud config server centralizes application properties in a single repository, enabling runtime refresh and decoupled microservices, with secure backends and multiple environments behind a load balancer.

Explore the core of Spring Framework, including dependency injection and Aspect Oriented Programming, and see how these concepts translate to real life experiences and future Spring Boot workflows.

Add and configure a Maven pom.xml for a Spring project, including dependencies for Spring context, AspectJ, and logging with Logback and SLF4J, while excluding Commons Logging.

Create packages and a customer class with investments, wiring dependencies through Spring IoC using constructor injection and factories, aided by local date and time factories for dates.

Explore inversion of control and dependency injection in Spring, and learn how constructors, setter injections, and factories wire dependencies through basic configuration.

Create an xml bean configuration accessed by a test program, illustrating spring declarations and constructor injection for customer and investment beans.

This lecture demonstrates debugging a failing Spring bean configuration by contrasting bad and good customer configs and fixes conversion errors with a factory method using a constructor argument.

Diagnose and fix investment bean configuration by matching the constructor arguments to the bean setup, choosing the correct constructor, and adjusting XML or factory references for local date.

Explore configuring lists and maps in Spring Framework using dependency injection, including lists of strings and maps of strings to custom objects, and test with a Spring IoC setup.

Fix errors and run the list configuration in a Spring Boot microservices project, debugging class not found and package issues to reliably load lists of strings and custom objects.

Develop an xml config for maps in Spring Boot microservices, wiring a map of strings and a map of objects like car entities, and validating date handling.

Explore Spring's IOC and constructor injection to configure lists of strings and custom objects, such as shopping cart items, using local factories and maps to test collections.

Explore configuring maps in Spring by building map of strings and map of objects, using value and value-ref in constructor arguments, and running a basic test program.

Explore setter injection in Spring and wire beans through setters, building configuration for lists, maps, and custom objects, and test the Spring configuration file.

Fix and run setter injection in Spring by diagnosing errors, correcting package paths, and wiring customer, address, and education properties through Spring configuration.

Explore how real life dependency injection mirrors Spring's approach, using animals, trees, and nature to illustrate how objects are provided by the environment rather than created in isolation.

Explore real life dependency injection through a spring di analogy, showing how objects like atmosphere, trees, and animals model how spring wires beans and manages oxygen flows.

Understand aspect oriented programming and how crosscutting concerns like logging and security centralize in spring via proxies and before/after/around advice. See join points, pointcuts, and weaving with airport security analogies.

Model airport operations with an interface and plain Java, then apply a Spring AOP proxy to intercept calls. Learn before, after, and after throwing advice and why interfaces enable proxies.

Apply aspect oriented programming in spring to create proxies via dependency setup and annotation driven weaving for flight, airport operations, and travelers.

Demonstrate aspect oriented programming in a spring boot context, implementing an airport operations interface and security checks, with an after throwing aspect that logs exceptions and traces traveler processing.

Co-create a spring aop configuration to implement aspect oriented programming, showing how a proxy intercepts calls to the airport operations target object through before and after aspects.

Explore the customer microservice quickstart by opening a terminal, navigating to the project directory, running the service, and watching the explanation videos for practical guidance.

Clone the spring cloud template repository to explore microservices with spring boot and spring cloud, focusing on service discovery, config client, and domain object diagrams plus docs and sequence diagrams.

Explore UML class diagrams centered on a customer domain, mapping one-to-many relationships among accounts, addresses, contacts, liabilities, investments, employment, and education, to model home loans and lender evaluation.

Follow the Spring Cloud startup sequence diagram to learn how the app retrieves properties, registers with the service discovery registry, and initializes the Spring context for microservices.

Trace the customer creation sequence in a Spring Boot microservice, from client to controller, service, repository, and event-driven listeners, culminating in JSON conversion.

import an existing Maven project into the spring source tool suite, deselect unnecessary modules, finish the import, and load the spring cloud template to start building microservices.

Explore Maven POM elements and configure Spring Boot microservices with Spring Cloud, including discovery and config client dependencies, customization of templates, and managing releases.

Define the account and account type domain POJOs using JPA entities, with one-to-one and many-to-one relationships, lazy fetching, generated IDs, and constructors.

Explore address and contact type domain pojos for customers, including street, city, state, zip, country, and address variants, plus 1:1 and 1:many relations.

Explore the customer domain object, its id, names, social security number, date of birth, and loan amount; learn one-to-many and many-to-one relationships with addresses and prevent duplicates with a set.

Model education, degree type, employment, investments, and liabilities as connected domain objects with one-to-one and one-to-many relationships in a customer-centric microservices setup, prepared for rest APIs in Java.

Perform bottom-up refactoring of the service package to fix compilation by renaming and configuring the customer service classes, adjusting event and listener wiring, and tidying imports for a successful build.

Create the customer service and its repository, extract the customer domain, remove unused global services, and align primary key and get all operations across customer, counter, and product services.

The lecture guides editing and serving the customer controller, linking it to the customer service and API, and prepares to troubleshoot compilation issues.

Improve and finalize the custom customer controller by resolving compilation issues in Eclipse, implementing get all customers, get customer by id, create update delete operations, and wiring with customer service.

Modify the rest controller aspect in the service module using before advice to trace and route create customer and get all customers operations within Spring Boot and Spring Cloud microservices.

Configure the Spring Boot customer start application by enabling auto-configuration, setting up JPA repositories, and enabling discovery client to register with the discovery service using a shared logical name.

Modify configuration properties across bootstrap, profiles, and cloud config to resolve conflicts and ensure local and remote server properties load correctly in a microservices environment.

Clone the Eureka and config service repositories, switch to the latest Spring Cloud versions, and build both with mvn clean package before running the apps.

Run two Eureka service instances for high availability, configure spring profiles and host mapping, and verify they register and communicate on localhost ports 8761 and 8762.

Validate the spring cloud config service by connecting to a dedicated repository that holds per-microservice properties, using the application name and profiles to fetch the correct configuration for each client.

Build and run the customer service microservice with Spring Boot and Spring Cloud, load properties from the config server, and verify discovery with the Eureka client before testing.

Test customer service APIs demonstrates get, create, update, and delete operations, verifies database records, and tracks generic and specific console messages via a Spring event publisher and application listener.

Explore actuator endpoints and Swagger UI in a Spring Boot microservices setup, test health, manage properties, and interact with a sample customer service through Swagger documentation.

Explore how Spring Cloud declarative Feign client works via a sequence diagram, detailing client calls, service registry and discovery, and client-side load balancing with Ribbon.

Explore how spring cloud declarative feign with ribbon handles client-side load balancing on service failure, introducing hystrix circuit breaker, sequence diagrams, and fallback method.

Introduction to the customer account service in a microservices architecture with Spring Boot and Spring Cloud, using Feign for declarative calls and Hystrix for resilience and validation.

Clone the repository from GitHub and configure a Spring Boot microservices project with Spring Cloud dependencies, including Eureka, Feign, Hystrix, and Swagger, for a runnable microservices setup.

Explore changes to the conflict service to run multiple microservices, sync with the Git repository, and import updated projects into Spring Tool Suite while reviewing config changes.

Review spring cloud feign client and hystrix circuit breaker, showing how feign reduces code for rest calls, enables circuit breaking with fallback, and uses ribbon and eureka for load balancing.

Demonstrate Feign calls to the customer service via an interface and Hystrix fallbacks, while validating discovery and config services and performing get and create customer operations.

Demonstrates update, retrieve, and delete operations on a customer resource using Swagger as a rest client. Highlights using annotations and dependencies to enable these functions in Spring Boot microservices.

Discover how Hystrix implements circuit breaking with fallbacks to protect microservices under load, and how Feign enables declarative, load-balanced external service calls with service discovery.

Run and test the person microservice with Spring Boot and MySQL in a guided tour, executing CRUD operations via REST APIs (get all, get by id, post, put, delete).

Run the service discovery microservice using spring cloud and spring boot, demonstrating two instances and a highly available Eureka setup, and how discovery interacts with config and other microservices.

Explore how the configuration service centralizes environment-specific properties in a dedicated config repository. Test properties for microservices using profiles and update them without restarting.

Run the customer microservice in Spring Cloud and register it with service discovery using a logical name. Test APIs to list, create, retrieve, and update customer data.

Learn to run and test the customer account microservice with Spring Boot and Spring Cloud, including building, deploying, and performing create, retrieve, update, and delete operations.