Detailed training program
- Why test a Spring Boot application
- JUnit 6 as the course's working foundation
- AssertJ, Hamcrest, JSONassert, and JsonPath as the assertion language
- Mockito without magic and without a false sense of security
- Unit testing business logic without Spring context
- Spring Boot 4 testing landscape and test annotations map
- Test profiles, properties, and managed test configuration
- JSON tests as a separate API quality layer
- @WebMvcTest as a basic tool for narrow controller testing
- MockMvc and HTTP mechanics without launching a server
- MockMvcTester as a more ergonomic MVC path
- Validation and error handling in controller tests
- Applied MVC scenarios: pagination, files, and boundary cases
- @DataJpaTest and authentic repository-layer testing
- TestEntityManager, flush, clear, and the real-world consequences of JPA mapping
- Queries, pagination, and the bridge to a real database
- Entity relationships, lazy loading, and concurrent scenarios
- Flyway, @Sql, and repeatable test data
- @SpringBootTest and the full context map
- Full-context tests with MockMvc
- Running server integration tests via RestTestClient
- A minimal professional regression suite
- Security testing for a secured Spring Boot API
- Testing external integrations and simple async behavior
- Testcontainers and the real PostgreSQL path
- REST Docs, platform settings, and the final test suite strategy
- Why Hibernate, what we are building, and how to read SQL output
- Entity lifecycle and the persistence context as the foundation of everything else
- Dirty checking and how Hibernate automatically detects object changes
- Flush and exactly when Hibernate decides to hit the database
- Detached objects: what happens to them and how to correctly use merge()
- Lazy loading, proxy objects, and why transaction boundaries matter more than you think
- N+1 using live examples as the first real ORM problem
- JOIN FETCH, EntityGraph, and @BatchSize as tools for intentional data loading
- Entity as a write-model and projection as a read-model in a mature persistence layer
- HQL, Criteria API, and native SQL — three tools and understanding when to use which
- Owning side, cascades, and lifecycle design as the foundation of correct mapping
- Link entity instead of naive ManyToMany — a robust model with control over lifecycle
- equals(), hashCode(), and proxy in collections as a source of silent, costly bugs
- Embeddables, value objects, and converters for an expressive and convenient domain model
- Identifier strategies, natural id, and their actual runtime cost
- Inheritance, @DynamicUpdate, schema constraints, and mature mapping design
- Hibernate inside Spring transactions and transaction boundary at the service level
- Optimistic locking as basic protection against lost updates in business scenarios
- Pessimistic locking as a targeted tool for critical concurrent sections
- Soft delete, filters, and managing data visibility in a real application
- Hibernate Envers as a complete change history without manual audit fields
- Lifecycle callbacks and listeners — a convenient mechanism with hidden side effects
- JDBC batching as a practical way to speed up bulk writes
- Bulk operations and StatelessSession as a way to go beyond the entity model
- Read-only mode, first-level cache, and caching as part of performance thinking
- SQL diagnostics and performance audit as a systematic approach to optimization
- Hibernate under the hood of Spring Data JPA and the limits of abstraction convenience
- ORM integration testing to catch real database layer bugs
- Hibernate anti-patterns and refactoring as preparation for a proper code review
- Final persistence audit, decision framework, and growth roadmap after the course
- Container thinking for the Java/Spring developer and the full course map
- Everyday Docker CLI without DevOps overload
- The first container for a Spring Boot application
- Dockerfile through the eyes of a Java developer
- Layers, cache, and fast image rebuilds
- Multi-stage build as the standard path for Java
- Base images, reproducibility, and platforms
- Layered Spring Boot images on Boot 4.0.3
- Buildpacks and bootBuildImage
- Development target and debug-oriented image
- Externalized configuration inside a containerized Boot application
- Profiles and external configuration files
- Volumes, bind mounts, and file scenarios
- Logs, health, and graceful application shutdown (graceful shutdown)
- Compose as the standard way to live with multiple containers
- The first production-grade setup — app + PostgreSQL
- Startup order and the real readiness model
- Flyway and the local environment lifecycle
- Adding Redis to the same Compose stack
- Adding RabbitMQ without turning the course into a messaging track
- Developer workflow around Compose
- Troubleshooting workshop
- JVM under memory and CPU limits
- Image hygiene, non-root, and the final reusable template
400+
Lessons
700+
Tasks
80
Tests
And also:
- Instant validation
- AI code validator
- IDE plugin
- WebIDE
- Gamification