Spring Boot Masterclass: Beginner to DevOps

Explore Spring Boot as a production-ready, Java-based framework for backend apps, microservices, and cloud-native solutions, featuring auto-configuration, starter dependencies, and easy rapid development.

Discover the difference between Spring and Spring Boot, where Spring is the engine that powers the Spring Boot framework, which contains Tomcat, security, Lombok, and other components.

Explore the three layers of a Spring Boot application: the controller, the service, and the repository. Learn how the client calls the api layer and data moves to the repository.

Check your java version in the terminal, then download and install the java development kit (jdk) from oracle to include the runtime environment for spring boot development.

Use the Spring Initializer to create a Java Maven Spring Boot 4 project with the Spring Web dependency, enabling Spring MVC and an embedded Tomcat.

Download and install IntelliJ, open the project, and explore folders like .idea, .mvn, and src with pom.sml. Run the Spring Boot entry point and review static resources, templates, and application.properties.

Configure multiple JDKs in your Spring Boot 4 project, run and monitor logs, and change the server port via application.property to deploy a jar.

Build and understand a simple contact API in Spring Boot, implementing a three-layer dataflow from controller to service to repository, with a contact model and a DTO for API responses.

Create a generic api response dto with a java record for immutability, including status code, message, and data, and cover java version compatibility and json include not null behavior.

Implement a Spring Boot repository layer using @Repository to connect to an in-memory data store, with find all, find by id, save, and delete by id methods for contact data.

Spring Boot demonstrates a service layer that handles business logic for contacts, using dependency injection to access the repository. It offers CRUD operations with api responses (200, 201, 204, 404).

Create the api layer in spring boot by building a rest controller and wiring a contact service through dependency injection. Expose get endpoints such as /api/contacts to fetch data.

Learn to implement a get request to fetch all contacts, wrapping the result in a response entity. Understand API/contact route handling and how path conflicts produce runtime errors.

Apply post mapping to create contacts using a request body for name and phone number, tested with postman. Explore endpoint setup, response handling, and in-memory storage before database integration.

Implement a delete mapping in Spring Boot that accepts a path variable id and returns a response entity after deleting the contact via the contact service.

Learn how to implement a put mapping in spring boot to update a contact by id, using a path variable and request body, and return the updated contact.

Review Spring Boot, a Java-based framework for backend apps, and its controller, service, and repository layers managing data flow. Use dependency injection and rest controller annotations to build apis.

Explore Spring Boot fundamentals and advanced topics, including security, authentication, authorization, roles, JPA persistence, and connecting to MySQL and Postgres to build a task manager.

Learn how Spring Security acts as the gatekeeper of a Spring Boot application, intercepting requests to authenticate and authorize before they reach controllers and APIs.

Design and build a secure task manager with user and admin roles, enabling registration, login, profile updates, and full CRUD on categorized tasks, with a Spring Boot project on GitHub.

Create a spring boot 4 project on start.spring.io using java and maven, add spring web, jpa, validation, security, lombok, and mysql or postgres for task manager app with auto-created tables.

Open the Spring Boot project in IntelliJ, create a task_manager branch, install dependencies, run on port 8080, and note data source URL error for connecting a database in next lecture.

Navigate to mysql.com, go to downloads, download the MySQL community server and MySQL Workbench, then optionally install the MySQL shell; configure a username and password to connect.

Install PostgreSQL on Windows or macOS using the EDB installer or PostgreSQL app, connect with PgAdmin to manage the database, and explore setup guides for PostgreSQL and MySQL.

Learn how to connect a Spring Boot 4 application to a MySQL database by configuring pom.xml dependencies, application.properties, and a local database named task db, then run and test.

Connect a Spring Boot application to a Postgres database by adding the Postgres dependency and updating pom.sml. Configure spring.datasource.url, username, and password in application.properties to verify the connection.

Set spring.jpa.hibernate.ddl-auto to update to let Hibernate auto-update database tables from entity changes during development; in production use none or validate.

