Master Java Web Services and REST API with Spring Boot

Maximize learning efficiency by practicing speed watching. Set playback to 1.25x to 2x for time savings while guarding comprehension; start at 1.25x and incrementally increase.

Begin by building a tightly coupled game, then refactor to loose coupling with interfaces, and finally let the Spring framework manage objects through dependency injection and Spring beans.

Set up a new Spring Initializr project with Maven and Java, choose latest released version, specify group id and artifact id, then import the Maven project in Eclipse.

Build a tightly coupled game runner and Mario game, wiring a GameRunner to run Mario with up, down, left, and right controls via simple console output.

Analyze tight coupling in the game runner as you switch between Mario and super contract game, illustrating code changes that create coupling and hinting at reduction strategies for next step.

Implement a gaming console interface to decouple game logic from the runner, enabling Mario, Super Contract, and Pac-Man to run interchangeably through the interface.

Discover how interfaces enable loose coupling by swapping Pac-Man game implementations with a game runner, and see how Spring framework further reduces coupling in Java services.

Explore loose coupling with a gaming console interface and see how the Spring framework manages components, autowiring, and beans in an application context to run Java applications.

Explore how the Spring framework identifies candidate components, wires them via constructor autowiring, and manages beans in the background, guided by debug logs and bean configuration.

Learn how Spring uses @Component to mark classes and how component scanning discovers them across packages. Explore dependency injection, inversion of control, and how the application context manages beans.

Explore how the Spring framework adds value by auto-wiring dependencies and managing object lifecycles across web, business, and data layers in real-world enterprise apps.

Learn to resolve multiple matching beans in a Spring app by designating a single primary bean to guide autowiring, preventing no unique bean errors.

Discover how Maven downloads Spring jars and manages transitive dependencies through pom.xml, ensuring automatic dependency updates and a standard project structure with source main java and source main resources.

Explore Spring dependency injection types: constructor, setter, and field injection, and learn why constructor-based injection is recommended for reliable, fully initialized objects.

Discover Spring modules and learn to pick the right ones for your app, from the core IOC container and Spring MVC tests to reactive Web Flux and database transactions.

Explore how Spring projects evolve with changing architectures, from Spring Boot for REST APIs to Spring Cloud, Spring Data, Spring Integration, and Spring Security for secure, cloud-native Java apps.

Get a concise 10,000-foot overview of spring framework terminology, including dependency injection, autowiring, spring beans, components, IoC container, and application context.

Meet the primary instructor, Ranga Khanum, founder of in 28 minutes, with two decades of programming in Java, Python, and JavaScript, and multi-cloud certifications, guiding this Spring Boot course.

Learn why Spring Boot enables building web apps and REST APIs, compare it with Spring MVC, and explore starter projects, auto configuration, developer tools, and actuator through a REST API.

Get a 10,000-foot overview of building apps before Spring Boot, focusing on dependency management and heavy configuration. See how web.xml, dispatcher servlet setup, and logging and monitoring were handled.

Learn how to set up a new Spring Boot project using Spring Initializr, configure Maven, Java version, milestone release, and Spring Web, then import into Eclipse and run on Tomcat.

Build a simple hello world rest api with Spring Boot by exposing /courses to return a list of courses with id, name, and author via a rest controller.

Build production ready Spring Boot applications quickly using spring initialization, starter projects, auto configuration, and dev tools. Monitor memory and metrics across environments with logging, profiles, and actuator.

Explore how Spring Boot starter projects bundle web, testing, and data dependencies into convenient descriptors, simplifying setup from pom.xml and enabling embedded Tomcat, json conversion, and testing.

Explore Spring Boot auto-configuration, driven by classpath and existing settings, to auto-wire DispatcherServlet, Tomcat, error pages, and Jackson JSON converters; customize with your own config.

Boost developer productivity with Spring Boot DevTools by enabling automatic restarts on code changes; learn to configure via pom.xml and see instant tests of new features.

Explore environment specific configuration with Spring Boot profiles, creating dev and prod properties and merging them with defaults. See how active profiles control logging levels from trace to error.

Learn to manage complex app configurations with Spring Boot's configuration properties and profiles, centralizing currency service settings via a dedicated configuration class and properties.

Discover how embedded servers simplify production deployment with Spring Boot, replacing the VAR approach and enabling runnable jars with Tomcat, Jetty, or Undertow via mvn clean install.

