Spring Boot 4 REST APIs: Building Modern REST APIs

Build a books project with spring boot rest and swagger to explore api endpoints. Learn crud operations using post, get, put, and delete for a six-book list.

Set up a Spring Boot 3.x project using Spring Initializer with Maven, Java, and Spring Web, then download, unzip, open in IntelliJ, and install dependencies with Maven.

Create a spring boot project from scratch using the spring initializer at start.spring.io, selecting maven, java, the latest spring boot version, and the spring web dependency for restful APIs.

Create a Spring Boot REST endpoint using a controller with @RestController and @GetMapping for /api endpoint that returns Hello Eric; run with mvnw spring-boot:run.

Create your first rest endpoint in spring boot by implementing a rest controller with a get mapping that returns hello Eric at the root path, or under /api.

Learn how Spring Boot 3 uses Jackson for JSON data binding, converting JSON to a Java POJO with setters and POJO to JSON with getters in REST controllers.

Create a Spring rest service for the books project that exposes get /api/books and returns a json list of book pojos (title, author, category) via Spring Boot and Jackson.

Create a book entity with title, author, and category, initialize a sample list in memory, and expose a REST endpoint at /api/books that returns the six books in JSON.

Set up Swagger and swagger ui to design, document, and call rest endpoints in Spring Boot. Redirect the ui to docs for easier access and test endpoints like /books.

install and configure swagger using spring doc open api to document the /api/books endpoint and expose interactive docs at /docs.

Master path variables in spring boot rest, distinguishing static and dynamic parameters through endpoints like /api/books/{id} or /api/books/{title}, and retrieve by index or title using loops or streams.

Learn how Spring Boot uses the @PathVariable annotation to fetch a book by title via /api/books/{title}, matching titles case-insensitively and returning null if not found.

Enhance a rest endpoint by using a path variable title with java streams and lambdas to filter books, perform a case-insensitive title match, return the first match or null.

Explore how Spring Boot REST handles query parameters to filter data, using optional request parameters, @RequestParam, and case-insensitive streaming to filter books by category.

Master using optional query parameters, or request parameters in Spring Boot, to filter the books API by category and return all books when no parameter is provided.

Stream and filter books by an optional category query parameter in Spring Boot REST, returning a list or all books when the parameter is null, using equals ignore case.

Use path parameters to identify specific resources when location and identity are critical. Use query parameters and path parameters together to refine endpoints, like /books/1?category=math.

Learn to use the POST method to create books via a request body in Spring Boot, converting JSON to a Java Pojo with Jackson and preventing duplicate titles.

Create a post request to add a unique book using a request body at /api/books, validating titles before appending to the in-memory list, with swagger UI demonstration.

Use streams to implement a Spring Boot REST POST that checks for existing book titles with noneMatch and adds a new book when none match.

Use put requests to update data in a spring boot rest api by sending an updated book in the body and matching on the original title as a path variable.

Shows how to implement a put request to update a book in Spring Boot, using a for loop with a path variable and request body, and return 200 in swagger.

Learn how to implement the delete http request in Spring Boot by mapping a delete endpoint to /api/books/{title} and removing a matching book from the in-memory list.

Implement a delete mapping in Spring Boot REST, using a path variable to identify and remove a book by title, then verify a 200 response and confirm removal.

Add a class-level request mapping for /api/books to automatically apply the base path to get, post, put, and delete endpoints, reducing repetition and centralizing endpoint values.

Define a Spring Boot REST API base path /api/books with request mapping, then implement get, post, put, and delete endpoints using path variables and query parameters to manage books.

Continue building book API endpoints in Spring Boot REST by adding data validation, exception handling, status codes, swagger configuration, and Java request objects, while deepening CRUD operations.

Enhance the book model by adding a long id and a rating, and implement their getters and setters. Update the constructor and initialize enhanced books with new titles, authors, categories.

Upgrade the books project to include a primary key id and rating, update the book entity and controller, and seed six books with unique ids and revised details.

