enable spring again

Author: marschall

pom.xml

@@ -354,11 +354,6 @@
         </exclusion>
       </exclusions>
     </dependency>
-    <dependency>
-      <groupId>org.springframework</groupId>
-      <artifactId>spring-jdbc</artifactId>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-orm</artifactId>

src/test/java/com/github/marschall/hibernate/batchsequencegenerator/BatchSequenceGeneratorIntegrationTest.java

@@ -2,32 +2,26 @@
 
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-import java.net.URL;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import javax.sql.DataSource;
 
-import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.jpa.boot.spi.Bootstrap;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.MapPropertySource;
 import org.springframework.core.env.MutablePropertySources;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 import org.springframework.jdbc.datasource.init.DatabasePopulator;
+import org.springframework.orm.jpa.EntityManagerFactoryUtils;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.TransactionDefinition;
 import org.springframework.transaction.support.DefaultTransactionDefinition;
-import org.springframework.transaction.support.TransactionOperations;
 import org.springframework.transaction.support.TransactionTemplate;
 
 import com.github.marschall.hibernate.batchsequencegenerator.configurations.FirebirdConfiguration;
@@ -38,18 +32,17 @@
 import com.github.marschall.hibernate.batchsequencegenerator.configurations.OracleConfiguration;
 import com.github.marschall.hibernate.batchsequencegenerator.configurations.PostgresConfiguration;
 import com.github.marschall.hibernate.batchsequencegenerator.configurations.SqlServerConfiguration;
+import com.github.marschall.hibernate.batchsequencegenerator.configurations.TransactionManagerConfiguration;
 import com.github.marschall.hibernate.batchsequencegenerator.entities.ChildEntity;
 import com.github.marschall.hibernate.batchsequencegenerator.entities.ParentEntity;
 
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
-import jakarta.persistence.EntityTransaction;
-import jakarta.persistence.spi.PersistenceUnitTransactionType;
 
 public class BatchSequenceGeneratorIntegrationTest {
 
   private AnnotationConfigApplicationContext applicationContext;
-  private EntityManagerFactory entityManagerFactory;
+  private TransactionTemplate template;
 
   public static List<Arguments> parameters() {
     List<Arguments> parameters = new ArrayList<>();
@@ -78,47 +71,21 @@ private void setUp(Class<?> dataSourceConfiguration, String persistenceUnitName)
       assumeTrue(isSupportedOnTravis(persistenceUnitName));
     }
     this.applicationContext = new AnnotationConfigApplicationContext();
-    this.applicationContext.register(dataSourceConfiguration);
+    this.applicationContext.register(dataSourceConfiguration, HibernateConfiguration.class, TransactionManagerConfiguration.class);
     ConfigurableEnvironment environment = this.applicationContext.getEnvironment();
     MutablePropertySources propertySources = environment.getPropertySources();
-    Map<String, Object> source = Collections.singletonMap(HibernateConfiguration.PERSISTENCE_UNIT_NAME, persistenceUnitName);
+    Map<String, Object> source = Map.of(HibernateConfiguration.PERSISTENCE_UNIT_NAME, persistenceUnitName);
     propertySources.addFirst(new MapPropertySource("persistence unit name", source));
     this.applicationContext.refresh();
 
-    URL persistenceXml = BatchSequenceGeneratorIntegrationTest.class.getClassLoader().getResource("META-INF/persistence.xml");
-    DataSource dataSource = this.applicationContext.getBean(DataSource.class);
-
-    Map<String, Object> integrationSettings = new HashMap<>();
-    integrationSettings.put(AvailableSettings.DATASOURCE, dataSource);
-    this.entityManagerFactory = Bootstrap.getEntityManagerFactoryBuilder(persistenceXml, persistenceUnitName, PersistenceUnitTransactionType.RESOURCE_LOCAL, integrationSettings)
-            .withDataSource(dataSource)
-            .build();
-
-    this.populateDatabase(dataSource);
-  }
-
-  private void populateDatabase(DataSource dataSource) {
-    //  PlatformTransactionManager txManager = this.applicationContext.getBean(PlatformTransactionManager.class);
-    PlatformTransactionManager txManager = new DataSourceTransactionManager(dataSource);
+    PlatformTransactionManager txManager = this.applicationContext.getBean(PlatformTransactionManager.class);
     TransactionDefinition transactionDefinition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
-    TransactionOperations template = new TransactionTemplate(txManager, transactionDefinition);
-    template.execute(status -> {
-      return this.populateDatabaseInTransaction();
+    this.template = new TransactionTemplate(txManager, transactionDefinition);
+    this.template.execute(status -> {
+      return this.populateDatabase();
     });
   }
 
-  private Object populateDatabaseInTransaction() {
-    Map<String, DatabasePopulator> beans = this.applicationContext.getBeansOfType(DatabasePopulator.class);
-    DataSource dataSource = this.applicationContext.getBean(DataSource.class);
-    try (Connection connection = dataSource.getConnection()) {
-      for (DatabasePopulator populator : beans.values()) {
-        populator.populate(connection);
-      }
-    } catch (SQLException e) {
-      throw new RuntimeException("could initialize database", e);
-    }
-    return null;
-  }
 
 
   private static boolean isTravis() {
@@ -134,66 +101,57 @@ private static boolean isSupportedOnTravis(String persistenceUnitName) {
             || persistenceUnitName.contains("db2"));
   }
 
+  private Object populateDatabase() {
+    Map<String, DatabasePopulator> beans = this.applicationContext.getBeansOfType(DatabasePopulator.class);
+    DataSource dataSource = this.applicationContext.getBean(DataSource.class);
+    try (Connection connection = dataSource.getConnection()) {
+      for (DatabasePopulator populator : beans.values()) {
+        populator.populate(connection);
+      }
+    } catch (SQLException e) {
+      throw new RuntimeException("could initialize database", e);
+    }
+    return null;
+  }
+
   private void tearDown() {
     if (this.applicationContext == null) { // unsupported database on travis
       return;
     }
-    this.entityManagerFactory.close();
     this.applicationContext.close();
   }
 
   @ParameterizedTest
   @MethodSource("parameters")
   public void parentChildInstert(Class<?> dataSourceConfiguration, String persistenceUnitName) {
     this.setUp(dataSourceConfiguration, persistenceUnitName);
+    EntityManagerFactory factory = this.applicationContext.getBean(EntityManagerFactory.class);
     try {
-      EntityManager entityManager = this.entityManagerFactory.createEntityManager();
-      try {
-        this.runInTransaction(entityManager, () -> this.verifyParentChildInstert(entityManager));
-      } finally {
-        entityManager.close();
-      }
+      this.template.execute(status -> {
+        EntityManager entityManager = EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
+        int parentCount = 100;
+        List<ParentEntity> parents = new ArrayList<>(parentCount);
+        for (int i = 0; i < parentCount; i++) {
+          ParentEntity parent = new ParentEntity();
+
+          parent.addChild(new ChildEntity());
+          parent.addChild(new ChildEntity());
+
+          parents.add(parent);
+        }
+        for (ParentEntity parent : parents) {
+          entityManager.persist(parent);
+          for (ChildEntity child : parent.getChildren()) {
+            child.setParentId(parent.getParentId());
+            entityManager.persist(child);
+          }
+        }
+        status.flush();
+        return null;
+      });
     } finally {
       this.tearDown();
     }
   }
 
-  private void runInTransaction(EntityManager entityManager, Runnable callback) {
-    EntityTransaction transaction = entityManager.getTransaction();
-    transaction.begin();
-    try {
-      callback.run();
-      if (transaction.getRollbackOnly()) {
-        transaction.rollback();
-      } else {
-        transaction.commit();
-      }
-    } catch (Throwable t) {
-      if (transaction.isActive()) {
-        transaction.rollback();
-      }
-      throw t;
-    }
-  }
-
-  private void verifyParentChildInstert(EntityManager entityManager) {
-    int parentCount = 100;
-    List<ParentEntity> parents = new ArrayList<>(parentCount);
-    for (int i = 0; i < parentCount; i++) {
-      ParentEntity parent = new ParentEntity();
-
-      parent.addChild(new ChildEntity());
-      parent.addChild(new ChildEntity());
-
-      parents.add(parent);
-    }
-    for (ParentEntity parent : parents) {
-      entityManager.persist(parent);
-      for (ChildEntity child : parent.getChildren()) {
-        child.setParentId(parent.getParentId());
-        entityManager.persist(child);
-      }
-    }
-  }
-
 }

src/test/java/com/github/marschall/hibernate/batchsequencegenerator/configurations/HibernateConfiguration.java

@@ -3,8 +3,13 @@
 import javax.sql.DataSource;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.env.Environment;
+import org.springframework.orm.jpa.JpaDialect;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaDialect;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
 
 @Configuration
 public class HibernateConfiguration {
@@ -18,19 +23,19 @@ public class HibernateConfiguration {
   private DataSource dataSource;
 
 
-//  @Bean
-//  public LocalContainerEntityManagerFactoryBean entityManager() {
-//    LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
-//    bean.setPersistenceUnitName(environment.getProperty(PERSISTENCE_UNIT_NAME));
-//    bean.setJpaDialect(jpaDialect());
-//    bean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
-//    bean.setDataSource(dataSource);
-//    return bean;
-//  }
-//
-//  @Bean
-//  public JpaDialect jpaDialect() {
-//    return new HibernateJpaDialect();
-//  }
+  @Bean
+  public LocalContainerEntityManagerFactoryBean entityManager() {
+    LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
+    bean.setPersistenceUnitName(this.environment.getProperty(PERSISTENCE_UNIT_NAME));
+    bean.setJpaDialect(this.jpaDialect());
+    bean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
+    bean.setDataSource(this.dataSource);
+    return bean;
+  }
+
+  @Bean
+  public JpaDialect jpaDialect() {
+    return new HibernateJpaDialect();
+  }
 
 }

src/test/java/com/github/marschall/hibernate/batchsequencegenerator/configurations/TransactionManagerConfiguration.java

@@ -3,8 +3,14 @@
 import javax.sql.DataSource;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.env.Environment;
+import org.springframework.orm.jpa.JpaDialect;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import jakarta.persistence.EntityManagerFactory;
 
 @Configuration
 public class TransactionManagerConfiguration {
@@ -15,16 +21,16 @@ public class TransactionManagerConfiguration {
   @Autowired
   private DataSource dataSource;
 
-//  @Autowired
-//  private JpaDialect jpaDialect;
-
-//  @Bean
-//  public PlatformTransactionManager txManager(EntityManagerFactory emf) {
-//    JpaTransactionManager transactionManager = new JpaTransactionManager(emf);
-//    transactionManager.setDataSource(this.dataSource);
-//    transactionManager.setJpaDialect(this.jpaDialect);
-//    transactionManager.setPersistenceUnitName(environment.getProperty(HibernateConfiguration.PERSISTENCE_UNIT_NAME));
-//    return transactionManager;
-//  }
+  @Autowired
+  private JpaDialect jpaDialect;
+
+  @Bean
+  public PlatformTransactionManager txManager(EntityManagerFactory emf) {
+    JpaTransactionManager transactionManager = new JpaTransactionManager(emf);
+    transactionManager.setDataSource(this.dataSource);
+    transactionManager.setJpaDialect(this.jpaDialect);
+    transactionManager.setPersistenceUnitName(this.environment.getProperty(HibernateConfiguration.PERSISTENCE_UNIT_NAME));
+    return transactionManager;
+  }
 
 }