Structure your Spring Boot project into layers—repository, controller, and service—and create packages for dtos, enums, models, exceptions, and security to accelerate development.

Design a relational schema with users and tasks, establishing one-to-many links. Demonstrate fields like user id, email, password, and role, plus task details and the task owner reference.

Define a user entity with @Entity and @Table(name = 'users'). Use @Data for getters and setters; apply @Id and @GeneratedValue(strategy = identity) for a unique id, with email, password, role, and tasks.

Create a task entity class mapped to the tasks table with id, title, description, category enum, isCompleted, and a user relationship, using Lombok data and identity generation.

Define category and role enums to support personal and work tasks, then protect APIs for admin and authenticated users, and import enums properly to link table relationships.

Define a one-to-many relationship where a user has multiple tasks using mappedBy, join column, and cascade all. Apply json managed reference and json back reference to prevent circular serialization.

Learn to create user DTO and task DTO in a Spring Boot app, configure serialization with json include not null to omit passwords, and manage DTO relationships for clean responses.

Create and validate custom registration and login request dtos, enforce email and password with jakarta validation, and implement a generic api response to standardize outcomes.

Run the app to automatically create users and tasks tables in Postgres via JPA mappings, illustrating table and column generation. This session previews Spring Security setup in the next lecture.

Implement a custom user details class that implements Spring Security's UserDetails, map the user email as the username, and expose the password and role-based authorities for authentication.

Implement a custom user details service in spring security that loads a user by email through a repository, handles not-found cases, and returns custom user details for authentication.

Create a security config class and a security filter chain bean to secure requests. Enable web and method security, configure cors with origins, methods, headers, credentials, and disable CSRF.

Configures spring security in a spring boot 4 app with session management, authentication, and route protection; enables login and register as permitAll and includes bcrypt password encoding and logout.

Define a task repository interface extending JPA repository for Task with long id, enabling find by user and find by user and category to fetch a user's tasks by category.

Implement a global exception handler in Spring Boot with controller advice, define non-found and bad request exceptions, and return custom API responses for 400, 404, and 500.

Design and implement a Spring Boot registration and login service with interface and implementation, include email check, password encoding, role handling, and API responses.

Authenticate users with the authentication manager using email and password from the login request, populate the Spring Security context, and issue a session cookie for a successful login.

Explore building a Spring Boot auth controller to register and login users, validate input with @Valid, and manage sessions via cookies by integrating a custom user details service.

Explore end-to-end registration api testing using postman, validating /api/auth/register on localhost:8088, handling default role user, admin role with capitalized keys, and duplicate email errors.

Test the login API by posting email and password to api/auth/login, observe 401 for unauthenticated routes, and note session-based authentication that resets on restart.

Implement a task service with create, get by user and category, delete, and complete methods. Map results to a task DTO and return an API response, authenticating the user email.

Create task controller as rest controller /api/tasks. Use requireR constructor to inject a task service and handle a post returning a task dto via authentication to obtain the user email.

Test the create task API with Postman, handle authentication to obtain a session, submit a task with title, description, and category, and debug description capture and session flow.

Implement a task service that retrieves user tasks by category, maps them to DTOs, and returns clear API responses. Include delete and authorization checks, and support toggling task completion.

Implement controller methods to fetch tasks by user category with an optional category parameter and authentication, and delete or update task status via path variables and put mappings.

Master tasks management api tests by validating get all tasks by user and category, toggle completion, and delete tasks, while debugging task service mappings and authentication flows.

Implement Spring Boot 4 user service, inject the user repository, map to user DTOs; get all users, get a profile by email, and update a user profile with api responses.

Build a spring boot 4 user controller with rest annotations and autowired user service, exposing admin-only get all users, get my profile, and update profile via authentication and user DTO.

Explore testing user management with Spring Boot security: authenticate as normal and admin users, access control for getting all users, view and update profiles, and verify role-based permissions.

