Spring Boot 4 in Action: Build 5 Projects from Scratch [NEW]

Install Java 25 on Windows 11 from Oracle's official JDK download, then configure JAVA_HOME and PATH. Verify the setup with java -version and javac -version.

Download the IntelliJ IDEA Community Edition on Windows 11, select pom and java, create a desktop shortcut, then launch IntelliJ after agreeing to the terms.

Install and configure MySQL server and MySQL Workbench on Windows 11, verify installation via Workbench login and command prompt, create a demo database, and add MySQL bin to PATH.

Install the Postman rest client on Windows 11, sign up with Google, and start testing rest APIs by creating requests in a workspace.

Discover how Spring Boot addresses the heavy configuration of Spring Framework by auto configuration of common beans, providing an embedded Tomcat, and starter dependencies for quick, opinionated projects.

Learn how Spring Boot accelerates Spring-based app development with starters, auto configuration, externalized configuration, actuator, and embedded servlet containers. Eliminate boilerplate and simplify dependency management with these features.

Create your first spring boot project quickly with spring initializer, choosing maven, java, and spring boot 4, and add web dependencies for a REST API running on an embedded tomcat.

Describe the Spring Boot project structure: pom.xml dependencies and plugins, src/main/java and resources, main class with @SpringBootApplication, and static, templates, and application.properties.

Create a simple Spring Boot hello world REST API using Spring MVC controllers, REST controller, and GetMapping to return hello world at /hello world.

Change the default port and context path of a Spring Boot app by editing application.properties; set server.port and server.servlet.context-path to customize the base URL, e.g., 9090 and /first-app.

Master the spring boot starter parent as the central manager for a spring boot project, auto-configuring default java version, dependency versions, and maven plugins for streamlined builds.

Explore how Spring Boot auto configuration reduces boilerplate by auto wiring beans from classpath dependencies, with conditional logic and debug insights into activated configurations.

Discover how Spring Boot auto configuration automatically creates and configures beans from classpath dependencies, demonstrated with Spring Boot Starter Web MVC and embedded Tomcat.

Exclude specific auto-configuration classes in Spring Boot to manually configure components like data sources, using the exclude attribute on @SpringBootApplication and enabling debug logs.

Spring Boot applies auto configurations only when conditions are met, using conditional annotations like on class, on missing bean, on property, and web or not web.

Understand how the Spring Boot application annotation composes @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan to enable auto configuration, component scanning, and extra configuration for beans.

Master Spring Boot rest api basics, including RestController, GetMapping, PostMapping, PutMapping, DeleteMapping, PathVariable, RequestParam, RequestBody, ResponseEntity, and base URL via RequestMapping.

Create a simple Spring Boot rest api by building a hello world controller annotated as a rest controller, mapping a get request to /hello-world that returns hello world.

Create a spring boot rest api that returns a list of students as json, using a get mapping and a controller method.

Create a Spring Boot rest API that handles path variables with @PathVariable, map requests with @GetMapping, bind uri template variables to method parameters, and test dynamic responses in the browser.

Build a Spring Boot rest api that uses @RequestParam to extract single and multiple query parameters from the request url, and distinguish it from path variables.

Create a Spring Boot rest api that handles http post requests, mapping json to a student object with @PostMapping and @RequestBody, and returns a 201 created status.

Build a spring boot rest api using @PutMapping to handle http put requests that update existing resources, binding the id with @PathVariable and extracting json with @RequestBody.

Create a Spring Boot rest API that handles http delete requests using @DeleteMapping, binds the student id via @PathVariable, and returns a 200 response with a 'student deleted successfully' message.

Learn how to use the response entity class to craft a complete http response for Spring Boot Rest APIs, configuring status, headers, and body with 200 and 201 codes.

Define a base url for rest apis in a spring mvc controller with @requestmapping at the class level using base url students, then test with Postman and verify 200/201 responses.

Create a Spring Boot 4 rest api with Spring Data JPA and Hibernate for a MySQL database. Set up the project in IntelliJ, map user entities, and implement CRUD APIs.

Configure the spring boot app to connect to localhost:3306 using the user_management database by setting the jdbc url, username, and password, and enable spring.jpa.hibernate.ddl-auto update and show sql.

Create a standard Spring Boot packaging structure and build a user JPA entity mapped to the users table, with id, first name, last name, and a unique email.

