Modern Java Web Development

Meet the course, see what you'll build with Spring Boot, and check the Java background you'll need. Every exercise and the project run in a ready-to-use Udacity workspace.

Learn Spring Core concepts, including Inversion of Control and Dependency Injection patterns, and how to configure beans using annotations, Java config, and XML.

Watch Spring choose between several repository beans in a product catalog. Then refactor a notification service to use constructor injection, `@Primary`, and `@Qualifier` so it stays loosely coupled.

Explore Spring bean lifecycle phases and scopes, including lifecycle callbacks, singleton, prototype, web scopes, and how instance sharing and cleanup responsibilities differ.

Explore a booking system that mixes shared, per-use, and per-request beans. Then build a checkout app with lifecycle callbacks, prototype lookups through a provider, and request-scoped state.

Explore Spring Boot fundamentals: how starter dependencies drive auto-configuration, the back-off model, Boot 4 modularization, and tools for diagnostics and rapid development.

See Boot 4 modular starters, auto-configuration, and DevTools at work in a weather service. Then build a bookmark service with an HTTP endpoint, profile-specific settings, a custom banner, and selectively exposed Actuator endpoints.

Learn how Spring Boot externalizes configuration, manages precedence, uses @Value for single values, @ConfigurationProperties for groups, and supports profiles and validation for reliable setups.

Bind nested, validated settings into a typed configuration class for a notification service. Then configure a payment service whose credentials, retry policy, and currencies vary across dev, staging, and prod profiles.

Follow the flow of an HTTP request in Spring MVC, from DispatcherServlet to controller and view, understanding each component's role in handling and rendering responses.

Explore an event-registration site built with Spring MVC handlers. Then build a product catalog controller covering listing, filtering, path variables, form binding, and post-redirect-get with flash messages.

Learn how Spring MVC binds form data to Java objects, applies validation rules, and uses BindingResult for handling and displaying user input errors effectively.

Validate a job application form with built-in, repository-backed, and cross-field rules. Then build a registration form with your own custom constraints and field-level error messages.

Learn server-side rendering with Thymeleaf: natural templates, expressions, iteration, conditions, and fragments, plus when to choose SSR over client-side rendering in Spring Boot.

See reusable fragments, iteration, and conditionals power a museum exhibition site. Then convert a static product catalog into data-driven Thymeleaf pages that share one header, navigation bar, and footer.

Learn how Spring centralizes exception handling, using @ExceptionHandler and @ControllerAdvice to ensure consistent, secure error responses in web applications.

Map an exception hierarchy to custom error views and status codes in a URL shortener. Then build a global handler for an order store that links each error page to its log entry with a correlation ID.

Explore how Spring Boot Actuator provides operational visibility with controlled endpoints, health checks, security, and integration with monitoring tools like Prometheus.

See a roast-monitoring app expose selected Actuator endpoints behind an operator role. Then secure an inventory service's monitoring endpoints with HTTP Basic, and add custom health and info contributors.

Learn how Spring AOP separates cross-cutting concerns, applies advice using proxies, defines key AOP terms, and configures pointcuts for cleaner business code.

See a library loan desk use Spring AOP for logging, timing, and policy checks. Then add service-wide logging and annotation-driven performance monitoring to a storefront without changing its business methods.

Learn Spring Expression Language (SpEL) to build dynamic logic, query data, use variables, collections, and ensure safe evaluation in Spring applications.

See SpEL evaluated against beans, method calls, and the security context in a recipe app. Then use it in a document vault for a computed storage path, selective caching, and an owner-or-admin delete rule.

Meet the course, see how you'll progress from raw JDBC to JPA, Hibernate, and Spring Data JPA on PostgreSQL, and check the tools and Java background you'll need.

See how Java talks to a database through JDBC, why opening connections is costly, and how a pooled DataSource, prepared statements, and batching keep apps fast and safe.

Watch a concert tracker use raw JDBC with HikariCP, then build a customer repository and benchmark how pool size affects throughput under concurrent load.

Learn how JPA tracks objects in the persistence context, the four entity states and the EntityManager calls that move between them, and how id strategies shape SQL timing.

Follow a pilot roster through every JPA lifecycle state, then map Customer and Order entities and trace when IDENTITY and SEQUENCE ids fire each INSERT.

Understand @OneToOne and @ManyToOne mappings: owning versus inverse sides, why LAZY fetching should be your default, and how cascades and orphan removal behave.

See single-valued mappings in a vet clinic, then map a shared-key User and UserProfile and a lazy Order-to-Customer link, and fix the N+1 queries lazy loading can cause.

Understand @OneToMany and @ManyToMany: which side owns the foreign key, keeping bidirectional collections in sync, and when a join table should become its own entity.

Map albums, tracks, and artists in a demo, then build a BlogPost-Comment one-to-many with orphan removal and a Student-Course many-to-many through an Enrollment entity.

Map rich Java models onto flat tables with embeddables, element collections, inheritance strategies, composite keys, enum mapping, and attribute converters.

Explore embeddables, element collections, and a Money converter in a restaurant menu, then map Address, a JOINED Payment hierarchy, and Money for an order system.

Compare Hibernate's first-level and second-level caches, cache regions, concurrency strategies, and the query cache, and learn when caching risks serving stale data.

Cache a country dataset and read Hibernate's statistics, then enable the second-level cache on a product catalog and benchmark the drop in database queries.

Learn how the N+1 problem arises and how to spot it in logs and statistics, then compare JOIN FETCH, entity graphs, @BatchSize, and DTO projections as fixes.

Reproduce N+1 in a library demo, then fix a blog's lazy comments three ways, with JOIN FETCH, @EntityGraph, and @BatchSize, and compare the query counts.

Compare JPQL and the Criteria API: parameters, joins, and DTO projections in JPQL, and type-safe, dynamic queries built with CriteriaBuilder and predicates.

Query a product catalog with both JPQL and Criteria, then write a top-customers JPQL report and a dynamic Criteria order search driven by optional filters.

Learn when to drop to native SQL, how to map native results into typed DTOs, and why keyset pagination outperforms offset paging on large tables.

See native SQL and offset versus keyset paging on a news catalog, then build a monthly revenue report with PostgreSQL date_trunc and keyset-paginate a product list.

Explore Spring Data JPA repositories: choosing a base interface, derived query methods, @Query, projections, Specifications, and custom repository fragments.

Grow a task tracker's repository from derived methods to JPQL, native SQL, and paging, then query a product catalog four ways, ending with dynamic Specifications.

Take @Transactional apart: how Spring's proxy manages transactions, the self-invocation trap, propagation types, isolation levels, and rollback rules.

Watch a bank transfer commit, roll back, and audit with REQUIRES_NEW, then build an atomic placeOrder service whose audit record survives a rollback.

Understand lost updates and other concurrency anomalies, and compare optimistic locking with @Version against pessimistic row locks, including SKIP LOCKED.

Race two workers on one inventory row under each lock type, then protect a book inventory with @Version and retries, plus PESSIMISTIC_WRITE for the last copy.

Look back on everything you've built, from pooled JDBC connections to concurrency-safe persistence with JPA, Hibernate, and Spring Data JPA.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Introduces the RAG architecture. Compares naive vs. advanced modular RAG. Covers the data ingestion pipeline, focusing on data formats and intelligent chunking strategies.

Explains semantic search and the role of vector databases. Covers indexing algorithms (HNSW) for speed and advanced retrieval techniques like HyDE and re-ranking.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Explore the Spring Security 7 filter chain, the lambda-only configuration DSL, and the moving parts of the authentication and authorization model.

Configure a custom UserDetailsService backed by a database and define a Spring Security 7 SecurityFilterChain using the lambda-only DSL.

Explore the authentication options Spring Security 7 supports and when each is appropriate, including passkeys as a modern passwordless option.

Implement form-based authentication with custom success/failure handlers and remember-me support using the Spring Security 7 lambda DSL.

Explore the authorization models Spring Security 7 supports and the distinction between roles and authorities.

Implement layered authorization combining URL-based and method-based rules for a multi-role application using Spring Security 7.

Explore the OAuth2.1 framework, OpenID Connect, and JSON Web Tokens as the foundation of modern API security — including updates in Spring Security 7 such as PKCE-by-default.

Configure a Spring Boot 4 REST API as an OAuth2 resource server validating JWTs with scope-based access control using Spring Security 7.

Explore the browser-level threats that target web applications and the mechanisms that mitigate them — including Spring Security 7's hardened defaults.

Configure CORS for a single-page app frontend and harden an API with a strong set of modern security headers using the Spring Security 7 lambda DSL.

Explore the OWASP Top 10 and the secure-coding practices that prevent the most common web vulnerabilities.

Audit a vulnerable Spring Boot 4 application and fix issues across several OWASP Top 10 categories.

Explore approaches to externalizing secrets and the trade-offs between local, cloud-provider, and dedicated secret stores.

Externalize application secrets into Vault and configure Spring Boot 4 to load them at startup.

Explore centralized configuration strategies and basic observability patterns for distributed systems.

Stand up a Spring Cloud Config server backed by a Git repository and wire multiple services to consume it.

Explore modern logging frameworks and how Spring Boot 4's built-in structured logging changes the approach for distributed systems.

Configure Spring Boot 4's built-in structured logging with MDC-propagated correlation IDs and W3C Trace Context across services.

Explore how logs from distributed systems are aggregated, indexed, and searched.

Ship application logs to an Elasticsearch cluster and build Kibana dashboards and alerts.

Explore metrics, observability, and SLO-driven monitoring for Spring Boot 4 applications, with OpenTelemetry as the unifying standard.

Expose application metrics and traces via OpenTelemetry and build Grafana dashboards with SLO-based alerts for a Spring Boot 4 service.

Explore container concepts and how they change the packaging and deployment of Java applications.

Write an optimized multi-stage Dockerfile and compose a Spring Boot 4 app with its dependencies.

Explore Kubernetes at a working level as one common deployment target for containerized Spring Boot 4 services (alongside VMs and managed PaaS).

Deploy a Spring Boot 4 service to a local Kubernetes cluster with ConfigMaps, Secrets, and health probes as one of several viable deployment paths.

Explore the principles of continuous integration and deployment and the pipeline-as-code model, with Jenkins as the primary focus and other tools as alternatives.

Build a complete Jenkins declarative pipeline for a Spring Boot 4 app covering build, test, security scan, image publish, and deploy.

Explore the deployment strategies that enable zero-downtime releases and the operational concerns that come with them, orchestrated through Jenkins.

Implement a Jenkins-orchestrated blue-green deployment with Flyway migrations that remain backward-compatible.

Explore Infrastructure as Code at a working level and go deep on the JVM and application performance-tuning techniques that matter for Spring Boot 4 in production.

Profile a Spring Boot 4 application on JDK 25 to identify and fix a performance bottleneck, with a brief Terraform touchpoint for environment provisioning.