Java Spring Course

Lesson 1 • Setting Up the Development Environment

Guides installation of JDK, IDE, Maven or Gradle, and Spring Initializr. Produces a working local environment ready for all subsequent labs.

Lesson 2 • Introduction to the Spring Framework

Explains Spring's history, modules, and design philosophy. Positions Spring as a solution to enterprise Java complexity.

Lesson 3 • Build Tools and Project Structure

Covers Maven POM and Gradle build scripts, dependency scopes, and standard project layouts. Enables students to manage dependencies confidently.

Lesson 1 • Bean Scopes and Lifecycle Hooks

Explains singleton, prototype, request, and session scopes and their appropriate use cases. Covers @PostConstruct, @PreDestroy, and custom lifecycle callbacks.

Lesson 2 • IoC Container Concepts

Defines inversion of control and explains how the Spring container manages object lifecycles. Establishes the mental model needed for all bean configuration work.

Lesson 3 • Externalized Configuration with @Value and Profiles

Demonstrates injecting property values and activating environment-specific beans via profiles. Prepares students for multi-environment deployments.

Lesson 4 • Defining and Registering Beans

Covers XML bean definitions, stereotype annotations, and Java-based @Configuration classes. Students register beans using all three approaches.

Lesson 1 • AOP Concepts and Terminology

Defines join points, pointcuts, advice types, and aspects. Establishes vocabulary required to read and write AOP configurations correctly.

Lesson 2 • Implementing Aspects with @AspectJ

Guides creation of @Aspect classes with @Before, @After, @Around, and @AfterThrowing advice. Students write reusable aspects for logging and validation.

Lesson 3 • Pointcut Expressions and Reuse

Teaches pointcut expression syntax for method, annotation, and bean matching. Covers named pointcuts for reuse across multiple advice methods.

Lesson 1 • Validation and Error Handling

Applies Bean Validation annotations and @Valid to incoming data, then handles errors globally. Students build consistent error responses across all endpoints.

Lesson 2 • Request and Response Handling

Teaches @RequestBody, @ResponseBody, ResponseEntity, and HTTP status codes. Connects serialization to Jackson and content negotiation.

Lesson 3 • Controllers and Request Mapping

Covers @Controller, @RestController, and @RequestMapping variants for routing HTTP requests. Students map GET, POST, PUT, and DELETE operations.

Lesson 4 • Spring MVC Architecture

Traces an HTTP request through DispatcherServlet, handler mappings, and view resolvers. Provides the architectural foundation for all web layer work.

Lesson 1 • Transaction Management

Explains declarative and programmatic transaction management with @Transactional. Covers propagation, isolation levels, and rollback rules.

Lesson 2 • JPA and Hibernate Fundamentals

Introduces the JPA specification, entity lifecycle, and Hibernate as the default provider. Establishes ORM concepts before Spring Data abstractions are applied.

Lesson 3 • Spring Data JPA Repositories

Demonstrates JpaRepository, CrudRepository, and derived query methods. Students eliminate boilerplate DAO code using Spring Data conventions.

Lesson 4 • Entity Mapping and Relationships

Maps database tables to entities using column, table, and relationship annotations. Covers one-to-one, one-to-many, and many-to-many associations.

Lesson 1 • Spring Boot Actuator Endpoints

Enables and secures Actuator endpoints for health, metrics, info, and environment inspection. Connects observability data to monitoring systems.

Lesson 2 • Custom Auto-Configuration and Starters

Guides creation of custom auto-configuration classes and reusable starter modules. Enables teams to share infrastructure configuration across projects.

Lesson 3 • Spring Boot Auto-Configuration Internals

Explains @SpringBootApplication, @EnableAutoConfiguration, and the conditions that activate auto-config classes. Students understand what Spring Boot configures automatically.

Lesson 4 • Embedded Servers and Deployment

Configures embedded Tomcat, Jetty, and Undertow and packages applications as executable JARs or WARs. Prepares students for containerized and traditional deployments.

Lesson 1 • CSRF, CORS, and Security Testing

Manages CSRF protection, configures CORS policies, and writes security-focused integration tests. Closes common web security gaps in REST APIs.

Lesson 2 • Authorization and Access Control

Applies URL-based and method-level authorization using roles and expressions. Covers @PreAuthorize, @PostAuthorize, and SpEL security expressions.

Lesson 3 • Spring Security Architecture

Explains the security filter chain, SecurityContext, and authentication manager hierarchy. Provides the structural foundation for all security configuration decisions.

Lesson 4 • Configuring Authentication

Implements in-memory, JDBC, and custom UserDetailsService authentication. Students configure password encoding and user storage strategies.

Lesson 1 • Test Coverage and Quality Metrics

Measures coverage with JaCoCo, enforces thresholds in the build, and interprets coverage reports. Connects test quality to CI pipeline gates.

Lesson 2 • Test Containers and Database Testing

Runs real database instances in Docker via Testcontainers for realistic persistence tests. Eliminates discrepancies between in-memory and production database behavior.

Lesson 3 • Unit Testing with JUnit 5 and Mockito

Covers JUnit 5 annotations, assertions, and Mockito mocking for isolated unit tests. Establishes fast, dependency-free tests for service and utility classes.

Lesson 4 • Integration Testing with @SpringBootTest

Loads the full application context for end-to-end integration tests using TestRestTemplate and MockMvc. Validates component interactions across layers.