Learn to monitor a production-ready Spring Boot app with actuator, exploring health, beans, mappings, metrics, env, and config props, and selectively exposing endpoints to manage resources.

Understand how Spring framework relies on dependency injection and component scanning, how Spring MVC targets web apps and REST APIs, and how Spring Boot enables auto configuration with starters.

Explore a 10,000-foot overview of Spring Boot, covering startup projects terminology, auto configuration, Actuator dev tools, and the advantages of production-ready features.

Stay ahead of technology changes by embracing a 28-minute daily learning pledge, practicing consistency for 28 days to make learning a lasting habit.

Explore how jars package java class files into a java archive, enabling distribution and reuse of libraries with metadata and resources, using Maven.

Understand how Maven automates dependency management and builds for Java applications, standardizing project structure and enabling automatic download of Spring MVC, Spring Core, Commons Logging, and other libraries.

Create a Spring Maven project via start.spring.io, choosing Maven, Java, and a version without snapshot. Import the project into your IDE, add Spring Boot Web MVC, and run on Tomcat.

Discover how the pom.xml defines a project's identity with groupId, artifactId, and version, and how Maven uses these to manage dependencies like Spring Boot Starter.

Discover how Maven downloads dependencies from the central repository to your local .m2 repository, caching jars and using them for your pom.xml dependencies like Spring Boot Starter Web MVC.

Explore Maven's convention over configuration by applying the folder structure—source main java, source main resources, source test java, and source test resources—and manage dependencies with pom.xml for import into projects.

Master the Maven build lifecycle by following the sequence validate, compile, test, and package, then optionally verify, install, and deploy as you run Maven commands.

Discover how spring boot starter dependencies, the parent pom, and the spring boot maven plugin form the perfect pair with maven to auto-manage dependencies, run applications, and build container images.

Understand semantic versioning in Spring Boot projects by learning major, minor, and patch increments, and how snapshot, milestone, and release candidate modifiers affect upgrade and production use.

Master Maven basics to build and share Java projects, manage dependencies and transitive libraries, and accelerate Spring Boot development with starters, plugins, and conventional project structure.

Set up a Spring Boot Gradle project from start.spring.io with Gradle Groovy, Java, and Spring Web, then import into Eclipse and review build.gradle and settings.gradle.

Explore gradle core files build.gradle and settings.gradle, using groovy syntax to define group, version. See how artifact id and project name are defined in settings.gradle, with maven central hosting dependencies.

Explore how Gradle treats every action as a task, from compiling Java code to building jar files, and learn to optimize task graphs and create custom tasks.

Compare Maven and Gradle to understand XML-based declarative configuration, Groovy or Kotlin DSL, and decide when Gradle’s incremental builds suit large projects over Maven.

Implement three soap web services to manage courses with spring web services, covering get one, get all, and delete, plus xsd, jaxb, wsdl, soap header, body, fault, and ws-security.

Initialize a Spring Boot web services project from start.spring.io using Maven and Java, add soap web services, JPA, and H2 dependencies, and run the application on Tomcat 8080.

Discover building a soap service with Spring web services using contract first design. Define xsd for requests and responses, generate wsdl, and use JAXB to map inputs to course details.

Define an XML structure for the request and response, including a get course details request with a course id and a response with id, name, and description, using a namespace.

Define an xml schema definition (xsd) for the get course details request, specifying an id as integer, attach a schema location and xsi namespace, and validate requests.

Define an XML schema for the get course details response by creating a reusable complex type course details in the tns namespace, enabling validation and future reuse.

Explore XML schema definition best practices, including using the xs prefix, defining sequences, choices, attributes, complex types, and enumerations, to map Java objects to XML for Spring web services.

Learn to map the course details XSD to Java objects using JAXB, configure the JAXB two Maven plugin, and generate Java classes to serialize and deserialize SOAP XML.

Create a Spring web services endpoint that processes the get course details request using payload annotations, mapping XML to Java via JAXB, and returning a get course details response.

