Spring Boot 4: REST APIs with JWT, AWS, Spring AI & Docker

Explore the IoC container in spring, manage spring beans through dependency injection and full lifecycle—from instantiation to destruction—while configuring objects via XML, Java config, or annotations.

Build your first Spring Boot application using Spring Initializr or IDE, add a REST controller with a /welcome endpoint, and run it on an embedded Tomcat server.

Explore the Spring Boot @SpringBootApplication annotation as the single entry point that marks the main class as a configuration class and enables auto-configuration and component scanning.

Explain how Spring Boot starts from the main class and run method, bootstrapping the environment, banner, and application context, and selecting servlet, reactive, or none modes.

Explore Spring Boot runners, including command line runner and application runner, to execute one-time logic after bootstrapping, with examples of database operations, email tasks, and argument handling.

Explore how Spring Boot Actuator provides production features to monitor and manage applications, exposing health, beans, configuration, env, logs, metrics, and mappings through customizable endpoints.

Explore stereotype annotations in Spring Boot that auto register beans in the IOC container at class level, including repository, service, and controller layers with component, repository, service, and controller annotations.

Explore how the autowired annotation injects dependencies at runtime, and implement setter, constructor, and field injection in a product service and its controller.

Resolve dependency injection ambiguity in Spring Boot by using @Qualifier to select a specific bean or @Primary to designate a default bean, illustrated with debit and credit card services.

Define beans with @Bean annotations inside a configuration class marked by @Configuration to let the IOC container manage product objects, declaring bean definitions through configuration class methods.

Discover how Spring Data JPA abstracts JPA to reduce boilerplate, leveraging repositories, JPQL, native SQL, entity relationships, fetch types, and cascade operations for persistence management.

Explore the internal execution flow of Spring Data JPA, from repository method calls in the service layer to JPA API usage, Hibernate as the provider, SQL generation, and JDBC communication.

Compare Hibernate and Spring Data JPA to understand how Spring Data JPA provides repository abstraction and delegates persistence to JPA, while Hibernate maps objects to SQL via JDBC.

Create a Spring Boot project with Maven, Java 17, and dependencies Spring Web, Spring Data JPA, MySQL driver, and Lombok to enable REST APIs and CRUD operations.

Connect a Spring Boot application with a MySQL database by configuring the JDBC URL, credentials, and Hibernate properties, creating a products database, and verifying the connection through the running app.

Create a product object, set its fields, and persist it to the products table using Spring Data JPA's save method, then verify the saved record in console and MySQL Workbench.

Update a product entity in the database by retrieving it, setting a new product name and description, and saving with the repository’s save method to perform insert or update.

Learn how to save multiple entities at once with the saveAll method by creating three product objects, saving them via the product repository, and confirming three records in MySQL Workbench.

implement delete by id to remove a single entity using the product repository, and verify deletion with a unit test and MySQL Workbench showing id 14 deleted.

Delete an entity by id using the repository's find by id and delete methods, validated with a unit test and verified in MySQL Workbench.

Create jpql queries with index parameters in spring data jpa repositories using the query annotation. Explore entity-based querying on product name and description and compare index versus named parameters.

Learn to create native sql queries in Spring Data JPA using the query annotation, querying the products table by name and description via a repository method with native query enabled.

Learn what a REST API, Representational State Transfer, is and how it enables client and server communication over the internet using HTTP methods and JSON requests and responses.

Explore rest architectural principles, including client-server architecture, statelessness, cacheable responses, uniform interface, layered system, and optional code on demand. See how constraints make APIs reliable, scalable, and easy to use.

Explore how servers respond to client requests with http status codes, from 1xx to 5xx, including 200, 201, 204, 400, 404, 500, and 503.

Explains mapping HTTP requests to Spring Boot controller methods with request mapping and response body, including base URL, get/post/put/delete method-level mappings, and JSON conversion.

Spring Rest controller annotation handles Rest APIs by combining controller and response body, returning json or xml without config. It supports http requests like get, post, put and delete.

Get mapping annotation handles HTTP get requests, maps them to handler methods, and defines API endpoints, with response entity returning status, headers, and body.

Learn how the request param annotation extracts query parameter values from a URL, including single and multiple key-value pairs, with a practical get mapping example returning an employee object.

Master path variables in Spring Boot by extracting URL values with the @PathVariable annotation and binding them to controller method parameters for dynamic routing.

Learn how post mapping handles http post requests to create resources, and how request body converts JSON into a Java object, demonstrated with a sample employee endpoint and postman.

Master the delete mapping annotation to handle http delete requests, map endpoints for a rest API, and delete an employee by id using a path variable and a response entity.

Learn how Project Lombok uses annotations to generate getters, setters, constructors, toString, and equals and hashCode, reducing boilerplate in Java classes; install and configure a Maven dependency.

Map objects automatically with the model mapper library, converting entity to DTO and DTO to entity, reducing boilerplate in Spring Boot apps using the map method.

Define high level requirements for an e-commerce app, including customer and order management with CRUD REST APIs, one-to-many mapping, validations, and JWT authentication with role-based security on AWS.

Select a Java 17 stack for an e-commerce backend using Spring Boot, Spring Security, Spring Data JPA, and JWT, built with Maven, tested via Postman, deployed on AWS.

Identify the core e-commerce resources—customer, order, and user—and design REST APIs with pagination, sorting, and a one-to-many customer-order mapping. Implement register and login APIs and secure HTTPS with JWT authentication.

Create a Spring Boot project from scratch using spring initializer or IDE, with Maven and Java 17, including Spring Web, Spring Data JPA, Lombok, DevTools, and Spring Security.

Learn to build a Spring Boot packaging structure using a three-layer architecture, creating entity, repository, service, controller, and config packages, with dto transfer and preparation for MySQL integration.

Create a MySQL database and connect it to a Spring Boot app by configuring the data source, Hibernate dialect, and JPA settings in application properties.

Create a customer JPA entity in a Spring Boot eCommerce app, using Lombok and JPA annotations to map to a MySQL table with primary key, unique constraints, and columns.

Define a customer repository by extending Spring Data JPA's JPA repository for the customer entity. Leverage built-in CRUD operations, pagination, and sorting without additional repository annotations.

Create a customer dto in spring boot to transfer data between client and server, hiding sensitive fields and returning dto from service and controller layers of rest apis.

Build and test a create customer REST API with Spring Boot, using DTO to entity mapping, a repository, a controller, and Postman verification.

Build and test a spring boot get customer by id rest api with http get at /api/customer and id, using a resource not found exception and dto mapping.

Design and implement a delete customer by id rest api using a delete method, path variable, and service-layer integration with jpa repository, and verify via postman and database updates.

Explore pagination and sorting concepts, including page size, page number, and sorting by fields, using query parameters in urls to fetch data page by page and improve performance.

Implement pagination for the get all customers API by adding page number and page size parameters, using pageable to fetch pages and extract content, and updating service, repository, and controller.

Enhance the rest API pagination by returning a customer response with content, page number, page size, total elements, total pages, and last status, mapped through service and controller.

Implements pagination for the Get all customers rest API by adding page number and page size parameters, using a pageable object to fetch the page content.

Customize the pagination rest api for retail customers by returning a customer response with content, page number, page size, total elements, total pages, and last.

Enable sorting for the get all customers rest API with sort by and order by, plus ascending and descending sorts and page number and page size pagination in Spring Boot.

Implement dynamic sorting in a Spring Boot REST API by adding a search direction parameter to return results in ascending or descending order, and verify with Postman.

Refactor the get all customers API by introducing a utils constants class with default page number 0, default page size 5, default sort by id, and default sort direction ascending.