Java with Spring Boot Course

Lesson 1 • Exception Handling and Debugging

Covers checked and unchecked exceptions, try-catch-finally, and custom exceptions. Robust error handling is critical for building reliable Spring Boot APIs.

Lesson 2 • Modern Java Features

Introduces lambdas, streams, Optional, and records from Java 8 through Java 17. Spring Boot leverages these features extensively in its auto-configuration and data layers.

Lesson 3 • Collections and Generics

Explores List, Set, Map, and Queue with generic type parameters. Proper collection usage is essential for handling data in Spring services and repositories.

Lesson 4 • Java Syntax and Data Types

Covers primitive types, variables, operators, and control flow. Establishes the syntax baseline required for all subsequent Java and Spring code.

Lesson 1 • Spring Boot Auto-Configuration

Explains how Spring Boot auto-configures beans based on classpath dependencies. Understanding this mechanism prevents misconfiguration and aids troubleshooting.

Lesson 2 • Application Structure and Conventions

Explains the standard package layout, main class, and Spring Boot conventions. Following these conventions enables auto-configuration and component scanning.

Lesson 3 • Spring Initializr and Build Tools

Generates a project with Spring Initializr and configures Maven or Gradle build files. This is the entry point for every Spring Boot application created in the course.

Lesson 1 • Stereotype Annotations and Component Scanning

Uses @Component, @Service, @Repository, and @Controller to register beans automatically. Proper annotation use enforces architectural boundaries in layered apps.

Lesson 2 • Java-Based Configuration

Defines beans programmatically with @Configuration and @Bean methods. Java config provides type-safe, refactorable alternatives to XML or annotation scanning.

Lesson 3 • Bean Scopes and Lifecycle

Covers singleton, prototype, request, and session scopes plus lifecycle callbacks. Correct scope selection prevents memory leaks and concurrency bugs.

Lesson 4 • Inversion of Control and the IoC Container

Defines IoC and explains how the ApplicationContext manages beans. This mental model is the foundation for understanding every Spring component.

Lesson 1 • API Documentation with OpenAPI

Generates interactive API docs using SpringDoc and the OpenAPI specification. Documentation accelerates onboarding and serves as a contract for consumers.

Lesson 2 • Spring MVC Request Handling

Maps HTTP requests to controller methods using @RequestMapping and its shortcuts. This section establishes the request-response cycle central to all REST APIs.

Lesson 3 • REST API Design Best Practices

Applies RESTful resource naming, HTTP method semantics, and status code conventions. Well-designed APIs reduce client errors and simplify versioning.

Lesson 4 • Input Validation and Error Responses

Validates request payloads with Bean Validation annotations and handles errors globally. Consistent error responses improve API usability and client integration.

Lesson 1 • Database Migrations with Flyway

Manages schema evolution using versioned Flyway migration scripts. Automated migrations ensure consistent database state across all environments.

Lesson 2 • Spring Data Repositories

Uses JpaRepository and CrudRepository to generate data access methods automatically. Repository abstraction eliminates boilerplate DAO code.

Lesson 3 • Entity Relationships

Models one-to-one, one-to-many, and many-to-many associations with cascade and fetch options. Proper relationship mapping prevents data integrity issues and N+1 queries.

Lesson 4 • Transaction Management

Controls data consistency with @Transactional, propagation, and isolation levels. Correct transaction boundaries prevent dirty reads and partial updates.

Lesson 1 • Authorization and Role-Based Access Control

Restricts endpoint access using @PreAuthorize, @Secured, and HTTP security rules. Fine-grained authorization enforces the principle of least privilege.

Lesson 2 • JWT-Based Stateless Authentication

Implements token issuance, validation, and refresh using JSON Web Tokens. JWT enables scalable, stateless authentication for REST APIs.

Lesson 3 • User Authentication Configuration

Configures in-memory and database-backed user stores with password encoding. Secure credential storage is a baseline requirement for any production application.

Lesson 4 • CORS, CSRF, and Security Headers

Configures cross-origin resource sharing, CSRF protection, and HTTP security headers. These settings defend against common web vulnerabilities in browser-based clients.

Lesson 1 • Controller Slice Tests with MockMvc

Tests REST controllers in isolation using @WebMvcTest and MockMvc. Slice tests validate request mapping, validation, and error handling without a full context.

Lesson 2 • Unit Testing with JUnit 5 and Mockito

Tests individual classes in isolation using JUnit 5 assertions and Mockito mocks. Isolated unit tests run fast and pinpoint defects at the source.

Lesson 3 • Repository Slice Tests with DataJpaTest

Validates JPA queries and repository methods using an in-memory database. Data layer tests confirm correct SQL generation and entity mapping.

Lesson 4 • Testing Spring Beans and Services

Loads a partial Spring context with @ExtendWith(SpringExtension) and @MockBean. Service-layer tests verify business logic with real Spring wiring.

Lesson 1 • Containerising with Docker

Creates optimized Docker images using layered JARs and multi-stage builds. Containers standardize the runtime environment and simplify orchestration.

Lesson 2 • Structured Logging and Distributed Tracing

Configures Logback for structured JSON logs and adds trace IDs with Micrometer Tracing. Correlated logs and traces accelerate root-cause analysis in distributed systems.

Lesson 3 • Packaging and Running the Application

Builds executable JARs and WARs and configures JVM startup options. Correct packaging ensures the app runs identically across all deployment targets.

Lesson 4 • Performance Tuning and Caching

Applies Spring Cache abstraction, connection pool tuning, and async processing. These optimizations reduce latency and increase throughput under production load.