Switch api endpoints to use the book id as the unique identifier, updating get, put, and delete mappings to match and filter by id rather than title.

Enhance rest endpoints by switching from title-based lookups to id-based fetch, update, and delete operations, and test in-memory data behavior to ensure unique identifiers.

Define and implement a book request object (DTO) to capture and validate incoming http data, replacing direct entity handling with a dedicated book request and conversion to a book.

Introduce a BookRequest DTO to remove client-provided IDs, let the server generate IDs, and convert post requests into the book source of truth.

Implement a reusable convert-to-book function in a Spring Boot REST API, simplify post creation with an ID assignment, convert requests to books, and update the in-memory list.

Enhance a Spring Boot PUT endpoint by consuming a book request, converting it with the path variable id, and updating the existing book.

Enhance spring boot rest put by updating a book with a book request dto and an id path variable, converting to a book, and validating title, author, category, and rating.

Explore data validation in Spring Boot REST APIs, applying Jakarta validation constraints to path variables and book request objects, using at min, at max, and at size to ensure input.

Add path variable data validation in spring boot REST APIs using @Min(1) to ensure IDs are at least one across get, put, and delete endpoints, improving efficiency and error handling.

Apply Jakarta validation to the book request using @Min and @Max for rating (1-5) and @Size for title, author, and category, then apply @Valid in create and update endpoints.

Explicitly set HTTP status codes with @ResponseStatus for controller methods and exceptions in Spring Boot REST APIs, returning 404 for not found and 201 for created.

Learn to explicitly control API responses with Spring Boot's @ResponseStatus by returning 200 for fetch, 201 created for new resources, and 204 no content for deletes, updates, and void responses.

Add swagger tag and operation annotations to clarify endpoint purposes and parameter needs, creating cleaner, self-documenting APIs in the swagger UI. Example endpoints like get all books and get book by title illustrate how descriptions guide developers.

Add swagger tags and operations to clarify a Spring Boot rest application programming interface, with class tag and endpoint summaries for get all, get by id, create, update, and delete.

Learn how to document Spring Boot REST endpoints with Swagger by adding parameter descriptions for path variables and query parameters, including get all books, get by ID, update, and delete.

Learn to implement spring rest exception handling by returning a json error when a book is not found, including status, timestamp, and a descriptive message.

Provide a robust exception handling approach in Spring Boot REST APIs by returning a structured error response with status, message, and timestamp when a book is not found.

Implement a new book not found exception and a book error response, returning a 404 via a response entity and exception handler when a book ID is not found.

Enhance Spring Boot REST by implementing consistent book not found handling across get, put, and delete, return the updated book, and customize validation error responses.

override the global exception handler to return a unified book error response for all non-not-found errors with a 400 status and timestamp, masking sensitive messages.

Implement a global exception handler with spring rest controller advice to centralize and reuse error handling across controllers, intercepting all exceptions and returning JSON error responses in an aop-based approach.

Implement global exception handling with a controller advice to share exception handlers across all controllers in a Spring Boot REST API, enabling reusable book not found and invalid request responses.

Switch focus to employees and build project three with sql databases, authentication, authorization, and password hashing, using a secured rest controller–service–dao architecture backed by spring boot security.

Build a real-time Spring Boot REST API for an employee directory, connecting controller, service, and DAO to a database with CRUD endpoints to list, retrieve, add, update, and delete employees.

Create a spring boot project using spring initializer, configure maven, java, dependencies, and metadata, then unzip the downloaded zip and open it in IntelliJ to download dependencies with Maven.

Create a new Spring Boot project via Spring Initializer, switch to Maven, choose Java, and set group id com.decode.spring boot and artifact employees. Add dependencies Spring Web, Spring Data JPA, H2, and Spring Boot DevTools, unzip and move the project into your directory, then open it in your IDE.

