add transaction management

ZeusbaseJAVA · Aug 12, 2024 · 6f6d388 · 6f6d388
1 parent 44c522b
commit 6f6d388
Show file tree

Hide file tree

Showing 4 changed files with 44 additions and 31 deletions.
diff --git a/src/main/java/com/example/r2dbc/config/ApplicationConfiguration.java b/src/main/java/com/example/r2dbc/config/ApplicationConfiguration.java
@@ -9,8 +9,11 @@
 import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
 import org.springframework.data.r2dbc.config.EnableR2dbcAuditing;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
+import org.springframework.r2dbc.connection.R2dbcTransactionManager;
+import org.springframework.transaction.ReactiveTransactionManager;
+import org.springframework.transaction.reactive.TransactionalOperator;
 
-@Configuration
+@Configuration(proxyBeanMethods = true)
 @EnableR2dbcRepositories
 @EnableR2dbcAuditing
 public class ApplicationConfiguration extends AbstractR2dbcConfiguration {
@@ -44,4 +47,14 @@ public ConnectionFactory connectionFactory() {
         );
     }
 
+    @Bean
+    public ReactiveTransactionManager reactiveTransactionManager() {
+        return new R2dbcTransactionManager(connectionFactory());
+    }
+
+    @Bean
+    public TransactionalOperator transactionalOperator() {
+        return TransactionalOperator.create(reactiveTransactionManager());
+    }
+
 }
diff --git a/src/main/java/com/example/r2dbc/domain/Customer.java b/src/main/java/com/example/r2dbc/domain/Customer.java
@@ -20,6 +20,10 @@ public class Customer {
     public Customer() {
     }
 
+    public List<Order> getOrders() {
+        return  orders == null ? new ArrayList<>() : orders;
+    }
+
     public Customer(Long id, String name, String email) {
         this.id = id;
         this.name = name;
@@ -50,10 +54,6 @@ public void setEmail(String email) {
         this.email = email;
     }
 
-    public List<Order> getOrders() {
-        return orders;
-    }
-
     public void setOrders(List<Order> orders) {
         this.orders = orders;
     }

diff --git a/src/main/java/com/example/r2dbc/repository/OrderRepository.java b/src/main/java/com/example/r2dbc/repository/OrderRepository.java
@@ -9,6 +9,6 @@
 public interface OrderRepository extends ReactiveCrudRepository<Order, Long>  {
 
     Flux<Order> findAllByCustomerId(Long customerId);
-    Mono<Void> deleteAllByCustomerId(Long customerId);
+    Mono<Long> deleteAllByCustomerId(Long customerId);
 
 }
diff --git a/src/main/java/com/example/r2dbc/service/CustomerService.java b/src/main/java/com/example/r2dbc/service/CustomerService.java
@@ -5,38 +5,49 @@
 import com.example.r2dbc.dto.CustomerDTO;
 import com.example.r2dbc.repository.CustomerRepository;
 import com.example.r2dbc.repository.OrderRepository;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.reactive.TransactionalOperator;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.util.function.Tuple2;
 
 import java.util.NoSuchElementException;
 
+import static reactor.core.publisher.Operators.as;
+
 @Service
 public class CustomerService {
 
     private final CustomerRepository customerRepository;
     private final OrderRepository orderRepository;
+    private final TransactionalOperator transactionalOperator;
 
-    public CustomerService(CustomerRepository customerRepository, OrderRepository orderRepository) {
+    public CustomerService(CustomerRepository customerRepository, OrderRepository orderRepository, TransactionalOperator transactionalOperator) {
         this.customerRepository = customerRepository;
         this.orderRepository = orderRepository;
+        this.transactionalOperator = transactionalOperator;
     }
 
 
+
     public Mono<CustomerDTO> findById(Long id) {
 
         return customerRepository.findById(id)
                 .switchIfEmpty(Mono.error(new NoSuchElementException()))
-                .flatMap(this::getOrdersForCustomer);
+                .flatMap(this::getOrdersForCustomer)
+                .as(transactionalOperator::transactional);
     }
 
+
     public Flux<CustomerDTO> findAll() {
         return customerRepository.findAll()
-                .flatMap(this::getOrdersForCustomer);
+                .flatMap(this::getOrdersForCustomer)
+                .as(transactionalOperator::transactional);
     }
 
+
     private Mono<CustomerDTO> getOrdersForCustomer(Customer customer) {
 
         return Mono.just(customer)
@@ -45,11 +56,11 @@ private Mono<CustomerDTO> getOrdersForCustomer(Customer customer) {
                         result.getT1().getId(),
                         result.getT1().getName(),
                         result.getT1().getEmail(),
-                        result.getT2()));
+                        result.getT2()))
+                .as(transactionalOperator::transactional);
 
     }
 
-    @Transactional
     public Mono<CustomerDTO> createCustomer(Customer customer) {
         if (customer.getId() != null) {
             return Mono.error(new IllegalArgumentException());
@@ -60,50 +71,39 @@ public Mono<CustomerDTO> createCustomer(Customer customer) {
                         newCustomer.getId(),
                         newCustomer.getName(),
                         newCustomer.getEmail(),
-                        newCustomer.getOrders()));
+                        newCustomer.getOrders()))
+                .as(transactionalOperator::transactional);
 
     }
 
-    @Transactional
     public Mono<CustomerDTO> updateCustomer(Customer customer) {
         return customerExists(customer.getId())
                 .then(customerRepository.save(customer))
                 .map(newCustomer -> new CustomerDTO(
                         newCustomer.getId(),
                         newCustomer.getName(),
                         newCustomer.getEmail(),
-                        newCustomer.getOrders()));
+                        newCustomer.getOrders()))
+                .as(transactionalOperator::transactional);
 
     }
 
-    @Transactional
     public Mono<Void> deleteCustomer(Long id) {
 
-        orderRepository.deleteAllByCustomerId(id);
-        return customerRepository.deleteById(id);
-
+        return orderRepository.deleteAllByCustomerId(id)
+                .flatMap(c -> customerRepository.deleteById(id))
+                .as(transactionalOperator::transactional);
 
-        /*
-
-        This one deletes orders, but not a customer!
-
-                return customerRepository.findById(id)
-                .zipWith(orderRepository.deleteAllByCustomerId(id))
-                .map(Tuple2::getT1)
-                .flatMap(customerRepository::delete);
-
-         */
     }
 
-
-    @Transactional
     public Mono<Void> createOrderForCustomer(Order order) {
         if (order.getId() != null) {
             return Mono.error(new IllegalArgumentException());
         }
 
         return customerExists(order.getCustomerId())
-                .then(orderRepository.save(order)).then();
+                .then(orderRepository.save(order)).then()
+                .as(transactionalOperator::transactional);
 
     }