RESTful APIs and Microservices

Overview

Udacity Diwali Sale: 10% Off All Programs

Use code DIWALI2026 at checkout for 10% off a monthly plan, bundle, or single Nanodegree. For payments in INR. Ends Nov 11.

Get 10% Off

This course dives into the essentials of web services and APIs, focusing on RESTful and GraphQL principles alongside their practical applications using Spring Boot and Spring WebFlux. Participants will design and build robust REST APIs, handle requests/responses, and apply DTO mapping. Key concepts include microservices architecture, API gateway functionality, and resilience patterns with tools like Resilience4j. The course also covers advanced topics like AI integration using the Spring AI framework, retrieval augmented generation workflows, and asynchronous messaging with Kafka. Students will gain hands-on experience in creating documentation and testing APIs for a comprehensive understanding.

Syllabus

Course Introduction — Meet the course, see how it builds from a single REST endpoint to resilient, AI-powered, event-driven microservices, and check the prerequisites and tools you'll use.
Understand REST Principles and HTTP Methods — Learn why REST organizes an API around resources rather than actions. Match HTTP methods to their meaning, and see what statelessness and idempotency buy you when the same request arrives twice.
Apply REST Design to a New API — Watch a product API map operations to resource URIs, HTTP methods, and status codes. Then design an order API with a nested items resource and a cancel action that returns the right status on success or failure.
Understand Building REST APIs with Spring Boot — Follow an HTTP request through Spring Boot, from routing to the controller method that handles it to the JSON response. See how request and response bodies are converted and how declarative HTTP clients call other services.
Apply Spring Boot to Build a REST API — See controllers, API versioning, and HTTP interfaces at work in a Spring Boot product API. Then build an order API with CRUD endpoints, header-based versioning, and a declarative client that fetches customer details.
Understand Request/Response Handling and DTOs — Learn why exposing entities directly makes an API fragile and insecure. See how Java records make clean DTOs, and weigh hand-written mapping against generated mappers.
Apply DTO Mapping with MapStruct — See MapStruct generate the mapping between product entities and DTOs. Then refactor an order API to use validated request and response records, with mappers generated at build time.
Understand Error Handling and Problem Details — See why inconsistent error formats burden every client. Learn the RFC 9457 Problem Details standard and how @ControllerAdvice produces it from one central place without exposing internals.
Apply Standardized Error Responses — Watch a global handler turn exceptions into standard Problem Details responses. Then build one for an order API that returns a clean 404, per-field 400 validation errors, and a safe 500.
Understand Reactive Programming with Spring WebFlux — Compare thread-per-request with the reactive event loop and see where each breaks down. Meet Mono, Flux, and backpressure, and weigh WebFlux against Java's virtual threads.
Apply Reactive APIs with Spring WebFlux — See a WebFlux endpoint avoid the thread exhaustion of a blocking one. Then rewrite a stalled dashboard API with Mono, Flux, and WebClient, and stream live updates with Server-Sent Events.
Understand GraphQL Fundamentals — Learn how GraphQL's schema and resolvers let a client ask for exactly the data it needs in one request. See where the N+1 performance trap hides and when REST remains the better fit.
Apply GraphQL with Spring for GraphQL — See products served through Spring for GraphQL schema mappings. Then build a GraphQL API for orders with queries, a mutation, and batch loading that fixes the N+1 problem.
Understand Microservices Architecture Principles — Weigh a monolith against microservices on the terms that matter: team independence, scaling, and operational cost. Learn to draw service boundaries that give real independence instead of a distributed tangle.
Apply Microservices Decomposition — Watch a monolith split into independently deployable services. Then identify bounded contexts and data ownership, and extract order and inventory services that communicate over HTTP.
Understand API Gateway and Service Discovery — Learn how an API gateway gives clients one way in and handles cross-cutting concerns. See how a service registry tracks live instances and how client-side load balancing works in Spring Cloud.
Apply API Gateway and Service Discovery — See Spring Cloud Gateway and a Eureka registry route traffic through a logging filter. Then set up both yourself, routing requests by service name and load-balancing them across two instances.
Understand Circuit Breaker and Resilience Patterns — See how one slow dependency can cascade into a full outage. Learn how circuit breakers, retries with backoff, and bulkheads contain failures so a partial outage degrades gracefully.
Apply Resilience with Resilience4j — Watch a circuit breaker and fallback protect a client from a failing inventory service. Then harden a flaky payment call with retry and exponential backoff, a circuit breaker, and a fallback.
Understand Spring AI Framework — Explore Spring AI's core abstractions for building on large language models. See how one client works across providers, how structured output returns typed objects, and how tools let a model call your services.
Apply Spring AI to Build an LLM-Powered Feature — See Spring AI's ChatClient send system and user prompts to a model. Then build a review-analysis feature that turns raw reviews into a typed summary with a title, key points, and sentiment.
Understand LangChain4j for Java — Learn how LangChain4j turns an annotated Java interface into a working AI service. Compare its declarative approach with Spring AI's builder style, including how each handles memory and tool calling.
Apply LangChain4j to Build an Agent — See a LangChain4j agent call local Java methods as tools. Then build a travel assistant with a persona, multi-turn memory, and tools that look up flights and weather.
Tokens, Embeddings, and Vector Search — Covers the foundations of NLP for LLMs. Defines tokenization, embeddings as semantic vectors, and vector search (similarity search) as the basis for finding relevant information.
Retrieval Augmented Generation (RAG) Workflow — Introduces the RAG architecture. Compares naive vs. advanced modular RAG. Covers the data ingestion pipeline, focusing on data formats and intelligent chunking strategies.
Semantic Search with Vector Databases for RAG — Explains semantic search and the role of vector databases. Covers indexing algorithms (HNSW) for speed and advanced retrieval techniques like HyDE and re-ranking.
Apply Semantic Search with Vector Databases — See embeddings and similarity search find documents by meaning rather than keywords. Then build an FAQ search that chunks and embeds entries into a vector store and returns the closest matches for a question.
Apply RAG to Build a Knowledge Base Q&A System — Watch Spring AI's QuestionAnswerAdvisor ground a model's answers in retrieved documents. Then build a support Q&A system over a product manual that cites its sources and says when it doesn't know.
Understand Asynchronous Messaging Systems — See why synchronous call chains break down and how asynchronous messaging decouples services. Compare message brokers like RabbitMQ with event logs like Kafka, and choose the model that fits your data.
Apply Asynchronous Messaging with Kafka — See Kafka listeners retry failed messages and route them to a dead-letter topic. Then decouple an order pipeline with Kafka events, independent consumer groups, and retry with dead-letter handling.
Understand Event Sourcing and CQRS — Learn how event sourcing keeps an append-only log of every change and rebuilds state by replaying it. See how CQRS separates read and write models and how sagas coordinate work across services.
Apply Event Sourcing and CQRS — See a CQRS system keep separate write and read models for products. Then build an event-sourced order with command handlers, a read model projected from its events, and a saga with a compensating step.
Understand API Documentation and Testing — Learn how the OpenAPI specification describes an API and how Spring generates it from your controllers. Explore the testing pyramid and which layer catches which kind of bug.
Apply OpenAPI Documentation and REST Testing — See Springdoc generate interactive Swagger UI docs from a controller. Then document an order API with endpoint summaries and examples, and test it with MockMvc slice tests and a full integration test.
Course Outro — Look back on what you've built, from clean REST endpoints to resilient, AI-powered, event-driven microservices, and see how these skills carry into your next project.
AI-Powered Automated RMA (Return Merchandise) Engine — Build an AI-powered engine that approves or denies product returns, using Spring AI with RAG, Resilience4j, Kafka events, and a GraphQL read model for the dashboard.