Build REST APIs with Spring Boot 4, Spring Security 7, & JWT

Learn how to download, install, and verify Java 25 on Windows 11, set JAVA_HOME and PATH, and confirm the JDK is ready with java -version and javac.

download and install the IntelliJ Idea community edition on windows 11, including visiting the official site, running the installer, and launching after agreeing to the terms.

Install and configure MySQL server and MySQL Workbench on Windows 11, set up root password, configure port 3306, add bin to PATH, and verify with a demo database.

Install Postman on Windows 11, sign in with Google or GitHub, complete two-step verification, then create a workspace to send REST API requests with method, URL, headers, and body.

Explore how an API enables two software systems to talk. Understand how REST APIs use HTTP methods and JSON to exchange data.

discover the six rest constraints that define a true rest api: client-server architecture, statelessness, cacheability, uniform interface, layered system, and optional code on demand.

Master the rest concepts of resources, sub resources, and URIs and how they organize data in APIs. See examples with pizzas, orders, and users and URIs like /pizzas and /pizzas/5/reviews.

Explore the four core http methods—get, post, put, and delete—and learn how they read, create, update, and remove resources in rest apis, with practical pizza menu examples.

Understand how servers respond to client requests with http status codes. Explore 1xx to 5xx categories and codes such as 200, 201, 204, 404, 500, and 503 in rest apis.

Understand the core components of an HTTP request—the request line, headers, body, and query parameters—and how they guide REST API behavior in Spring Boot applications.

Explore the core components of an HTTP response—the status line, headers, and body—and how cookies and status codes guide client behavior in REST APIs built with Spring Boot.

Explain payload as the data in the body of a rest api request or response, in formats like json, xml, or files, and its role in validation, performance, and security.

Explore the rest message as the http request or response exchanged between a client and a server in a REST API. It comprises the request/response line, headers, and optional body.

Understand statelessness: servers do not retain client state between requests, requiring authentication info in every call with tokens like JWT, enabling scalable, reliable, and cache-friendly REST APIs.

Explore the pros and cons of restful web services, highlighting simplicity, scalability, stateless architecture, and loose coupling, plus overfetching, real-time limits, and versioning in rest APIs.

Rest resources are identified by data, a unique id, and create, read, update, and delete actions, with sub resources like order items; use pizzas, orders, and customers as examples.

Design clean, predictable rest urls by using nouns and plurals, lowercase paths with hyphens, path parameters, sub resources, and query parameters, then apply versioning and avoid file extensions.

Learn to assign the right http methods to rest resources—get, post, put, patch, and delete—across endpoints, and understand idempotent behaviors with real-world examples.

Model json representations for rest apis by using flat resource objects and arrays, applying camel or snake case consistently, and returning structured json errors.

Adopt plural nouns to name REST API resources, ensuring URIs always start with a plural collection and clearly distinguish between collection and item paths, improving consistency, predictability, and developer understanding.

Use proper http headers to specify serialization formats in REST APIs, including content-type and accept, with JSON as a standard and explicit handling of errors like 415 when needed.

Learn to model real-world relationships with subresources in rest api, using paths like /users/{id}/addresses and /products/{id}/reviews to express one-to-many and many-to-many connections.

Master selecting the right http status codes for rest apis, including 200, 201, 204, 400, 401, 403, 404, 405, 500, 502, and 503, to communicate results clearly.

Explore the real differences between get and post in rest apis, including when to fetch data versus submit data, visibility, caching, idempotency, limits, and security considerations.

Differentiate post and put in REST APIs by showing when to create resources versus update at a known URI; post is non-idempotent while put is idempotent, with corresponding status codes.

Compare put and patch in REST API design, highlighting full resource replacement versus partial updates, idempotency, payload size, data loss risk, and bandwidth and performance considerations.

Understand how REST, a server-side API design style that exposes endpoints over HTTP, differs from Ajax, a client-side technique for asynchronous browser requests, and how they complement modern web apps.

Compare http and https, explain encryption with ssl/tls and certificates, and show when to use each, including ports 80 and 443, browser indicators, and seo impact.

Compare rest and soap across architecture, formats, transport, and use cases. Rest delivers speed and simplicity with http and json, while soap offers structured, enterprise-grade security with xml and wsdl.

Compare rest and GraphQL in api development, highlighting how rest uses resource endpoints and http methods while GraphQL uses a single flexible query endpoint to fetch exact data.

Create and set up a spring boot project in IntelliJ IDEA using spring initializer, Maven, Java, and Spring Boot 4 milestone, then run on an embedded Tomcat at port 8080.

Create a Spring Boot hello world REST API by building a REST controller with a GET mapping for /hello-world, returning a hello world string on an embedded Tomcat.

Develop a spring boot rest api that returns a student bean as json by creating the bean and a rest controller with @GetMapping.

Create a Spring Boot rest API that returns a four-student list in JSON via a get mapping on /students in the student controller.

Learn to build a Spring Boot rest API that uses path variables with @PathVariable. Bind url values to method arguments and handle dynamic ids.