Create a Spring Data JPA repository for the User JPA entity, extending JpaRepository to get built-in CRUD operations and automatic runtime implementation with pagination and sorting.

Create a DTO using a Java record to hold immutable data, and build a mapper to convert between user JPA entities and user DTOs, with spring bean wiring via @Component.

Build a create user rest API by implementing service and controller layers, mapping between user DTO and entity, persisting with a repository, and testing with Postman to return 201 created.

Implement a get user by id rest api across service and controller layers, map to a user dto, and test with postman; handle not found with resource not found exception.

Build a get all users rest API in a Spring Boot app, backed by the service layer, testing with postman, mapping JPA entities to user dtos.

Build an update user rest api in spring boot, wiring service and controller layers with a put mapping, using a user dto and postman to test 200 and 404 responses.

Build a delete user rest API in spring boot by validating the user exists, deleting via the repository, and returning a success message, then test with postman.

Understand the Spring Boot project architecture across the controller, service, and DAO layers, and see how Postman tests REST APIs from client to database using Spring Data JPA.

Explore account management by building Rest APIs to create accounts, retrieve a specific account, get all accounts, withdraw amount, deposit amount, and delete accounts.

Design a rest api for the account resource in a banking app, detailing the base path /api/accounts, and operations for create, read, update, delete, deposit, withdraw, transfer, and transaction history.

Create a spring boot project in IntelliJ with Spring Initializer and Maven, Java 25, then import it and add web, Spring Data JPA, MySQL driver, Lombok, and annotation processing.

Configure a Spring Boot project to connect to a local MySQL database by creating banking_app, updating application.properties with JDBC URL, username, and password, and setting hibernate ddl-auto to update.

Create a JPA entity Account with id, account holder name, and balance mapped to accounts; use Lombok for getters/setters and constructors, then define AccountRepository extends JpaRepository<Account, Long>.

Build the add account rest api by creating the service layer, mapping account dto to entity with a mapper, and exposing a post endpoint in the controller.

build a get account by id rest api in spring boot, implementing service, repository, mapper, and controller to return an account dto and handle not found.

Build a deposit rest API that updates an account balance by adding a specified amount, using a service, repository, and DTO mapping, exposed via put /{id}/deposit.

Implement a withdraw amount rest api in Spring Boot by updating account service and controller to verify account, enforce funds, deduct balance, and return the updated account dto.

Build the get all accounts rest api by implementing the service method to fetch all accounts, map entities to account dtos, and expose a get mapping in the controller.

Implement a delete account rest api by updating the account service and controller, handling non-existent ids with a runtime exception, deleting by id via the repository, and testing with postman.

Learn how to use a Java record class as a DTO in a Spring Boot banking app, with immutable data and auto-generated getters, constructors, equals, hashCode, and toString.

Learn exception handling for a banking rest API by returning proper error responses when an account ID is not found, aligning with the account management feature.

Explore spring boot's default exception handling and implement a custom account exception, an error details record, and a global exception handler to return 404 with meaningful messages.

Implement a global exception handler with @ControllerAdvice to centralize account and generic error handling, returning error details via ResponseEntity including timestamp, message, url, and an error code.

Build the transfer funds REST API that debits from one account and credits another, using a transfer fund DTO and implementing service methods, then test with Postman.

Implement the transfer funds method in the account service interface and its sample class, retrieve both accounts by id, debit from the source, credit the destination, and save both entities.

Build a transfer funds api in spring boot by adding a post mapping with request body, using transfer fund dto, invoking account service to transfer funds, and returning success message.

Create a transaction JPA entity with id, account id, amount, transaction type, and timestamp, and annotate it with Lombok and JPA to map the transactions table.

Create a Spring Data JPA repository for the transaction entity and define a query method to fetch transactions by account id, ordered by timestamp descending.

Log the deposit operation by creating a transaction entity, setting account id, amount, type, and timestamp, and persisting via the transaction repository using constructor injection.

Log every withdraw transaction by saving a transaction entity to the database in the account service withdraw method, and verify balance updates via the withdraw API.

Log the transfer operation by updating the transfer funds method in account service to create and save a transaction entity, enforcing balance validation and recording the transfer in the database.

Build the fetch account transactions api by implementing a transaction DTO, converting JPA entities to DTOs, and wiring service and repository to return transactions ordered by timestamp; test with Postman.