Spring Transactions In-Depth

Explore the Spring framework and its principles, including inversion of control and dependency injection. Create a Spring Boot application with CRUD operations, API calls, and three layered architecture.

Explore dependency injection and inversion of control in spring, wire services with constructor injection, manage beans via the application context, and validate correct bean instances in tests.

Learn how Java annotations serve as metadata for source code, compiler, and runtime, and how Spring annotations like Component, Controller, Service, Repository, and Bean enable bean mapping and configuration. Create a custom simple logger annotation with runtime retention, apply it to a method, and implement a simple before-and-after aspect that logs execution in a Spring Boot example.

Build your first Spring Boot project from start.spring.io with Maven and Java, adding Spring Web and an embedded Tomcat. Run the standalone jar and verify the server on localhost:8080.

Build a Spring Boot MVC REST controller to manage users at /users, implementing get, post, put, and delete operations with JSON responses and user domain, payload DTO, and Postman testing.

Introduce a user service interface and impl, register as a spring bean, and delegate get all users, get user, create, update, and delete to the service via IoC.

Refactor the service layer into a repository layer, implement a user repository with findAll, findById, save, and deleteById, and move ID generation to the repository.

Configure an H2 in-memory database with file persistence for Spring Data JPA, enabling data to survive restarts and access via the H2 console.

Explore how a database transaction acts as a single unit of work, guaranteed by atomicity, consistency, isolation, and durability, with commit and rollback in practice.

Install Docker and MySQL, run MySQL in a container for integration tests and an Angular app, and use docker run and docker exec with port mappings.

Explore how Spring transaction provides a powerful, high level abstraction for managing database transactions, ensuring data consistency, and simplifying database interaction in Spring Boot applications.

Demystify open session in view (OSIV) by debugging transactions, enabling logs, and monitoring open vs closed connections; learn to disable OSIV in Spring JPA to prevent connection buildup.

Apply transactional annotation to automatically manage transactions in the service layer, ensuring a single cohesive transaction for create category operations and avoiding controller-level misuse.

Implement transactional updates for categories in a Spring Boot app, ensuring consistency and integrity, covering update category, payload usage, transactional annotation, and Hibernate dirty checking.

Learn how read-only transactions prevent unnecessary dirty checking in Hibernate and boost performance, while noting that misusing read-only mode on delete or update stops persistence.

Explore how eager fetching causes the n plus one problem in spring transactions via a product and category relationship; learn hibernate’s default behavior and performance implications.

Implement create and delete product endpoints that link products to categories using a category-aware payload, and apply transactional handling for consistent fetch and delete operations.

Develop the checkout flow by implementing customer, order, and order item entities with repositories and services, then compare checked versus unchecked exceptions and their transaction effects.

Explore transaction boundaries and how threading and async execution affect whether methods run in the same or a new transaction, and why propagation and cross-thread execution impact data consistency.

Examine data inconsistency from transaction boundaries when emails are sent during checkout, illustrating why decoupling persistence from notifications and adopting an event-driven approach with spring events can improve consistency.

Learn how transactional event listeners in spring delay handling until after a commit. Default phase after commit ensures emails and notifications run only after persistence.

Explore edge cases where transactional event listeners don't trigger, adjust order so balance deduction precedes 5% credit, and use propagation phase of before commit or the saga pattern for consistency.

Learn how fallback execution in transactional event listeners lets you react to events outside an active transaction, ensuring data consistency across transactional and non-transactional scenarios.

Explore MySQL isolation levels with docker-based hands-on demos, from read uncommitted to serializable, and observe how commits, rollbacks, and spring transactional annotations affect consistency.