Configure IntelliJ community edition to enable auto reload by turning on build project automatically and enabling compiler first for seamless auto build with Spring Boot dev tools.

Configure a file-based H2 database in a Spring Boot project using application.properties, enable the H2 console, and map an employee entity to the table with @Column for camel-to-snake alignment.

Learn to set up an H2 database for a Spring Boot REST API, configure data source properties, enable the H2 console, and initialize a sample employee table with seed data.

Create a Jakarta persistence entity with id, first_name, last_name, and email, and generate constructors, getters, setters, and a toString.

Define a DAO interface and a JPA implementation in Spring Boot, wire with constructor injection to the entity manager, and expose a REST endpoint that fetches all employees.

define a dao interface for employees and implement it with a Spring repository using an entity manager, constructor injection, and a typed query to fetch all records.

Create a Spring Boot rest controller for employees, map to api/employees, wire the employee dao via constructor, and expose a find all endpoint backed by an in-memory h2 database.

Refactor your rest api to a service layer that implements the service facade design pattern, wiring the rest controller to a service delegating to employee, skills, and payroll daos.

Create an employee service interface and implementation, inject the employee dao via constructor, and annotate with @Service; have the rest controller use the service to return all employees at /employees.

Implement employee crud by elevating transactional boundaries to the service layer, remove @Transactional from the dao, and use the entity manager for find by id, merge, and delete operations.

Enhance the employee dao to save, update, and fetch by id, and to delete by id using the entity manager; apply transactional concepts in the service layer.

Implement the service layer for CRUD operations on employees—get list, get by id, add, update, and delete—using an employee request with validation and a convert-to-employee method.

Enhance the service layer by integrating DAO operations—find by ID, save, and delete by ID—adding an employee request and converting requests to employee entities with create or update logic.

Implement Swagger in a Spring Boot REST API, document and call endpoints from the app, expose Swagger UI at /docs, and add data validation for employee requests.

Add the data validation library and OpenAPI for Swagger, configure Swagger UI at /docs, and apply Jakarta validation annotations (@NotBlank, @Size, @Email) to employee request fields.

Create a get by id endpoint in the Spring Boot REST controller to return a single employee by id at /api/employees/{id}, including id, first name, last name, and email.

Enhance the Spring Boot REST controller by wiring new service and DAO layers, adding swagger tags, and implementing get endpoints to fetch all employees and a single employee by id.

Implement a spring boot rest post controller to create employees, validate requests, map input to an employee entity, return http created, and configure json headers via swagger.

Implement put and delete endpoints in a spring boot rest API, using an employee request with validation to update and delete by id with confirmation.

Implement create and update operations for employees in a spring boot rest api using post and put mappings, request validation, and a service layer to persist changes.

Implement a delete endpoint for employees using a delete mapping, validating the id, returning no content, and invoking the service to delete by id, demonstrating complete CRUD with best practices.

Learn how Spring Data JPA replaces boilerplate DAOs with a JPA repository interface, enabling automatic CRUD operations for any entity with no implementation class.

Learn how to switch to a JPA repository in a Spring Boot REST API, enabling out-of-the-box CRUD with an H2 database, including handling optional results and not-found errors.

Run the app and verify the JPA repository by performing CRUD operations on employees. Fetch all IDs, update, create, and delete records to confirm the API behaves as expected.

Secure Spring Boot rest APIs with users and roles and protected URLs. Implement authentication and authorization, and store usernames and passwords in a database, plain or encrypted.

Set up spring security by adding the spring boot starter security dependency and enabling basic authentication for endpoints like /api/employees; override credentials in application.properties with spring.security.user.name and spring.security.user.password.

Set up spring security by defining in-memory users with ids, passwords, and roles (John: employee, Mary: employee and manager, Susan: employee, manager, admin), using no op and bcrypt.

Configure spring boot rest security with an in-memory user details manager. Create John, Mary, and Susan with role-based access and observe cookie sessions.

Authorize access to spring boot rest endpoints using request matchers and role-based rules. Configure HTTP security, role checks for employee, manager, and admin, and disable CSRF for stateless REST APIs.

Configure a security filter chain to enforce role-based access on API endpoints using request matchers for employee, manager, and admin, with swagger endpoints open and CSRF disabled.

Enable basic authentication within swagger to test Spring Boot rest endpoints, disable browser basic auth, and configure a Swagger config with an authentication entry point and OpenAPI security.

Learn to secure Spring Boot REST with swagger by disabling browser basic authentication, implementing a custom authentication entry point, and configuring swagger’s HTTP basic security.

Configure spring security to re-enable access to the H2 console by permitting get and post on the H2 path and disabling frame options, restoring access after request matcher changes.

Configure spring security to allow access to the h2 console by adding get and post request matchers and disabling frame options via http headers, ensuring swagger-based authentication remains intact.

Enable jdbc authentication in spring security with an h2 database by creating users and authorities tables, populating them with John, Mary, and Susan, and wiring a jdbc user details manager.

Add jdbc-backed users and authorities tables to enable authentication with a database, and switch to a jdbc user details manager for role-based access (employee, manager, admin) via Spring Boot security.

Learn how Spring Security uses bcrypt to securely hash passwords with salt. The video shows a bcrypt password demo and how to implement bcrypt in your project.

Learn how Spring Security uses bcrypt for password encoding, adjust the password column to 68 chars, and implement a login flow with bcrypt-encoded passwords stored in an H2 database.

Demonstrates securing passwords in a Spring Boot REST app by converting plain text to bcrypt hashes. Shows bcrypt verification with Spring Security and Swagger, that bcrypt hashes cannot be reversed.

Explore how to customize Spring Security tables by mapping to your own members and roles, update the security configuration, and write queries to fetch users and their roles.

Drop and recreate system users and roles, seed John, Mary, and Susan with the password 123, and prepare to customize Spring Boot to work with the new tables.

Customize spring security by mapping system users and roles to authorities using a jdbc user details manager, defining queries for users and authorities, and updating configurations to reflect system tables.

Build a real time Spring Boot REST API connected to a professional MySQL database, implementing JDBC authentication, admin roles, and secure user and to do management via JWT enabled endpoints.

Create a Spring Boot 4 REST API project via Spring Initializr, configure Maven with Java 21, add Web, Spring Data JPA, DevTools, MySQL, Spring Security, and JWT creation and reading.

Set up a Maven Java Spring Boot to-dos REST project via start.spring.io, add Spring Web, Spring Data JPA, DevTools, MySQL driver, and Spring Security for JWT.

Create the core entities for the project—todo, user, and authority—and map their relationships with JPA annotations, including owner id, many-to-one, and embedded authorities.

define a todo entity in spring boot with @Entity and @Table, mapping id, title, description, priority, and complete fields to the todos table, plus getters.

Create a user entity that implements Spring Security's user details, maps to the users table, and includes id, unique email, password, and a one-to-many to dos with orphan removal.

Create an authority entity embedded in the user to manage multiple roles, implementing Spring security's granted authority with getAuthority and linking users to roles via a new table in MySQL.

Configure the user entity to embed authorities via an element collection, create a user authorities table joined by user id, and fetch authorities eagerly.

Configure a one-to-many users-to-dos relation with cascade all, orphan removal, and a many-to-one owner with lazy fetch and join column, then connect to mysql and run spring boot.

Spin up a MySQL 8.0 database in Docker on your machine, configure Spring Boot to connect via spring.datasource, adjust JPA settings, and explore data with DBeaver.

Set up Docker Desktop to run a MySQL container with root password, map port 3307, connect a Spring Boot app with JPA auto update and open session in view.

Connect to a MySQL database using DBeaver community, configure port 3307, and test the connection to view and manage todos, users, and user authorities in a running Spring Boot application.

Install OpenAPI Swagger for a Spring Boot app, add springdoc dependencies, and configure the UI path to /docs to expose controllers and endpoints.

Set up swagger in the spring boot project by adding springdoc openapi starter and validation, then access the swagger ui at /docs after running the app.

Explore how JWTs securely transmit data between server and client via a header, payload, and signature, with claims and a server-side secret using a Spring Boot library.

Set up jwt in a spring boot project by adding json web token dependencies and creating a jwt service to generate, parse, and validate tokens with 15-minute expiry.

Install the jjwt library and add jwt api, impl, and jackson dependencies to your Spring Boot project, then configure a secret and 15-minute expiration in application properties.

Create a JWT service in spring boot to extract usernames from tokens, validate tokens with user details, and generate tokens with claims, implemented via a service class and properties.

Generate a new jwt using the io.jsonwebtoken library by setting claims and subject, with issued at and a 15-minute expiration, signed with a base64 secret to create a token.

Learn to extract a username from a JWT by building reusable claim extraction in Spring Boot 4 REST APIs, parsing all claims with the signing key and a claim resolver.

Validate jwt tokens by extracting the username and expiration, ensuring the token is not expired and that the username matches user details, implementing is token valid logic.

Introduce a JWT service for parsing, validating, and generating tokens, and implement a Spring Security JWT authentication filter to intercept requests, validate bearer tokens, and set the security context.

Implement a once-per-request JWT authentication filter that reads the authorization header, validates the bearer token with the JWT service, and sets authentication in the security context.

Configure spring security with a jwt-based flow: load users by email via a Spring Data JPA repository, hash passwords with bcrypt, and add a jwt filter for stateless authentication.

Create a user repository to fetch users by email, extending CrudRepository<User, Long> and exposing Optional<User> findByEmail(String email). Prepare for the security configuration with JWT integration in the next video.

Configure security for a Spring Boot REST API by creating a security config with web security, beans for user details, bcrypt encoder, JWT filter, and stateless session.

Learn to register a new user using a validated register request, with first-user admin privileges, bcrypt password encoding, and unique email enforcement via the authentication service and controller.

Create a register request DTO with first name, last name, email, and password, enforce not empty and size, validate email format, encrypt with bcrypt, and provide a constructor and getters/setters.

Implement an authentication service register method that builds a new user, hashes the password, assigns authorities (admin for the first user, else employee), checks email availability, and saves transactionally.

Implement an authentication controller for registering users at /api/auth/register, validated via @Valid and @RequestBody, wired to the authentication service, and returning HTTP 201 for successful registrations.

Learn to authenticate users in Spring Boot by building a login flow with email and password validation, returning a JWT, and wiring the login through the service and controller.

Implement login by submitting an authentication request with email and password, hash and verify against the database using the authentication manager, and return a token.

Implement a login flow with authentication manager to validate credentials using bcrypt, fetch the user by email, and issue a JWT token in the authentication response.

Add a login endpoint to the authentication controller that authenticates with an auth request and returns a JWT token, issued with a secret using HS256.

Fetch the logged-in user's information via the get user info endpoint and configure swagger to accept JWT bearer tokens, guiding the creation of the user service, controller, and user response.

Build a user service and user controller to expose a get user info endpoint that returns authenticated user data via JWT, with security checks and swagger bearer token setup.

Add a swagger config with open api definition and bearer token security, update security to require authentication for non-public endpoints, and verify token authorization via swagger's authorize flow.

Create a user response dto in Spring Boot REST APIs that exposes only id, full name, email, and authorities, and update service and controller to return this concise user output.

Add a delete user feature to the service and controller. Implement a custom query to count admins and prevent deleting the last admin.

Implement a delete user feature in the service, ensuring deletion is blocked when the user is the last admin and all related todos are removed, returning forbidden status.

Learn how to count admin users with a custom sql query in spring boot rest apis, using a repository and jpa query to join authorities and filter by role admin.

Create a delete user endpoint using @DeleteMapping at /api/users, validate admin status to prevent deleting the last admin, and confirm user and authorities removal after deletion.

Define a secure custom error response with status, message, and timestamp for Spring Boot REST APIs. Use a global @ControllerAdvice and @ExceptionHandler to return JSON errors, avoiding leaking internal details.

Implement global exception handling in Spring Boot REST APIs using a dedicated exception model, controller advice, and a custom response entity to return 401 and 403 with clear messages.

Build a reusable utility package with a find authenticated user interface and implementation to centralize getting the authenticated user via getAuthenticatedUser from the security context, reducing code duplication.

Create a reusable util to fetch the authenticated user using getAuthenticatedUser, implemented as a FindAuthenticatedUser interface and a Spring component for easy reuse across endpoints.

Implement a password update workflow by adding a password update request dto, verifying old password, confirming the new password two, ensuring it differs from old, and exposing a /password endpoint.

Implement a password update request in a Spring Boot REST API requiring old, new, and confirmed passwords with 5–30 character validation and a generated constructor and getters/setters.

Implement a password update service that validates the current password, confirms the new password, ensures it differs from the old, then encodes and saves the user transactionally.

Add a put mapping in the users controller to change a user's password. Validate current password, ensure new passwords match and differ, and update via the authentication service.

Add response types and swagger annotations to the user controller, documenting info, delete user, and password update endpoints with explicit HTTP status ok for clearer API behavior.

Explore building a todo REST API by creating TodoRequest and TodoResponse objects, a CrudRepository, a service implementation, and a controller endpoint for creating todos with title, description, and priority validation.

Create separate todo request and response dto for a Spring Boot rest api, validating title, description, and priority, and expose id, title, description, priority, and complete in responses.

Create a TodoService with a createTodo function that maps a TodoRequest to a Todo entity, saves it, and returns a TodoResponse containing id, title, description, priority, and complete.

Expose a post endpoint to create to-dos for the authenticated user in a Spring Boot REST controller. Rely on a to-do service and swagger to manage creation and ownership.

Fetch all todos for the authenticated user by adding a find by owner repository method and a get all todos service function, then expose a controller endpoint returning todo responses.

Implement get all to dos in the todo service to fetch by the current user and map them to todo responses using repository find by owner and stream mapping.

Implement a todo toggle completion by updating the repository, service, and controller to find by id and owner, toggle isComplete transactionally, and return a not found error if missing.

Implement a toggle to-do completion endpoint by fetching a to do by id and owner, validating existence, flipping its completion state, persisting, and returning the updated to do.

Add a delete endpoint to the to do service and controller to remove a todo by id for the current user, throwing not found if missing and returning no content.

Add a transactional deleteTodo function to the to do service that receives a log id, validates the todo, throws if empty, and deletes it via todoRepository.delete(todo.get()).

Build and test a spring boot rest api for todos by adding endpoints to fetch all todos, toggle completion, and delete, with signed-in user context and proper http statuses.

Create an admin service and implementation, secure /api/admin, and provide an admin controller to get all users, promote to admin, and delete non-admin users.

Implement admin functionality to manage users by listing all users, promoting non-admins to admin, and deleting non-admin users, via an admin service, repository access, and security checks.

Promote a non-admin user to admin by validating existence, ensuring not already admin, updating authorities to include role employee and role admin, saving, and returning a user response.

Add a transactional delete non admin user function to the admin service, validating the user exists and is not already admin before deleting via the repository.

Configure an admin controller with security for /api/admin requiring the admin role, and implement endpoints using the admin service to get all users, promote to admin, and delete non-admin users.

Demonstrates running a Spring Boot REST API, creating users, logging in, and enforcing admin vs non-admin access to user data; promotes a user to admin and validates authorization.

Celebrate the Spring Boot REST APIs course by mastering REST concepts, JSON, HTTP messaging, Swagger, REST controllers, CRUD operations, JWT authentication, and role management.