Configure a logout endpoint at /api/auth/logout in spring security that deletes cookies and returns 200, usable with any http method. Verify by logging in again and re-accessing account details.

Explore microservices and event-driven architecture, including Apache Kafka, Eureka server and client, and API gateway, while practicing JWT-based authentication, sending emails, and building a fintech microservice backend.

Explore microservice architecture and monolithic designs through an online banking scenario. See independent services—user, account, transaction, and notification—each with its codebase, database, and deployment, connected by API or event-driven communication.

Explore event-driven architecture and its producer–consumer model with Apache Kafka or RabbitMQ. See how it replaces traditional request–response in a microservice banking app to enable scalability.

See how the discovery service and Eureka server make microservices discoverable and monitorable, while the api gateway acts as a gatekeeper and load-balancer for services like account and transaction.

Explore how the Spring Cloud API Gateway balances and routes requests in a microservice architecture, serving as the entry point and authenticating traffic to the account and user service.

Analyze the data model across the role table, user table, accounts table, transaction table, and notification table and their operations.

Create the nova bank discovery service by scaffolding a Maven spring boot project on start.spring.io, add spring web, spring boot actuator, and Eureka server, then push to a GitHub repo.

Learn to create an api gateway service with a reactive Spring stack, including gateway, cloud load balancer, Eureka discovery client, Spring Boot Actuator, Spring Security, and JWT, emphasizing non-blocking traffic.

Learn to create a Spring Boot user account service, set up the repository and dependencies for web, JPA, Postgres and MySQL, Lombok, Spring Security, Eureka discovery client, Kafka, and ModelMapper.

Create a transaction service project on GitHub and configure a Spring Boot app with spring web, jpa, mysql and postgres drivers, security, validation, discovery client, actuator, kafka, and opu feng.

Create a Spring Boot notification service to send customized emails and notifications for transactions and account events, using Thymeleaf templates, Java Mail Sender, and Kafka integration.

Connect the user accounts service to a mysql database by configuring application.properties with spring.datasource.url, server.port, and credentials; then create and connect to the database, observing discovery service issues.

Connect the user account service to a PostgreSQL database by configuring the Spring DataSource URL, creating NovaBankUsersAccountsDB, and enabling Hibernate ddl-auto to update on model changes.

Connect the transaction and notification services to their own databases, create transaction-db and notification-db, and set ports to 8082 and 8083.

Enable the Eureka server on port 8761, expose actuator endpoints, register the user account service with the discovery service, verify health via actuator, and enable instance IP addressing.

Set up the Eureka discovery service, register microservices, and monitor status with actuator metrics; configure discovery clients and restart services to reflect changes.

Learn to run a Kafka broker with Docker Compose using Docker, following industrial standard practices. Install Docker on Mac, Windows, or Linux and start Docker to set up Kafka quickly.

Learn to pull and run a Kafka image from Docker Hub with Docker Compose, exposing port 1992 to 0.0.0.0 and naming the service Kafka for containerized setup.

Pull and run the Kafka image as a container with docker compose up -d. Kafka acts as a broker, relaying events from producers to consumers for event-driven communication between services.

Configure the user account service for Kafka by setting the bootstrap server to localhost:1992, and define producer settings with string key serializer and JSON value serializer, enabling distinct event headers.

Organize an account service in Spring Boot by creating config, controller, service, repository, model, enums, security, Kafka, and exception packages, with entities planned next.

Define role entity for the user account service in Spring Boot 4, using @Entity and table roles, Lombok accessors, a builder, and an identity-generated id with a unique, non-null name.

Learn to implement a user repository that extends the JPA repository, with methods to find by email, check existence by email, count enabled users, and perform custom role-based queries.

Develop a generic api response and multiple dto objects for the users account service, implement user and account dtos with secure password handling and json configuration.

Explore how to design and implement auth and account service DTOs, including registration and login requests, authentication response with token, and admin user statistics and user-with-account DTOs.