Build a Spring Boot REST API using @RequestParam to extract query parameters from a request URL, including single and multiple parameters.

Build a Spring Boot Rest API that handles http post requests by mapping with @PostMapping and extracting json from the request body using @RequestBody to create a Student object.

Build a Spring Boot rest API that updates existing resources via http put using @PutMapping, @RequestBody, and @PathVariable to bind URL id and JSON request body.

Build a Spring Boot REST API for deleting a resource with @DeleteMapping, using a path variable id, tested via Postman, returning a 'student deleted successfully' message with HTTP 200.

Use Spring ResponseEntity to control the http response by configuring status, headers, and body, with generic types, including 200 and 201 created for REST APIs.

Apply @RequestMapping at the class level to define a base url for all rest APIs, using a /students base path and test student operations with Postman.

Design and implement a RESTful task API with CRUD operations, using a consistent /api/tasks base path and endpoints for create, read, update, delete, and patch actions to mark tasks complete.

Explore the Spring Boot project architecture across the three-tier design—controller, service, and Dao or repository layer—and show how Postman requests flow from client to controller, service, dao, and database.

Create a spring boot project in IntelliJ IDEA using spring initializer with maven, java 25, and spring boot 4.x, then import and review Spring Data JPA and MySQL dependencies.

Configure a MySQL database in a Spring Boot app using Spring Data JPA, set up data source and Hibernate DDL auto to update, and run on the embedded Tomcat server.

Define a task JPA entity mapped to the tasks table with Jakarta Persistence, including id, title, description, and completed fields, using identity generation and Hibernate to create the table.

Learn to set up a Spring Data JPA repository for task entities, enabling CRUD operations automatically, and craft a task DTO to securely transfer data between client and server.

Develop an add task REST API using a three-layer Spring Boot architecture (controller, service, repository), implementing dto-to-entity conversion, database persistence, and post mapping for creation.

Use ModelMapper to automatically map between DTO and JPA entity, configure a Spring bean, inject it into the service, and replace manual mappings with a single map call.

Build a get task by id api in spring boot by wiring service and controller, retrieving the task, mapping to a dto with model mapper, and returning 200 or 404.

Define and implement a get all tasks REST API by updating the service and controller, converting entities to task DTOs, and exposing a get /api/tasks endpoint.

Build and test the update task REST API by implementing the service and controller layers, handling not found errors, mapping task DTOs to JPA entities, and validating with postman.

Build the delete task rest api by implementing service and controller layers, using find by id and delete by id, and handling not found with resource not found exception.

Build a task rest API by updating the service and controller to mark a task as completed via a patch at /api/tasks/{id}/completed, with mapping to a task DTO.

build an incomplete task rest api by updating a task to incomplete, wiring the service and controller layers, and exposing a patch endpoint to persist changes.

Build a simple banking application with Spring Boot offering account management via rest apis. Implement create, fetch, list, withdraw, deposit, delete, and transfer operations with exception handling and transaction history.

Design a REST API for the account resource in a banking app, defining endpoints under /api/accounts for create, read, update, delete, deposits, withdrawals, transfers, and transaction history.

Explore building and securing a bank account management rest APIs with Spring Boot 4 and Spring Security 7, covering create, get, list, withdraw, deposit, and delete operations.

Set up Spring Boot project in IntelliJ with Maven and Java 25. Generate via Spring Initializer, add Web, Data JPA, MySQL driver; enable Lombok plugin and annotation processing, then sync.

Configure a MySQL database in a Spring Boot app by updating application.properties with the jdbc url, username, and password; enable automatic table creation with spring.jpa.hibernate.ddl-auto=update, then run the app.

Configure the MySQL database in a Spring Boot app by creating banking_app with MySQL Workbench, updating application.properties with the JDBC URL to localhost:3306/banking_app, and enabling Hibernate DDL auto update.

Create a JPA entity for accounts by defining id, account_holder_name, and balance, annotate with @Entity and @Table, use Lombok for getters/setters, and set up a repository extending JpaRepository<Account, Long>.

Build the add account rest api by implementing the service with account dto and mapper, persisting via the repository, and exposing a post endpoint that returns 201.

build a get account by id rest api with spring boot, call repository find by id, map to account dto, and expose via a get mapping with a path variable.

Develop a deposit rest API by implementing the service layer, account repository, and controller to add an amount to an account balance using id and amount, tested via Postman.

Build a withdraw rest API in Spring Boot by implementing the account service withdraw method, validating account existence and balance, updating the balance, and exposing it via put /accounts/{id}/withdraw.

Build and expose a get all accounts REST API by implementing the service and controller layers, mapping account entities to account DTOs, and returning a list via a GET endpoint.

Build the delete account REST API by implementing a delete method in the account service and exposing it via a delete mapping in the account controller, then test with Postman.

Explore using a Java record as a DTO in a Spring Boot banking app, leveraging immutability and auto-generated getters, constructors, equals, hashCode, and toString to streamline data transfer.