feat : adds cache invalidation at bi-directional mapping (#1834)

* feat : add more tests related to 2nd level cache

* fix issue with assertions

* feat : Handing cache invalidation at bi-directional mapping

* fix test failures

* attempt 1 to fix the issue

* adds more testcases

Author: rajadilipkolli

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/entities/Customer.java

@@ -1,5 +1,6 @@
 package com.example.hibernatecache.entities;
 
+import jakarta.persistence.Cacheable;
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
@@ -22,6 +23,7 @@
                     name = "uc_customer_email",
                     columnNames = {"email"})
         })
+@Cacheable
 @Cache(region = "customerCache", usage = CacheConcurrencyStrategy.READ_WRITE)
 public class Customer {
 
@@ -40,7 +42,7 @@ public class Customer {
     private String phone;
 
     @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, orphanRemoval = true)
-    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+    @Cache(region = "customerOrdersCache", usage = CacheConcurrencyStrategy.READ_WRITE)
     private List<Order> orders = new ArrayList<>();
 
     public Long getId() {

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/entities/Order.java

@@ -37,10 +37,11 @@ public class Order {
 
     @ManyToOne
     @JoinColumn(name = "customer_id")
+    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
     private Customer customer;
 
     @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
-    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+    @Cache(region = "orderItemsCache", usage = CacheConcurrencyStrategy.READ_WRITE)
     private List<OrderItem> orderItems = new ArrayList<>();
 
     public Long getId() {

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/entities/OrderItem.java

@@ -36,6 +36,7 @@ public class OrderItem {
 
     @ManyToOne
     @JoinColumn(name = "order_id")
+    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
     private Order order;
 
     public Long getId() {

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/repositories/CustomerRepository.java

@@ -1,6 +1,7 @@
 package com.example.hibernatecache.repositories;
 
 import static org.hibernate.jpa.AvailableHints.HINT_CACHEABLE;
+import static org.hibernate.jpa.HibernateHints.HINT_JDBC_BATCH_SIZE;
 
 import com.example.hibernatecache.entities.Customer;
 import io.hypersistence.utils.spring.repository.BaseJpaRepository;
@@ -20,8 +21,14 @@ public interface CustomerRepository
     @EntityGraph(attributePaths = {"orders"})
     Optional<Customer> findByFirstName(String firstName);
 
+    @Override
+    @QueryHints(@QueryHint(name = HINT_CACHEABLE, value = "true"))
+    @EntityGraph(attributePaths = {"orders"})
+    Optional<Customer> findById(Long aLong);
+
+    @QueryHints(@QueryHint(name = HINT_JDBC_BATCH_SIZE, value = "25"))
+    @Query("delete from Customer ")
     @Transactional
     @Modifying
-    @Query("delete from Customer c")
-    void deleteAll();
+    void deleteAllInBatch();
 }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/repositories/OrderItemRepository.java

@@ -1,11 +1,29 @@
 package com.example.hibernatecache.repositories;
 
+import static org.hibernate.jpa.AvailableHints.HINT_CACHEABLE;
+import static org.hibernate.jpa.HibernateHints.HINT_JDBC_BATCH_SIZE;
+
 import com.example.hibernatecache.entities.OrderItem;
 import io.hypersistence.utils.spring.repository.BaseJpaRepository;
+import jakarta.persistence.QueryHint;
+import java.util.List;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.QueryHints;
 import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 public interface OrderItemRepository
         extends BaseJpaRepository<OrderItem, Long>, PagingAndSortingRepository<OrderItem, Long> {
 
-    void deleteAll();
+    @Query("select o from OrderItem o where o.order.id = :orderId")
+    @QueryHints(@QueryHint(name = HINT_CACHEABLE, value = "true"))
+    List<OrderItem> findByOrder_Id(@Param("orderId") Long orderId);
+
+    @QueryHints(@QueryHint(name = HINT_JDBC_BATCH_SIZE, value = "25"))
+    @Query("delete from OrderItem ")
+    @Transactional
+    @Modifying
+    void deleteAllInBatch();
 }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/repositories/OrderRepository.java

@@ -1,26 +1,39 @@
 package com.example.hibernatecache.repositories;
 
 import static org.hibernate.jpa.AvailableHints.HINT_CACHEABLE;
+import static org.hibernate.jpa.HibernateHints.HINT_JDBC_BATCH_SIZE;
 
 import com.example.hibernatecache.entities.Order;
 import io.hypersistence.utils.spring.repository.BaseJpaRepository;
 import jakarta.persistence.QueryHint;
 import java.util.List;
 import java.util.Optional;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.jpa.repository.QueryHints;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 public interface OrderRepository extends BaseJpaRepository<Order, Long>, PagingAndSortingRepository<Order, Long> {
 
-    void deleteAll();
-
     @QueryHints(@QueryHint(name = HINT_CACHEABLE, value = "true"))
     @Query("SELECT o FROM Order o join fetch o.orderItems oi WHERE o.id = :id ORDER BY oi.itemCode")
     Optional<Order> findById(@Param("id") Long id);
 
     @QueryHints(@QueryHint(name = HINT_CACHEABLE, value = "true"))
     @Query("SELECT o FROM Order o join fetch o.orderItems oi WHERE o.customer.id = :customerId ORDER BY oi.itemCode")
     List<Order> findByCustomerId(@Param("customerId") Long customerId);
+
+    @Override
+    @Transactional
+    @Modifying
+    @Query("delete from Order o where o.id = :id")
+    void deleteById(@Param("id") Long id);
+
+    @QueryHints(@QueryHint(name = HINT_JDBC_BATCH_SIZE, value = "25"))
+    @Query("delete from Order")
+    @Transactional
+    @Modifying
+    void deleteAllInBatch();
 }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/services/CustomerService.java

@@ -50,6 +50,10 @@ private Pageable createPageable(FindCustomersQuery findCustomersQuery) {
         return PageRequest.of(pageNo, findCustomersQuery.pageSize(), sort);
     }
 
+    public boolean existsById(Long id) {
+        return customerRepository.existsById(id);
+    }
+
     public Optional<CustomerResponse> findCustomerById(Long id) {
         return customerRepository.findById(id).map(customerMapper::toResponse);
     }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/services/OrderItemService.java

@@ -71,4 +71,9 @@ public OrderItemResponse updateOrderItem(Long id, OrderItemRequest orderItemRequ
     public void deleteOrderItemById(Long id) {
         orderItemRepository.deleteById(id);
     }
+
+    public List<OrderItemResponse> findOrderItemsByOrderId(Long orderId) {
+        List<OrderItem> byOrderId = orderItemRepository.findByOrder_Id(orderId);
+        return orderItemMapper.toResponseList(byOrderId);
+    }
 }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/services/OrderService.java

@@ -1,5 +1,6 @@
 package com.example.hibernatecache.services;
 
+import com.example.hibernatecache.entities.Customer;
 import com.example.hibernatecache.entities.Order;
 import com.example.hibernatecache.exception.OrderNotFoundException;
 import com.example.hibernatecache.mapper.OrderMapper;
@@ -8,6 +9,7 @@
 import com.example.hibernatecache.model.response.OrderResponse;
 import com.example.hibernatecache.model.response.PagedResult;
 import com.example.hibernatecache.repositories.OrderRepository;
+import jakarta.persistence.EntityManager;
 import java.util.List;
 import java.util.Optional;
 import org.springframework.data.domain.Page;
@@ -24,9 +26,12 @@ public class OrderService {
     private final OrderRepository orderRepository;
     private final OrderMapper orderMapper;
 
-    public OrderService(OrderRepository orderRepository, OrderMapper orderMapper) {
+    private final EntityManager entityManager;
+
+    public OrderService(OrderRepository orderRepository, OrderMapper orderMapper, EntityManager entityManager) {
         this.orderRepository = orderRepository;
         this.orderMapper = orderMapper;
+        this.entityManager = entityManager;
     }
 
     public PagedResult<OrderResponse> findAllOrders(FindOrdersQuery findOrdersQuery) {
@@ -50,6 +55,11 @@ private Pageable createPageable(FindOrdersQuery findOrdersQuery) {
         return PageRequest.of(pageNo, findOrdersQuery.pageSize(), sort);
     }
 
+    public List<OrderResponse> findOrdersByCustomerId(Long customerId) {
+        List<Order> orders = orderRepository.findByCustomerId(customerId);
+        return orderMapper.mapToOrderResponseList(orders);
+    }
+
     public Optional<OrderResponse> findOrderById(Long id) {
         return orderRepository.findById(id).map(orderMapper::toResponse);
     }
@@ -76,6 +86,15 @@ public OrderResponse updateOrder(Long id, OrderRequest orderRequest) {
 
     @Transactional
     public void deleteOrderById(Long id) {
+        Order order = orderRepository.findById(id).orElseThrow(() -> new OrderNotFoundException(id));
+
+        // Delete order
         orderRepository.deleteById(id);
+
+        // Force cache eviction for the customer's orders collection
+        entityManager
+                .getEntityManagerFactory()
+                .getCache()
+                .evict(Customer.class, order.getCustomer().getId());
     }
 }

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/web/controllers/CustomerController.java

@@ -4,11 +4,14 @@
 import com.example.hibernatecache.model.query.FindCustomersQuery;
 import com.example.hibernatecache.model.request.CustomerRequest;
 import com.example.hibernatecache.model.response.CustomerResponse;
+import com.example.hibernatecache.model.response.OrderResponse;
 import com.example.hibernatecache.model.response.PagedResult;
 import com.example.hibernatecache.services.CustomerService;
+import com.example.hibernatecache.services.OrderService;
 import com.example.hibernatecache.utils.AppConstants;
 import jakarta.validation.Valid;
 import java.net.URI;
+import java.util.List;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -27,9 +30,11 @@
 class CustomerController {
 
     private final CustomerService customerService;
+    private final OrderService orderService;
 
-    CustomerController(CustomerService customerService) {
+    CustomerController(CustomerService customerService, OrderService orderService) {
         this.customerService = customerService;
+        this.orderService = orderService;
     }
 
     @GetMapping
@@ -50,6 +55,14 @@ ResponseEntity<CustomerResponse> getCustomerById(@PathVariable Long id) {
                 .orElseThrow(() -> new CustomerNotFoundException(id));
     }
 
+    @GetMapping("/{id}/orders")
+    ResponseEntity<List<OrderResponse>> getCustomerOrders(@PathVariable Long id) {
+        if (!customerService.existsById(id)) {
+            throw new CustomerNotFoundException(id);
+        }
+        return ResponseEntity.ok(orderService.findOrdersByCustomerId(id));
+    }
+
     @GetMapping("/search")
     public ResponseEntity<CustomerResponse> searchCustomer(@RequestParam String firstName) {
         return customerService

jpa/boot-hibernate2ndlevelcache-sample/src/main/java/com/example/hibernatecache/web/controllers/OrderController.java

@@ -3,12 +3,15 @@
 import com.example.hibernatecache.exception.OrderNotFoundException;
 import com.example.hibernatecache.model.query.FindOrdersQuery;
 import com.example.hibernatecache.model.request.OrderRequest;
+import com.example.hibernatecache.model.response.OrderItemResponse;
 import com.example.hibernatecache.model.response.OrderResponse;
 import com.example.hibernatecache.model.response.PagedResult;
+import com.example.hibernatecache.services.OrderItemService;
 import com.example.hibernatecache.services.OrderService;
 import com.example.hibernatecache.utils.AppConstants;
 import jakarta.validation.Valid;
 import java.net.URI;
+import java.util.List;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -27,9 +30,11 @@
 class OrderController {
 
     private final OrderService orderService;
+    private final OrderItemService orderItemService;
 
-    OrderController(OrderService orderService) {
+    OrderController(OrderService orderService, OrderItemService orderItemService) {
         this.orderService = orderService;
+        this.orderItemService = orderItemService;
     }
 
     @GetMapping
@@ -47,6 +52,16 @@ ResponseEntity<OrderResponse> getOrderById(@PathVariable Long id) {
         return orderService.findOrderById(id).map(ResponseEntity::ok).orElseThrow(() -> new OrderNotFoundException(id));
     }
 
+    @GetMapping("/{id}/items")
+    ResponseEntity<List<OrderItemResponse>> getOrderItems(@PathVariable Long id) {
+        List<OrderItemResponse> orderItemsByOrderId = orderItemService.findOrderItemsByOrderId(id);
+        if (orderItemsByOrderId.isEmpty()) {
+            throw new OrderNotFoundException(id);
+        } else {
+            return ResponseEntity.ok(orderItemsByOrderId);
+        }
+    }
+
     @PostMapping
     ResponseEntity<OrderResponse> createOrder(@RequestBody @Validated OrderRequest orderRequest) {
         OrderResponse response = orderService.saveOrder(orderRequest);
@@ -67,8 +82,8 @@ ResponseEntity<OrderResponse> deleteOrder(@PathVariable Long id) {
         return orderService
                 .findOrderById(id)
                 .map(order -> {
-                    orderService.deleteOrderById(id);
-                    return ResponseEntity.ok(order);
+                    orderService.deleteOrderById(order.orderId());
+                    return ResponseEntity.accepted().body(order);
                 })
                 .orElseThrow(() -> new OrderNotFoundException(id));
     }