Configure spring web services by enabling WS, defining a message dispatcher servlet, mapping it to the /ws/* URL, and enabling transformed WSDL definitions for future WSDL generation.

Explore spring web services' contract-first approach by defining an XSD schema and configuring to generate and expose a course WSDL at /ws/course.wsdl, enabling SOAP requests.

Explore how to use Wizdler to execute soap requests against a WSDL, inspect the get course details operation, and view request and response structures for a Spring Boot web service.

Create a simple course bean and wire an in-memory course details service in spring. Implement find by id, find all, and delete by id, with a mapper for the response.

Implement a soap web service to return all course details by defining the get all course details request and response in the XSD, creating the endpoint, and mapping course data.

Navigate the WSDL structure, including types, messages, port type, binding, and service, and see how SOAP over HTTP with document style exposes operations such as get all course details.

Implement a soap delete operation for course details by id in a Spring Boot web service, updating the XSD and endpoint. Confirm status 1 for success.

Improve the delete course details request by introducing a status enum with values success and failure, and map it consistently in xsd and the service for a clearer contract.

Learn how Spring Web Services handles exceptions and crafts SOAP fault responses, including custom exceptions, fault codes, and client versus server errors in a web service.

Implement simple security with WS security for SOAP web services, using XWSS and Spring WS Security; configure a security interceptor with a simple password callback and a username token policy.

Explore why Spring Boot enables REST API development, design resources and actions, define json request and response structures, apply best practices, and connect to databases with JPA and Hibernate.

Initialize a rest api project using spring initializer, select maven, java, and the latest spring boot version, and add web, spring data jpa, h2, and devtools dependencies.

Create a hello world rest api in Spring Boot by exposing a rest controller mapped to /hello-world with get mapping that returns hello world.

Enhance the hello world rest api by returning a hello world bean instead of a string, with a message field, getters, setters, and a constructor to produce a json response.

Explore how Spring Boot automatically configures a dispatcher servlet, Jackson HTTP message converters, and error handling through auto-configuration and starter web dependencies.

Spring Boot 4 modularizes dependencies by swapping Spring Boot Starter Web with Web MVC and introducing Web MVC Test and Data JPA Test, reducing size and startup time.

Learn how path parameters and path variables map to rest api URLs, and implement a hello world endpoint that captures a name via a path parameter.

Design a rest api for a social media app with users and posts, using get, post, put, patch, and delete, and plurals in resource urls such as /users and /users/{id}/posts.

Create a user bean with id, name, and birth date, and build a spring-managed user dao service to manage users in a static in-memory list for rest api operations.

Implement get methods for the user resource by building a Spring Boot rest controller that retrieves all users and a single user by id using path variable and service methods.

Implement a post /users to create a new user from the json request body, assign a unique ID, and save via the user service, tested with Talent API Tester.

Enhance the post method to return 201 created with a location header pointing to the newly created user, using Spring Boot's ResponseEntity and the current request url.

Implement exception handling to return 404 not found for missing users, using a user not found exception with response status, and provide a structured application/json response.

Implement a custom error details structure for all resources, via a controller advice and a customized response entity exception handler, returning consistent rest api errors with timestamps and proper status.

Implement the delete method for the user resource in the rest api by adding a delete mapping that removes a user by id and returns a 200 status.

Learn to validate rest api inputs in Spring Boot by adding starter-validation, using @Valid and Jakarta validation constraints like size and past, and customize 400 bad request responses.

Explore advanced REST API features in a Spring Boot context, including OpenAPI and Swagger documentation, content negotiation for XML and JSON, internationalization, versioning, filtering, and API monitoring.

Learn to generate up-to-date REST API documentation from code using OpenAPI specification and Swagger UI, detailing resources, actions, request and response structures, and validations.

Configure and generate swagger documentation for a spring boot REST API using SpringDoc OpenAPI, and expose the OpenAPI 3.0.1 spec and swagger UI for resources like user and hello world.

Explore content negotiation in a Spring Boot REST API, enabling XML and JSON representations for the same resource via Accept headers, with a jackson-data-format-xml dependency and a quick restart.

Implement internationalization in a Spring Boot REST API using the accept-language header and a message source to return localized greetings.

Discover how to version a REST API to manage breaking changes, using URL-based versioning with v1 and v2, and noting alternatives like parameters, headers, and mime types.

Explore rest api versioning in Spring Boot using request parameter, header, and media type approaches via content negotiation. Consider UI pollution, header misuse, caching, and a consistent enterprise versioning strategy.

Explore Spring Boot 4 inbuilt versioning and semantic versioning, implementing path, query parameter, header, and media-type based strategies configured in application.properties to serve v1 and v2.

Enable hypermedia in rest APIs with HAL links. Wrap users with an entity model and generate links via spring mvc link builder.

Learn to customize rest API responses by serializing Java objects to JSON with Jackson, rename fields using json property, and apply static filtering to hide fields via json ignore.

Implement dynamic filtering for a spring boot REST API using JSON view to return different fields per endpoint, leveraging view1 and view2 to tailor responses.

Enable Spring Boot Actuator to provide production-ready monitoring and management of your application. Explore endpoints such as health, beans, metrics, env, and mappings to observe runtime behavior.

Explore your REST API with HAL Explorer in a Spring Boot project, using HAL format to navigate links, data, and endpoints like beans, metrics, and users.

Balance hard work with regular breaks through trekking stories from India, Nepal, Switzerland, Italy, and Austria, including the Annapurna Base Camp trek and the Via Alpina, and invite Q&A participation.

Explore JPA and Hibernate with a hands-on Spring Boot project using the H2 in-memory database. Build a simple JPA app, compare JPA and Hibernate, and use Spring Data JPA.

Set up a new spring boot project for jpa and hibernate using spring initializer, maven, and the latest released version, add spring web, spring data jpa, and h2, then run.

Connect to the in-memory h2 database via the h2 console, configure a static url, and create the codes table (id, name, author) with schema.sql for spring data jpa and hibernate.

Learn spring jdbc basics by inserting, selecting, and deleting data in a course table using SQL queries in the H2 console, noting spring jdbc uses less Java code than jtbc.

Learn to insert hardcoded data at startup using Spring JDBC with JDBC template, a repository, and a command line runner, then verify results in the H2 console.

Execute basic insert and delete operations using Spring JDBC by passing course details (id, name, author) through parameterized queries, updating the H2 database and verifying changes.

Query data with spring jdbc by selecting from course and finding by id, mapping the result to the course bean with a bean property row mapper.

Learn to map Java beans to database tables with Jakarta Persistence, manage entities via EntityManager, and perform insert, find, and delete operations using JPA with transactions and show SQL.

Explore the magic of JPA by mapping entities to tables and using the entity manager to insert, find, merge, and delete, reducing sql work.

Spring Data JPA simplifies JPA by handling the entity manager in the background and exposing a repository interface for course entities with built-in methods like save and findAll.

Explore spring data jpa by querying all courses, counting entities, and adding custom finder methods like find by author and find by name in the repository.

JPA is a specification API for mapping entities and attributes, with Hibernate as a popular implementation; use JPA annotations via Spring Boot Starter Data JPA and avoid Hibernate-specific annotations.

Connect your REST API to the database using JPA and Hibernate, starting with H2 and then MySQL. Upgrade the user resource to a JPA repository backed by Hibernate.

Create a user entity managed by jpa with a generated id, rename the table to user_details to avoid h2 keyword conflicts, configure a static h2 url, and defer data.sql initialization.

Create a jpa user repository and switch rest resources to use it for database access. Retrieve all users, find by id, delete, and save new users on the h2 database.

Create a post entity and map it to a user with a one-to-many relationship, configure lazy fetch, and exclude posts from user responses using json ignore.

build a get api to fetch all posts for a user using spring boot and jpa, mapping get /users/{id}/posts, handling user not found and returning the user's posts.

Implement a post api to create a post for a user using a post repository, input validation, and RESTful mapping in Spring Boot.

Explore how the spring boot rest api connects to the database, runs jpa and hibernate queries for users and posts, and creates new posts with post_sequence generated ids.

Learn how to connect a REST API to a MySQL database using Docker, transitioning from an in-memory setup with JPA and Hibernate, with optional demos.

Discover how to install Docker Desktop on Windows, Mac, and Linux with admin access, verify the latest Docker version, and follow platform-specific troubleshooting for a smooth setup.

Launch a mysql docker container and connect your rest api to mysql, configuring application properties and mysql dialect, then verify persistence by querying user_details and post data.

Add the Spring Security starter, sign in with the generated password, configure custom credentials in application.properties, and enable authentication for all REST APIs by default.

Enable spring security for the rest api, enforce authentication with a customized security filter chain, implement http basic authentication with defaults, and disable CSRF to allow post requests.