Understanding the Mechanics of Spring Transactions

In Spring, a transaction represents a series of operations executed as a single logical unit. With Spring’s declarative transaction management, developers can specify transactional behavior through annotations applied to methods or classes, offering a streamlined approach to managing transactions.

Sample Scenario: Product Management in E-Commerce

To illustrate the concept, let's analyze a situation where we manage products within an e-commerce platform. We will look into various transaction propagation levels to comprehend their effects on data consistency and isolation.

Code Implementation

Product Entity:

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

@Entity

public class Product {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String name;

private double price;

// Constructors, getters, setters, etc.

public Product() {

}

public Product(String name, double price) {

this.name = name;

this.price = price;

}

// Getters and setters

}

ProductRepository.java:

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {

// Custom repository methods if needed

}

ProductService.java:

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

@Service

public class ProductService {

@Autowired

private ProductRepository productRepository;

@Transactional(propagation = Propagation.REQUIRED)

public void requiredTransaction() {

productRepository.save(new Product("Laptop", 1200.00));

}

@Transactional(propagation = Propagation.REQUIRES_NEW)

public void requiresNewTransaction() {

productRepository.save(new Product("Mobile Phone", 500.00));

}

@Transactional(propagation = Propagation.NESTED)

public void nestedTransaction() {

productRepository.save(new Product("Tablet", 300.00));

}

@Transactional(propagation = Propagation.SUPPORTS)

public void supportsTransaction() {

productRepository.save(new Product("Smartwatch", 150.00));

}

@Transactional(propagation = Propagation.NOT_SUPPORTED)

public void notSupportedTransaction() {

productRepository.save(new Product("Headphones", 50.00));

}

@Transactional(propagation = Propagation.MANDATORY)

public void mandatoryTransaction() {

productRepository.save(new Product("Camera", 800.00));

}

@Transactional(propagation = Propagation.NEVER)

public void neverTransaction() {

productRepository.save(new Product("Printer", 250.00));

}

}

ProductController.java:

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/products")

public class ProductController {

@Autowired

private ProductService productService;

@GetMapping("/required")

public String requiredTransaction() {

productService.requiredTransaction();

return "Product added using REQUIRED Transaction";

}

@GetMapping("/requiresNew")

public String requiresNewTransaction() {

productService.requiresNewTransaction();

return "Product added using REQUIRES_NEW Transaction";

}

@GetMapping("/nested")

public String nestedTransaction() {

productService.nestedTransaction();

return "Product added using NESTED Transaction";

}

@GetMapping("/supports")

public String supportsTransaction() {

productService.supportsTransaction();

return "Product added using SUPPORTS Transaction";

}

@GetMapping("/notSupported")

public String notSupportedTransaction() {

productService.notSupportedTransaction();

return "Product added using NOT_SUPPORTED Transaction";

}

@GetMapping("/mandatory")

public String mandatoryTransaction() {

productService.mandatoryTransaction();

return "Product added using MANDATORY Transaction";

}

@GetMapping("/never")

public String neverTransaction() {

productService.neverTransaction();

return "Product added using NEVER Transaction";

}

}

Understanding When to Apply Different Propagation Levels

• REQUIRED: Utilize when you want the method to join an existing transaction or create a new one if none exists.
• REQUIRES_NEW: Opt for this when you need the method to initiate a new transaction, pausing the existing one if applicable.
• NESTED: Choose this when the method should run within a nested transaction if there’s a current transaction; otherwise, start a new one.
• SUPPORTS: Use this for methods that should participate in an existing transaction if available; otherwise, operate without one.
• NOT_SUPPORTED: Select this when you need the method to run outside of a transaction, suspending any existing ones.
• MANDATORY: Apply this when the method should join an existing transaction; if none exists, an exception will be thrown.
• NEVER: Use when you want the method to operate outside of a transaction; if a transaction is present, an exception is raised.