[Spring Boot Basics] Transaction trong Spring Boot: @Transactional là gì, đặt ở đâu và khi nào rollback

spring.application.name=demo
spring.jpa.open-in-view=false
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.springframework.orm.jpa.JpaTransactionManager=DEBUG 

spring.datasource.url=jdbc:postgresql://localhost:55430/shop
spring.datasource.username=shop
spring.datasource.password=secret
spring.jpa.hibernate.ddl-auto=create

docker run -d --name sb-a30-pg -e POSTGRES_USER=shop -e POSTGRES_PASSWORD=secret -e POSTGRES_DB=shop -p 55430:5432 postgres:18

./gradlew -q bootJar

java -jar build/libs/demo-0.0.1-SNAPSHOT.jar --server.port=8130 --spring.profiles.active=postgres '--logging.pattern.console=%logger{0}: %msg%n'

docker exec sb-a30-pg psql -U shop -d shop -c 'select id, sku, stock from products order by id' -c 'select (select count(*) from orders) as orders, (select count(*) from order_lines) as order_lines'

    @Transactional
    public Order place(Long customerId, List<OrderItem> items) {
        Customer customer = customers.findById(customerId)
                .orElseThrow(() -> new CustomerNotFoundException(customerId));
        Order order = new Order(customer);
        for (OrderItem item : items) {
            Product product = productService.reserveStock(item.productId(), item.quantity());
            order.addLine(new OrderLine(product, item.quantity()));
        }
        return orders.save(order);
    }

curl -i -s -H 'Content-Type: application/json' -d '{"lines":[{"productId":1,"quantity":2},{"productId":3,"quantity":1}]}' http://localhost:8130/api/customers/1/orders

HTTP/1.1 201
Location: http://localhost:8130/api/orders/1
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sun, 13 Sep 2026 10:34:44 GMT
 
{"id":1,"customerId":1,"lines":[{"productId":1,"quantity":2,"unitPrice":89.90,"lineTotal":179.80},{"productId":3,"quantity":1,"unitPrice":39.00,"lineTotal":39.00}],"total":218.80}

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |    10
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      1 |           2
(1 row)

JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select c1_0.id,c1_0.email from customers c1_0 where c1_0.id=?
SQL: select cp1_0.id,cp1_0.customer_id,cp1_0.full_name,cp1_0.phone from customer_profiles cp1_0 where cp1_0.customer_id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.save]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
SQL: insert into orders (customer_id) values (?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
JpaTransactionManager: Initiating transaction commit

    public Product reserveStock(Long id, int quantity) {
        Product product = findById(id);
        if (product.getStock() < quantity) {
            throw new InsufficientStockException(product.getSku(), product.getStock(), quantity);
        }
        product.setStock(product.getStock() - quantity);
        return product; 
        return products.save(product); 
    }

curl -i -s -H 'Content-Type: application/json' -d '{"lines":[{"productId":1,"quantity":2},{"productId":2,"quantity":3}]}' http://localhost:8130/api/customers/1/orders

HTTP/1.1 409
Content-Type: application/problem+json
Transfer-Encoding: chunked
Date: Sun, 13 Sep 2026 10:35:53 GMT
 
{"detail":"Only 1 of MS-01 in stock, 3 requested","instance":"/api/customers/1/orders","status":409,"title":"Conflict"}

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |     8
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      0 |           0
(1 row)

JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select c1_0.id,c1_0.email from customers c1_0 where c1_0.id=?
SQL: select cp1_0.id,cp1_0.customer_id,cp1_0.full_name,cp1_0.phone from customer_profiles cp1_0 where cp1_0.customer_id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.save]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit

    @Transactional
    public Order place(Long customerId, List<OrderItem> items) {

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |    10
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      0 |           0
(1 row)

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |     8
  2 | MS-01  |     1
  3 | HUB-07 |     4
(3 rows)
 
 orders | order_lines
--------+-------------
      1 |           2
(1 row)

java -jar build/libs/demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=postgres,lab --spring.main.web-application-type=none '--logging.pattern.console=%logger{0}: %msg%n'

    @Override
    public void run(ApplicationArguments args) throws Exception {
        context.getBeansOfType(PlatformTransactionManager.class)
                .forEach((name, bean) -> log.info("PlatformTransactionManager bean: {} -> {}", name, bean.getClass().getName()));
        log.info("transactionManager defined in: {}", context.getBeanFactory().getBeanDefinition("transactionManager").getResourceDescription());
        log.info("TransactionTemplate beans: {}", Arrays.toString(context.getBeanNamesForType(TransactionTemplate.class)));
        log.info("OrderService bean class: {}", orderService.getClass().getName());
        log.info("its superclass: {}", orderService.getClass().getSuperclass().getName());
        log.info("AopUtils.isCglibProxy: {}", AopUtils.isCglibProxy(orderService));
        // the demonstrations of the later sections follow
    }
 
    private List<String> stocks() {
        return jdbcClient.sql("select sku, stock from products order by id")
                .query((rs, n) -> rs.getString(1) + "=" + rs.getInt(2))
                .list();
    }

TransactionLab: PlatformTransactionManager bean: transactionManager -> org.springframework.orm.jpa.JpaTransactionManager
TransactionLab: transactionManager defined in: class path resource [org/springframework/boot/hibernate/autoconfigure/HibernateJpaConfiguration.class]
TransactionLab: TransactionTemplate beans: [transactionTemplate]

JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.place]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(1757141441<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@282a596e]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1757141441<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select c1_0.id,c1_0.email from customers c1_0 where c1_0.id=?
SQL: select cp1_0.id,cp1_0.customer_id,cp1_0.full_name,cp1_0.phone from customer_profiles cp1_0 where cp1_0.customer_id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1757141441<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1757141441<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1757141441<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction rollback
JpaTransactionManager: Rolling back JPA transaction on EntityManager [SessionImpl(1757141441<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction

JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1945821582<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: insert into orders (customer_id) values (?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(1945821582<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction

TransactionLab: OrderService bean class: com.example.demo.order.OrderService$$SpringCGLIB$$0
TransactionLab: its superclass: com.example.demo.order.OrderService
TransactionLab: AopUtils.isCglibProxy: true

javap -v -cp spring-data-jpa-4.1.1.jar org.springframework.data.jpa.repository.support.SimpleJpaRepository

package com.example.demo.lab;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
 
@Component
@Profile("lab")
public class RepositoryCalls {
 
    private static final Logger log = LoggerFactory.getLogger(RepositoryCalls.class);
 
    private final ProductRepository products;
 
    RepositoryCalls(ProductRepository products) {
        this.products = products;
    }
 
    public void readWithoutTransaction() {
        Product keyboard = products.findById(1L).orElseThrow();
        Product mouse = products.findById(2L).orElseThrow();
        long count = products.count();
        log.info("{}, {}, {} products", keyboard.getSku(), mouse.getSku(), count);
    }
 
    @Transactional
    public void readInOneTransaction() {
        Product keyboard = products.findById(1L).orElseThrow();
        Product mouse = products.findById(2L).orElseThrow();
        long count = products.count();
        log.info("{}, {}, {} products", keyboard.getSku(), mouse.getSku(), count);
    }
}

JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(38669275<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@1495f70]
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(38669275<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(952876299<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@56a34c0e]
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(952876299<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.count]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(640592192<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@6aa152b7]
SQL: select count(*) from products p1_0
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(640592192<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
RepositoryCalls: KB-01, MS-01, 3 products

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.RepositoryCalls.readInOneTransaction]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(319123198<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@121ec5c2]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(319123198<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(319123198<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(319123198<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select count(*) from products p1_0
RepositoryCalls: KB-01, MS-01, 3 products
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(319123198<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction

@Service
@Transactional(readOnly = true) 
public class OrderService {
 
    // fields and constructor unchanged
 
    @Transactional
    public Order place(Long customerId, List<OrderItem> items) {
        // unchanged
    }
 
    @Transactional(readOnly = true) 
    public Order findById(Long id) {
        return orders.findWithLinesById(id).orElseThrow(() -> new OrderNotFoundException(id));
    }
 
    @Transactional(readOnly = true) 
    public List<Order> findAll() {
        return orders.findAllWithLines();
    }
}

JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.place]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Initiating transaction rollback

public class InsufficientStockException extends RuntimeException { 
public class InsufficientStockException extends Exception { 

    public Product reserveStock(Long id, int quantity) { 
    public Product reserveStock(Long id, int quantity) throws InsufficientStockException { 

    @Transactional
    public Order place(Long customerId, List<OrderItem> items) { 
    public Order place(Long customerId, List<OrderItem> items) throws InsufficientStockException { 

    @PostMapping("/api/customers/{customerId}/orders")
    public ResponseEntity<OrderResponse> place(@PathVariable Long customerId,
                                               @Valid @RequestBody PlaceOrderRequest request) { 
                                               @Valid @RequestBody PlaceOrderRequest request) throws InsufficientStockException { 

    @ExceptionHandler(InsufficientStockException.class)
    public ProblemDetail conflict(RuntimeException e) { 
    public ProblemDetail conflict(Exception e) { 

SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(43570430<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |     8
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      0 |           0
(1 row)

    @Transactional
    @Transactional(rollbackFor = InsufficientStockException.class) 
    public Order place(Long customerId, List<OrderItem> items) throws InsufficientStockException {

JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.place]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-com.example.demo.product.InsufficientStockException
JpaTransactionManager: Initiating transaction rollback
JpaTransactionManager: Rolling back JPA transaction on EntityManager [SessionImpl(750252235<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction

    @Transactional(noRollbackFor = InsufficientStockException.class)
    public void reserveUpTo(Long productId, int quantity) {
        Product product = products.findById(productId).orElseThrow();
        int reserved = Math.min(product.getStock(), quantity);
        product.setStock(product.getStock() - reserved);
        if (reserved < quantity) {
            throw new InsufficientStockException(product.getSku(), reserved, quantity);
        }
    }

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.RollbackRulesLab.reserveUpTo]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,+com.example.demo.product.InsufficientStockException
JpaTransactionManager: Opened new EntityManager [SessionImpl(1244881865<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@63cf6497]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1244881865<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(1244881865<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: threw com.example.demo.product.InsufficientStockException: Only 1 of MS-01 in stock, 3 requested
TransactionLab: stocks after: [KB-01=12, MS-01=0, HUB-07=9]

public class InsufficientStockException extends Exception { 
public class InsufficientStockException extends RuntimeException { 

    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
 
    // ...
 
    @Transactional
    public Order placeAvailable(Long customerId, List<OrderItem> items) {
        Customer customer = customers.findById(customerId)
                .orElseThrow(() -> new CustomerNotFoundException(customerId));
        Order order = new Order(customer);
        for (OrderItem item : items) {
            try {
                Product product = productService.reserveStock(item.productId(), item.quantity());
                order.addLine(new OrderLine(product, item.quantity()));
            } catch (InsufficientStockException e) {
                log.info("Skipping a line: {}", e.getMessage());
            }
        }
        return orders.save(order);
    }

    @PostMapping("/api/customers/{customerId}/orders")
    public ResponseEntity<OrderResponse> place(@PathVariable Long customerId,
                                               @RequestParam(defaultValue = "false") boolean skipUnavailable, 
                                               @Valid @RequestBody PlaceOrderRequest request) {
        List<OrderItem> items = request.lines().stream()
                .map(line -> new OrderItem(line.productId(), line.quantity()))
                .toList();
        Order order = service.place(customerId, items); 
        Order order = skipUnavailable 
                ? service.placeAvailable(customerId, items) 
                : service.place(customerId, items); 

curl -i -s -H 'Content-Type: application/json' -d '{"lines":[{"productId":1,"quantity":2},{"productId":2,"quantity":3}]}' 'http://localhost:8130/api/customers/1/orders?skipUnavailable=true'

HTTP/1.1 201
Location: http://localhost:8130/api/orders/1
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sun, 13 Sep 2026 10:45:42 GMT
 
{"id":1,"customerId":1,"lines":[{"productId":1,"quantity":2,"unitPrice":89.90,"lineTotal":179.80}],"total":179.80}

JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.placeAvailable]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@101954ff]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select c1_0.id,c1_0.email from customers c1_0 where c1_0.id=?
SQL: select cp1_0.id,cp1_0.customer_id,cp1_0.full_name,cp1_0.phone from customer_profiles cp1_0 where cp1_0.customer_id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
OrderService: Skipping a line: Only 1 of MS-01 in stock, 3 requested
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(306657394<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: insert into orders (customer_id) values (?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(306657394<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |     8
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      1 |           1
(1 row)

    @Transactional(readOnly = true)
    public void changeStock(Long productId) {
        Product product = products.findById(productId).orElseThrow();
        product.setStock(product.getStock() + 100);
        log.info("stock of {} set to {} on a managed entity", product.getSku(), product.getStock());
    }

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.ReadOnlyLab.changeStock]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(291728707<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@753b6846]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(291728707<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
ReadOnlyLab: stock of KB-01 set to 110 on a managed entity
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(291728707<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: stocks after: [KB-01=10, MS-01=1, HUB-07=5]

    @Transactional(readOnly = true)
    public void saveNewProduct() {
        String readOnly = jdbcClient.sql("select current_setting('transaction_read_only')").query(String.class).single();
        log.info("transaction_read_only = {}", readOnly);
        Category keyboards = categories.findById(1L).orElseThrow();
        products.save(new Product("Compact keyboard", "KB-02", new BigDecimal("59.00"), 5, keyboards));
    }

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.ReadOnlyLab.saveNewProduct]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(107240479<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@237e4ed9]
ReadOnlyLab: transaction_read_only = on
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(107240479<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select c1_0.id,c1_0.name from categories c1_0 where c1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(107240479<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: insert into products (category_id,name,price,sku,stock) values (?,?,?,?,?)
error: HHH000247: ErrorCode: 0, SQLState: 25006
error: ERROR: cannot execute INSERT in a read-only transaction
JpaTransactionManager: Participating transaction failed - marking existing transaction as rollback-only
JpaTransactionManager: Setting JPA transaction on EntityManager [SessionImpl(107240479<open>)] rollback-only
JpaTransactionManager: Initiating transaction rollback
JpaTransactionManager: Rolling back JPA transaction on EntityManager [SessionImpl(107240479<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction

TransactionLab:   org.springframework.orm.jpa.JpaSystemException: could not execute statement [ERROR: cannot execute INSERT in a read-only transaction] [insert into products (category_id,name,price,sku,stock) values (?,?,?,?,?)]
TransactionLab:   org.hibernate.exception.GenericJDBCException: could not execute statement [ERROR: cannot execute INSERT in a read-only transaction] [insert into products (category_id,name,price,sku,stock) values (?,?,?,?,?)]
TransactionLab:   org.postgresql.util.PSQLException: ERROR: cannot execute INSERT in a read-only transaction

package com.example.demo.lab;
 
import java.util.List;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
 
@Component
@Profile("lab")
public class Restocker {
 
    private static final Logger log = LoggerFactory.getLogger(Restocker.class);
 
    private final ProductRepository products;
 
    Restocker(ProductRepository products) {
        this.products = products;
    }
 
    public void restockAll(List<Long> productIds, int quantity) {
        for (Long productId : productIds) {
            restock(productId, quantity);
        }
    }
 
    @Transactional
    public void restockAllInOneTransaction(List<Long> productIds, int quantity) {
        for (Long productId : productIds) {
            restock(productId, quantity);
        }
    }
 
    @Transactional
    public void restock(Long productId, int quantity) {
        log.info("restock({}, {}): transaction active = {}", productId, quantity,
                TransactionSynchronizationManager.isActualTransactionActive());
        Product product = products.findById(productId).orElseThrow();
        product.setStock(product.getStock() + quantity);
    }
}

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.Restocker.restock]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(476119323<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@75af5f2a]
Restocker: restock(3, 1): transaction active = true
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(476119323<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(476119323<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: stocks after: [KB-01=10, MS-01=1, HUB-07=6]

Restocker: restock(1, 1): transaction active = false
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(1007392323<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@746f1505]
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(1007392323<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
Restocker: restock(3, 1): transaction active = false
JpaTransactionManager: Creating new transaction with name [org.springframework.data.jpa.repository.support.SimpleJpaRepository.findById]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly
JpaTransactionManager: Opened new EntityManager [SessionImpl(1089993541<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@4c3c1963]
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(1089993541<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: stocks after: [KB-01=10, MS-01=1, HUB-07=6]

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.Restocker.restockAllInOneTransaction]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Restocker: restock(1, 1): transaction active = true
Restocker: restock(3, 1): transaction active = true
JpaTransactionManager: Initiating transaction commit
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
TransactionLab: stocks after: [KB-01=12, MS-01=1, HUB-07=8]

package com.example.demo.lab;
 
import java.util.List;
 
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
 
@Component
@Profile("lab")
public class RestockBatch {
 
    private final Restocker restocker;
 
    RestockBatch(Restocker restocker) {
        this.restocker = restocker;
    }
 
    public void restockAll(List<Long> productIds, int quantity) {
        for (Long productId : productIds) {
            restocker.restock(productId, quantity);
        }
    }
}

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.Restocker.restock]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Restocker: restock(1, 1): transaction active = true
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.Restocker.restock]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Restocker: restock(3, 1): transaction active = true
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
TransactionLab: stocks after: [KB-01=11, MS-01=1, HUB-07=7]

package com.example.demo.lab;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
 
@Component
@Profile("lab")
public class VisibilityLab {
 
    private static final Logger log = LoggerFactory.getLogger(VisibilityLab.class);
 
    @Transactional
    public void publicMethod() {
        report("public");
    }
 
    @Transactional
    protected void protectedMethod() {
        report("protected");
    }
 
    @Transactional
    void packagePrivateMethod() {
        report("package-private");
    }
 
    @Transactional
    private void privateMethod() {
        report("private");
    }
 
    private static void report(String visibility) {
        log.info("{} method: transaction active = {}", visibility,
                TransactionSynchronizationManager.isActualTransactionActive());
    }
}

        log.info("bean class: {}", visibilityLab.getClass().getName());
        for (Method m : VisibilityLab.class.getDeclaredMethods()) {
            if (!m.getName().endsWith("Method")) continue;
            boolean overridden = Arrays.stream(visibilityLab.getClass().getDeclaredMethods())
                    .anyMatch(p -> p.getName().equals(m.getName()));
            log.info("{} {}: overridden by the proxy class = {}", Modifier.toString(m.getModifiers()), m.getName(), overridden);
        }
        visibilityLab.publicMethod();
        visibilityLab.protectedMethod();
        visibilityLab.packagePrivateMethod();
        Method privateMethod = VisibilityLab.class.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);
        try {
            privateMethod.invoke(visibilityLab);
        } catch (InvocationTargetException e) {
            chain(e.getCause());
        }

TransactionLab: bean class: com.example.demo.lab.VisibilityLab$$SpringCGLIB$$0
TransactionLab: protected protectedMethod: overridden by the proxy class = true
TransactionLab:  packagePrivateMethod: overridden by the proxy class = true
TransactionLab: public publicMethod: overridden by the proxy class = true
TransactionLab: private privateMethod: overridden by the proxy class = false
JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.VisibilityLab.publicMethod]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
VisibilityLab: public method: transaction active = true
JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.VisibilityLab.protectedMethod]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
VisibilityLab: protected method: transaction active = true
JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.VisibilityLab.packagePrivateMethod]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
VisibilityLab: package-private method: transaction active = true
VisibilityLab: private method: transaction active = false

javap -c -p -cp spring-tx-7.0.9.jar org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource

  protected org.springframework.transaction.interceptor.TransactionAttribute computeTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>);
    Code:
       0: aload_0
       1: invokevirtual #111                // Method allowPublicMethodsOnly:()Z
       4: ifeq          19
       7: aload_1
       8: invokevirtual #114                // Method java/lang/reflect/Method.getModifiers:()I
      11: invokestatic  #120                // Method java/lang/reflect/Modifier.isPublic:(I)Z
      14: ifne          19
      17: aconst_null
      18: areturn

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; 
 
@Service
public class ProductService {
 
    // ...
 
    @Transactional
    public Product reserveStock(Long id, int quantity) {

curl -i -s -H 'Content-Type: application/json' -d '{"lines":[{"productId":1,"quantity":2},{"productId":2,"quantity":3}]}' 'http://localhost:8130/api/customers/1/orders?skipUnavailable=true'

HTTP/1.1 500
Content-Type: application/json
Transfer-Encoding: chunked
Date: Mon, 14 Sep 2026 02:45:35 GMT
Connection: close
 
{"timestamp":"2026-09-14T02:45:35.323Z","status":500,"error":"Internal Server Error","path":"/api/customers/1/orders"}

JpaTransactionManager: Creating new transaction with name [com.example.demo.order.OrderService.placeAvailable]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@5b68556]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select c1_0.id,c1_0.email from customers c1_0 where c1_0.id=?
SQL: select cp1_0.id,cp1_0.customer_id,cp1_0.full_name,cp1_0.phone from customer_profiles cp1_0 where cp1_0.customer_id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Participating transaction failed - marking existing transaction as rollback-only
JpaTransactionManager: Setting JPA transaction on EntityManager [SessionImpl(1114214325<open>)] rollback-only
OrderService: Skipping a line: Only 1 of MS-01 in stock, 3 requested
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1114214325<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: insert into orders (customer_id) values (?)
SQL: insert into order_lines (order_id,product_id,quantity,unit_price) values (?,?,?,?)
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(1114214325<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
[dispatcherServlet]: Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only] with root cause
org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only

 id |  sku   | stock
----+--------+-------
  1 | KB-01  |    10
  2 | MS-01  |     1
  3 | HUB-07 |     5
(3 rows)
 
 orders | order_lines
--------+-------------
      0 |           0
(1 row)

    @Transactional
    public void saveDuplicateSkuAndCatch() {
        Category keyboards = categories.findById(1L).orElseThrow();
        try {
            products.save(new Product("Keyboard copy", "KB-01", new BigDecimal("79.00"), 1, keyboards));
        } catch (DataIntegrityViolationException e) {
            log.info("caught {}", e.getClass().getName());
        }
    }

SQL: insert into products (category_id,name,price,sku,stock) values (?,?,?,?,?)
error: HHH000247: ErrorCode: 0, SQLState: 23505
error: ERROR: duplicate key value violates unique constraint "products_sku_key"
  Detail: Key (sku)=(KB-01) already exists.
JpaTransactionManager: Participating transaction failed - marking existing transaction as rollback-only
JpaTransactionManager: Setting JPA transaction on EntityManager [SessionImpl(483248328<open>)] rollback-only
RollbackRulesLab: caught org.springframework.dao.DataIntegrityViolationException
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(483248328<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: threw org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only

./gradlew dependencies --configuration compileClasspath

|    |    |    +--- org.hibernate.orm:hibernate-core:7.4.5.Final
|    |    |    |    +--- org.hibernate.orm:hibernate-platform:7.4.5.Final
|    |    |    |    |    +--- org.hibernate.orm:hibernate-core:7.4.5.Final (c)
|    |    |    |    |    +--- jakarta.persistence:jakarta.persistence-api:3.2.0 (c)
|    |    |    |    |    \--- jakarta.transaction:jakarta.transaction-api:2.0.1 (c)
|    |    |    |    +--- jakarta.persistence:jakarta.persistence-api:3.2.0
|    |    |    |    \--- jakarta.transaction:jakarta.transaction-api:2.0.1

javap -cp spring-tx-7.0.9.jar org.springframework.transaction.annotation.Transactional

Compiled from "Transactional.java"
public interface org.springframework.transaction.annotation.Transactional extends java.lang.annotation.Annotation {
  public abstract java.lang.String value();
  public abstract java.lang.String transactionManager();
  public abstract java.lang.String[] label();
  public abstract org.springframework.transaction.annotation.Propagation propagation();
  public abstract org.springframework.transaction.annotation.Isolation isolation();
  public abstract int timeout();
  public abstract java.lang.String timeoutString();
  public abstract boolean readOnly();
  public abstract java.lang.Class<? extends java.lang.Throwable>[] rollbackFor();
  public abstract java.lang.String[] rollbackForClassName();
  public abstract java.lang.Class<? extends java.lang.Throwable>[] noRollbackFor();
  public abstract java.lang.String[] noRollbackForClassName();
}

javap -cp jakarta.transaction-api-2.0.1.jar jakarta.transaction.Transactional

Compiled from "Transactional.java"
public interface jakarta.transaction.Transactional extends java.lang.annotation.Annotation {
  public abstract jakarta.transaction.Transactional$TxType value();
  public abstract java.lang.Class[] rollbackOn();
  public abstract java.lang.Class[] dontRollbackOn();
}

package com.example.demo.lab;
 
import java.io.IOException;
 
import com.example.demo.product.Product;
import com.example.demo.product.ProductRepository;
 
import jakarta.transaction.Transactional;
 
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
 
@Component
@Profile("lab")
public class JakartaLab {
 
    private final ProductRepository products;
 
    JakartaLab(ProductRepository products) {
        this.products = products;
    }
 
    @Transactional
    public void importStock(Long productId) throws IOException {
        Product product = products.findById(productId).orElseThrow();
        product.setStock(product.getStock() + 1);
        throw new IOException("stock file truncated");
    }
 
    @Transactional(rollbackOn = IOException.class)
    public void importStockRollbackOn(Long productId) throws IOException {
        Product product = products.findById(productId).orElseThrow();
        product.setStock(product.getStock() + 1);
        throw new IOException("stock file truncated");
    }
}

JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.JakartaLab.importStock]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Initiating transaction commit
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
TransactionLab: threw java.io.IOException: stock file truncated
TransactionLab: stocks after: [KB-01=12, MS-01=1, HUB-07=9]
JpaTransactionManager: Creating new transaction with name [com.example.demo.lab.JakartaLab.importStockRollbackOn]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-java.io.IOException
JpaTransactionManager: Initiating transaction rollback
TransactionLab: threw java.io.IOException: stock file truncated
TransactionLab: stocks after: [KB-01=12, MS-01=1, HUB-07=9]

        Integer stock = transactionTemplate.execute(status -> {
            Product hub = products.findById(3L).orElseThrow();
            hub.setStock(hub.getStock() + 10);
            return hub.getStock();
        });
        log.info("execute returned {}, stocks after: {}", stock, stocks());
 
        transactionTemplate.executeWithoutResult(status -> {
            Product hub = products.findById(3L).orElseThrow();
            hub.setStock(0);
            status.setRollbackOnly();
        });
        log.info("stocks after: {}", stocks());

JpaTransactionManager: Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(897736003<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@5f84e764]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(897736003<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Initiating transaction commit
JpaTransactionManager: Committing JPA transaction on EntityManager [SessionImpl(897736003<open>)]
SQL: update products set category_id=?,name=?,price=?,sku=?,stock=? where id=?
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: execute returned 19, stocks after: [KB-01=12, MS-01=0, HUB-07=19]
JpaTransactionManager: Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
JpaTransactionManager: Opened new EntityManager [SessionImpl(1244172753<open>)] for JPA transaction
JpaTransactionManager: Exposing JPA transaction as JDBC [org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle@7b6d88d1]
JpaTransactionManager: Found thread-bound EntityManager [SessionImpl(1244172753<open>)] for JPA transaction
JpaTransactionManager: Participating in existing transaction
SQL: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.sku,p1_0.stock from products p1_0 where p1_0.id=?
JpaTransactionManager: Transactional code has requested rollback
JpaTransactionManager: Initiating transaction rollback
JpaTransactionManager: Rolling back JPA transaction on EntityManager [SessionImpl(1244172753<open>)]
JpaTransactionManager: Closing JPA EntityManager after transaction
TransactionLab: stocks after: [KB-01=12, MS-01=0, HUB-07=19]