Update jpa-orders

Author: kai-niemi

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/JpaOrdersApplication.java

@@ -8,15 +8,13 @@
 import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.EnableAspectJAutoProxy;
 
 @Configuration
 @EnableAutoConfiguration(exclude = {
         TransactionAutoConfiguration.class,
         DataSourceTransactionManagerAutoConfiguration.class,
         DataSourceAutoConfiguration.class
 })
-@EnableAspectJAutoProxy(proxyTargetClass = true)
 @ComponentScan(basePackages = "io.roach")
 public class JpaOrdersApplication {
     public static void main(String[] args) {

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/OrderClient.java

@@ -0,0 +1,42 @@
+package io.roach.data.jpa;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import io.roach.data.jpa.service.OrderSystem;
+
+@Component
+public class OrderSystemClient implements CommandLineRunner {
+    protected final Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Autowired
+    private OrderSystem orderSystem;
+
+    @Override
+    public void run(String... args) {
+        logger.info("Clear all...");
+        orderSystem.clearAll();
+
+        logger.info(">> Creating products...");
+        orderSystem.createProductInventory();
+
+        logger.info(">> Creating customers...");
+        orderSystem.createCustomers();
+
+        logger.info(">> Creating orders...");
+        orderSystem.createOrders();
+
+        logger.info(">> Listing orders...");
+        orderSystem.listOrders();
+
+        logger.info(">> Find by sku: {}", orderSystem.findProductBySku("CRDB-UL-ED1"));
+
+        logger.info(">> Get total order price: {}", orderSystem.getTotalOrderPrice());
+
+//        logger.info("Removing orders...");
+//        orderSystem.removeOrders();
+    }
+}

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/OrderSystemClient.java

@@ -3,12 +3,21 @@
 import java.util.Optional;
 import java.util.UUID;
 
+import javax.persistence.LockModeType;
+
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import io.roach.data.jpa.domain.Product;
 
 @Repository
 public interface ProductRepository extends JpaRepository<Product, UUID> {
+    @Lock(LockModeType.PESSIMISTIC_READ)
     Optional<Product> findProductBySku(String sku);
+
+    @Query("select p from Product p where p.sku=:sku")
+    Optional<Product> findProductBySkuNoLock(@Param("sku") String sku);
 }

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/repository/ProductRepository.java

@@ -1,4 +1,4 @@
-package io.roach.data.jpa.config;
+package io.roach.data.jpa.service;
 
 import java.util.Properties;
 
@@ -8,11 +8,15 @@
 import org.hibernate.cache.internal.NoCachingRegionFactory;
 import org.hibernate.cfg.Environment;
 import org.hibernate.dialect.CockroachDB201Dialect;
+import org.postgresql.ds.PGSimpleDataSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.context.annotation.Primary;
 import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
@@ -24,16 +28,18 @@
 import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
-
-import com.zaxxer.hikari.HikariDataSource;
+import org.springframework.transaction.support.TransactionTemplate;
 
 import net.ttddyy.dsproxy.listener.logging.SLF4JLogLevel;
 import net.ttddyy.dsproxy.support.ProxyDataSourceBuilder;
 
 @Configuration
 @EnableTransactionManagement(proxyTargetClass = true)
+@EnableAspectJAutoProxy(proxyTargetClass = true)
 @EnableJpaRepositories(basePackages = {"io.roach"})
 public class JpaConfiguration {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
     @Bean
     @ConfigurationProperties("spring.datasource")
     public DataSourceProperties dataSourceProperties() {
@@ -42,18 +48,18 @@ public DataSourceProperties dataSourceProperties() {
 
     @Bean
     @ConfigurationProperties("spring.datasource.hikari")
-    public HikariDataSource hikariDataSource() {
+    public PGSimpleDataSource primaryDataSource() {
         return dataSourceProperties()
                 .initializeDataSourceBuilder()
-                .type(HikariDataSource.class)
+                .type(PGSimpleDataSource.class)
                 .build();
     }
 
     @Bean
     @Primary
     public DataSource dataSource() {
         return ProxyDataSourceBuilder
-                .create(hikariDataSource())
+                .create(primaryDataSource())
                 .name("SQL-Trace")
                 .asJson()
                 .logQueryBySlf4j(SLF4JLogLevel.TRACE, "io.roach.SQL_TRACE")
@@ -84,6 +90,11 @@ public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
         return emf;
     }
 
+    @Bean
+    public TransactionTemplate transactionTemplate(EntityManagerFactory entityManagerFactory) {
+        return new TransactionTemplate(transactionManager(entityManagerFactory));
+    }
+
     private Properties jpaVendorProperties() {
         return new Properties() {
             {
@@ -99,6 +110,7 @@ private Properties jpaVendorProperties() {
                 setProperty(Environment.FORMAT_SQL, Boolean.FALSE.toString());
                 // Mutes Postgres JPA Error (Method org.postgresql.jdbc.PgConnection.createClob() is not yet implemented).
                 setProperty(Environment.NON_CONTEXTUAL_LOB_CREATION, Boolean.TRUE.toString());
+//                setProperty(Environment.CONNECTION_PROVIDER_DISABLES_AUTOCOMMIT, Boolean.TRUE.toString());
             }
         };
     }

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/config/JpaConfiguration.java renamed to roach-data-jpa-orders/src/main/java/io/roach/data/jpa/service/JpaConfiguration.java

@@ -0,0 +1,28 @@
+package io.roach.data.jpa.service;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import io.roach.data.jpa.domain.Order;
+import io.roach.data.jpa.repository.OrderRepository;
+
+@Service
+public class OrderService {
+    @Autowired
+    private OrderRepository orderRepository;
+
+    @Transactional(propagation = Propagation.REQUIRES_NEW,readOnly = true)
+    public BigDecimal getTotalOrderPrice() {
+        BigDecimal price = BigDecimal.ZERO;
+        List<Order> orders = orderRepository.findAll();
+        for (Order order : orders) {
+            price = price.add(order.getTotalPrice());
+        }
+        return price;
+    }
+}

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/service/OrderService.java

@@ -0,0 +1,23 @@
+package io.roach.data.jpa.service;
+
+import java.math.BigDecimal;
+
+import io.roach.data.jpa.domain.Product;
+
+public interface OrderSystem {
+    void clearAll();
+
+    void createProductInventory();
+
+    void createCustomers();
+
+    void createOrders();
+
+    void listOrders();
+
+    Product findProductBySku(String sku);
+
+    BigDecimal getTotalOrderPrice();
+
+    void removeOrders();
+}

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/service/OrderSystem.java

@@ -1,4 +1,4 @@
-package io.roach.data.jpa;
+package io.roach.data.jpa.service;
 
 import java.math.BigDecimal;
 import java.util.Optional;
@@ -7,11 +7,16 @@
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionStatus;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionCallback;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
+import org.springframework.transaction.support.TransactionTemplate;
 import org.springframework.util.Assert;
 
+import io.roach.data.jpa.JpaOrdersApplication;
 import io.roach.data.jpa.domain.Customer;
 import io.roach.data.jpa.domain.Order;
 import io.roach.data.jpa.domain.Product;
@@ -20,7 +25,7 @@
 import io.roach.data.jpa.repository.ProductRepository;
 
 @Service
-public class OrderSystemFacade {
+public class OrderSystemImpl implements OrderSystem {
     protected static final Logger logger = LoggerFactory.getLogger(JpaOrdersApplication.class);
 
     @Autowired
@@ -32,6 +37,10 @@ public class OrderSystemFacade {
     @Autowired
     private OrderRepository orderRepository;
 
+    @Autowired
+    private OrderService orderService;
+
+    @Override
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void clearAll() {
         Assert.isTrue(TransactionSynchronizationManager.isActualTransactionActive(), "TX not active");
@@ -40,6 +49,7 @@ public void clearAll() {
         customerRepository.deleteAll();
     }
 
+    @Override
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void createProductInventory() {
         Product p1 = Product.builder()
@@ -60,6 +70,7 @@ public void createProductInventory() {
         productRepository.save(p2);
     }
 
+    @Override
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void createCustomers() {
         Customer c1 = Customer.builder()
@@ -78,6 +89,7 @@ public void createCustomers() {
         customerRepository.save(c2);
     }
 
+    @Override
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void createOrders() {
         Optional<Product> p1 = productRepository.findProductBySku("CRDB-UL-ED1");
@@ -120,7 +132,8 @@ public void createOrders() {
         orderRepository.save(o2);
     }
 
-    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    @Override
+    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true)
     public void listOrders() {
         logger.info("Placed orders:");
 
@@ -145,6 +158,39 @@ public void listOrders() {
 
     }
 
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+
+    @Override
+    @Transactional(propagation = Propagation.NEVER, readOnly = true)
+    public Product findProductBySku(String sku) {
+        Assert.isTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly(),"Not read-only");
+        Assert.isTrue(!TransactionSynchronizationManager.isActualTransactionActive(),"No tx");
+
+        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
+        transactionTemplate.setReadOnly(true);
+
+        Product p= transactionTemplate.execute(new TransactionCallback<Product>() {
+            @Override
+            public Product doInTransaction(TransactionStatus status) {
+                Optional<Product> p1 = productRepository.findProductBySkuNoLock(sku);
+                Product p = p1.orElseThrow(() -> new IllegalArgumentException("Not found"));
+                p.setPrice(BigDecimal.ZERO);
+                return p;
+
+            }
+        });
+        productRepository.saveAndFlush(p);
+        return p;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false)
+    public BigDecimal getTotalOrderPrice() {
+        return orderService.getTotalOrderPrice();
+    }
+
+    @Override
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void removeOrders() {
         orderRepository.findOrdersByUserName("adolfo").forEach(order -> {

roach-data-jpa-orders/src/main/java/io/roach/data/jpa/OrderSystemFacade.java renamed to roach-data-jpa-orders/src/main/java/io/roach/data/jpa/service/OrderSystemImpl.java

@@ -14,6 +14,7 @@ spring:
     enabled: true
     clean-on-validation-error: true
     ignore-pending-migrations: true
+    baseline-on-migrate: true
   datasource:
     url: jdbc:postgresql://localhost:26257/roach_data?sslmode=disable
     driver-class-name: org.postgresql.Driver
@@ -23,6 +24,7 @@ spring:
       connection-test-query: SELECT 1
       maximum-pool-size: 20
       minimum-idle: 20
+      auto-commit: false
   jpa:
     open-in-view: false
     properties: