2024 Beginner's Full Stack Microservices [Spring Boot 3.x]

Explore microservices as an architectural pattern of isolated, loosely coupled, independently deployable services, and weigh benefits like independent deployment and simpler continuous integration and delivery against complexity and testing challenges.

Functional decomposition is at the core of microservices and helps define the application's architecture by breaking the system into business functions and subdomains.

Understand the business by gathering requirements with domain experts, then define services and subdomains, outline initial APIs and interactions, and prototype or create a POC to validate architecture.

Identify domain experts and stakeholders, gather requirements, and outline high-level service operations such as creating and approving talent acquisition requests and posting jobs in the career portal.

Decompose services into subdomains using domain driven design, covering strategic and tactical design to craft a bounded context, ubiquitous language, and domain model for talent acquisition.

Define a bounded context with a ubiquitous language to unify meaning. Learn how talent acquisition management submits, approves, and publishes to the career portal within the core domain.

Explain how subdomains form bounded contexts in a microservices architecture, mapping core, supporting, and generic domains to services like talent requests, talent fulfillment, and the career portal.

Design and create three autonomous microservices with independent databases, a service registry and api gateway, guided by a DDD analysis, and connect them through a react uat app.

Open all five microservices in IntelliJ and load them as modules. Run each microservice from the services tool window while acknowledging required discovery service configuration and Lombok warnings.

Configure the Thames discovery service by enabling Eureka server, setting port 8761, and registering microservices via IP addresses so the api gateway can locate services through the service registry.

Register microservices with the discovery server (Eureka) by configuring each app's properties and enabling discovery, start the discovery service first, and assign unique ports so all three register.

Configure the Spring Cloud API Gateway to route requests to microservices via the discovery service, turning it into a centralized entry point and load balancer for external consumers.

Use Postman to send get requests to microservices directly and via the API gateway, validate routing through the service registry to the correct service and port.

Enable basic load balancing by configuring the Spring Cloud API gateway to discover services, run multiple instances with dynamic ports (server.port=0), and assign unique instance IDs for reliable routing.

Define the initial APIs and service interactions for your microservices and build a prototype to implement the core logic, validating the architecture with the API gateway and service discovery.

Define initial APIs and service interactions among talent request, talent fulfillment, and career portal microservices, guiding data flow with events, commands, and bounded contexts for post-approval job creation.

Learn to build a talent request service with event-driven microservices, using event sourcing and CQRS via the axiom framework, including the read model and bounded contexts.

Learn to use the Axon framework to implement domain driven design, event sourcing, and CQRS, and set up the Axon server for practical microservices development.

Learn to add Axon framework dependencies to Spring Boot microservices with Maven, including Guava and server connector, configure pom.xml, run the Axon server, and verify microservices in the overview.

The P.I.C.C. method from Fullstack Basics guides you to pause, implement, and compare code with the article and screen, then understand the code before proceeding, reducing errors.

Create four packages for the talent request service: command, core, query, and saga, with their subpackages, initialize the service app, and note saga may be named process manager.

Evaluate whether to use a shared library to share bounded context data between the talent request and talent fulfillment services, weighing autonomy against data transfer via events.

Explore the talent request aggregate within a microservices flow, implementing post and get endpoints, command and query handlers, and event-driven messaging to publish talent request events to the event store.

Implement command handler and event sourcing handler in the talent request aggregate, dispatch the talent request created event to the event store, and test the flow with Postman.

Review the cqrs and event sourcing architecture and implement the event handler to update the read database, configuring h2 persistence and mapping the talent request entity.

Implement find all talent requests and find by id queries via a talent request query controller and service, routing through the query gateway to fetch data from the repository.

Implement the find talent request by talent request id query in the talent request service, wiring the query, handler, and repository to fetch by id and map to a DTO.

Publish the talent request created event and drive it via a saga process manager to create a talent fulfillment command.

Orchestrate a saga across talent request and talent fulfillment services, using a process manager to start, associate, and publish a create talent fulfillment command via an event-driven Axon flow.

Implement the find talent fulfillment and talent fulfillment by id queries, wire them through a controller and query handlers to a rest api, returning results from the talent fulfillment db.

Implement and test the talent fulfillment service by building DTOs, queries, a service layer, and controllers, then verify get and post operations via the API gateway.

Finish implementing the talent request saga by updating the request status from open to assigned to using the talent fulfillment created event via the command bus.

Implement pre-work for the second saga by validating the happy path of talent fulfillment approvals, including role level and employment type, which triggers a job post in the career portal.

Learn how the career portal service handles the create job post command and the job post created event, persisting in the event store and updating talent request status to approved.

implement the job post creation saga in the talent fulfillment service by wiring the command gateway and handling talent fulfillment decision submitted and job post created events.

Implement the career portal service query layer to view all job posts and by id, including the query controller, dto, queries, query handler, and query service.

This lecture introduces React as a JavaScript library for building user interfaces with reusable components and covers frontend basics, JSX, functional versus class components, and setup with Create React App.

Install NodeJS and verify with node -v to set up your environment. Configure Visual Studio Code with essential extensions for React and Redux and enable Chrome extensions.

Create a react app with the redux template and name Thames-uat-front-end-react. Install react-router-dom, axios, react-icons, and react-modal, clean boilerplate, and run on localhost:3000.

Delete unused counter code and set up a React app with a Thames Home page, Redux store, and router, plus a header linking to home, hiring manager, and career portal.

Create home pages for three portals and wire up routes in a React app, setting up portal home components, imports, and app.js routes for hiring manager, career, and talent fulfillment.

Learn to build the create talent request form inside the hiring managers portal, configure routing, and manage form state for title, job description, responsibilities, qualifications, candidate skills, and start date.

Implement onChange handlers for the create talent request form using useState to capture user input, including nested fields like job description and candidate skills, and test via npm start.

Implement a react talent request form that handles submit with an onSubmit function, prevents default, logs the talent request JSON, and wires submission to the Spring Boot backend for testing.

Wire the talent request form in react to send JSON to the api gateway, and manage initial state with a redux toolkit slice and extra reducers.

Implement the create talent requests async thunk and wire the form to the talent request slice using useDispatch and useSelector, testing data flow with console logs.

Wires the talent request feature end-to-end, implementing the Create Talent Request function with Axios, connects to the API gateway, handles loading and errors, and resolves CORS issues for backend integration.

implement useEffect to handle errors during talent request submission, show toast errors on failure, and reset state to enable retries, while redirecting to the updated talent requests view after success.

Extend the create talent request form to navigate to the talent requests list on success, reset the form, and manage state with an effect.

Learn to view all talent requests by loading the back end data into the frontend state using the get all talent requests operation and Redux reducers.

Learn to display all talent requests in a React app by building a talent request item component, wiring routing links, and mapping backend data with start date and status formatting.

Implement a talent request by id view in a React frontend, wiring a get talent request by id API call with loading, error handling, and a routed detail page.

Learn to implement and view all talent fulfillment requests, with a talent fulfillment service, a Redux slice, and routes to test end-to-end viewing and approving.

View and approve a talent fulfillment request by id across the talent fulfillment, talent request, and career portal microservices, ensuring the job post is created via the front-end saga.

Set up the home page with three portals—hiring managers, talent fulfillment, and careers—and manage talent requests and job openings within the career portal.