如何配置JPA以在Maven中进行测试

Question

有没有办法在Maven项目中设置第二个persistence.xml文件，以便用于测试而不是用于部署的普通文件？

我尝试将一个persistence.xml放入src / test / resources / META-INF，它被复制到target / test-classes / META-INF中，但似乎是target / classes / META-INF（来自src / main的副本） / resources）首选，尽管mvn -X test以正确的顺序列出了类路径条目：

[DEBUG] Test Classpath :
[DEBUG]   /home/uqpbecke/dev/NetBeansProjects/UserManager/target/test-classes
[DEBUG]   /home/uqpbecke/dev/NetBeansProjects/UserManager/target/classes
[DEBUG]   /home/uqpbecke/.m2/repository/junit/junit/4.5/junit-4.5.jar
...

我希望能够针对简单的hsqldb配置运行测试，而无需更改JPA配置的部署版本，理想情况是在项目结账后直接进行，无需进行本地调整。

Answer 1

以下内容适用于Maven 2.1+（在此之前，测试和包之间没有可以绑定执行的阶段）。

您可以使用maven-antrun-plugin在测试期间将persistence.xml替换为测试版本，然后在打包项目之前恢复正确的版本。

此示例假定生产版本为src / main / resources / META-INF / persistence.xml，测试版本为src / test / resources / META-INF / persistence.xml，因此它们将被复制到target / classes / META -INF和target / test-classes / META-INF分别。

将它封装成mojo会更优雅，但是因为你只是复制一个文件，所以看起来有点过分。

<plugin>
  <artifactId>maven-antrun-plugin</artifactId>
  <version>1.3</version>
  <executions>
    <execution>
      <id>copy-test-persistence</id>
      <phase>process-test-resources</phase>
      <configuration>
        <tasks>
          <!--backup the "proper" persistence.xml-->
          <copy file="${project.build.outputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml.proper"/>
          <!--replace the "proper" persistence.xml with the "test" version-->
          <copy file="${project.build.testOutputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>
        </tasks>
      </configuration>
      <goals>
        <goal>run</goal>
      </goals>
    </execution>
    <execution>
      <id>restore-persistence</id>
      <phase>prepare-package</phase>
      <configuration>
        <tasks>
          <!--restore the "proper" persistence.xml-->
          <copy file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>
        </tasks>
      </configuration>
      <goals>
        <goal>run</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Answer 2

在EE6 / CDI / JPA项目中，测试src/test/resources/META-INF/persistence.xml只需很好的选择，无需进一步配置。

在Spring中使用JPA时，以下工作在用于测试的应用程序上下文中：

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!--
        JPA requires META-INF/persistence.xml, but somehow prefers the one
        in classes/META-INF over the one in test-classes/META-INF. Spring
        to the rescue, as it allows for setting things differently, like by
        referring to "classpath:persistence-TEST.xml". Or, simply referring
        to "META-INF/persistence.xml" makes JPA use the test version too: 
    -->
    <property name="persistenceXmlLocation" value="META-INF/persistence.xml" />

    <!-- As defined in /src/test/resources/META-INF/persistence.xml -->
    <property name="persistenceUnitName" value="myTestPersistenceUnit" />
    <property name="jpaVendorAdapter">
        <bean
            class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        </bean>
    </property>
</bean>

这里，/ /src/test/resources/META-INF/persistence.xml target/test-classes /src/test/resources/META-INF/persistence.xml target/test-classes /src/test/resources/META-INF/persistence.xml target/test-classes /src/test/resources/META-INF/persistence.xml （复制到target/test-classes ）将优先于/src/main/resources/META-INF/persistence.xml （复制到target/classes ） 。

不幸的是， persistence.xml文件的位置也决定了所谓的“ 持久性单元的根 ”，然后确定为@Entity注释扫描哪些类。 因此，使用/src/test/resources/META-INF/persistence.xml将扫描target/test-classes ，而不是target/classes （需要测试的类将存在的类）。

因此，为了进行测试，需要将<class>条目显式添加到persistence.xml ，以避免java.lang.IllegalArgumentException: Not an entity: class ... 通过使用不同的文件名（如persistence-TEST.xml可以避免对<class>条目的需要，并将该文件放在与常规persistence.xml文件完全相同的文件夹中。 然后，测试文件夹中的Spring上下文可以引用<property name="persistenceXmlLocation" value="META-INF/persistence-TEST.xml" /> ，Spring会在src/main找到它。

作为替代方案，可以使persistence.xml对于实际应用程序和测试保持相同，并且仅在src/main定义一个。 大多数配置（如驱动程序，方言和可选凭据）都可以在Spring上下文中完成。 还可以在上下文中传递 hibernate.hbm2ddl.auto等设置：

<bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!-- For example: com.mysql.jdbc.Driver or org.h2.Driver -->
    <property name="driverClassName" value="#{myConfig['db.driver']}" />
    <!-- For example: jdbc:mysql://localhost:3306/myDbName or 
        jdbc:h2:mem:test;DB_CLOSE_DELAY=-1 -->
    <property name="url" value="#{myConfig['db.url']}" />
    <!-- Ignored for H2 -->
    <property name="username" value="#{myConfig['db.username']}" />
    <property name="password" value="#{myConfig['db.password']}" />
</bean>

<bean id="jpaAdaptor"
    class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
    <!-- For example: org.hibernate.dialect.MySQL5Dialect or 
        org.hibernate.dialect.H2Dialect -->
    <property name="databasePlatform" value="#{myConfig['db.dialect']}" />
</bean>

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="jpaVendorAdapter" ref="jpaAdapter" />
    <property name="jpaProperties">
        <props>
            <!-- For example: validate, update, create or create-drop -->
            <prop key="hibernate.hbm2ddl.auto">#{myConfig['db.ddl']}</prop>
            <prop key="hibernate.show_sql">#{myConfig['db.showSql']}</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

Answer 3

似乎多个persistence.xml文件是JPA的一般问题，只能通过类加载技巧来解决。

对我有用的解决方法是在一个persistence.xml文件中定义多个持久性单元，然后确保您的部署和测试代码使用不同的绑定（在Spring中，您可以在实体管理器工厂中设置“persistenceUnitName”属性）。 它会使用测试配置污染您的部署文件，但如果您不介意它可以正常工作。

Answer 4

为测试添加一个persistance.xml： /src/test/resources/META-INF/persistence.xml正如@Arjan所说，这将改变持久性单元的根和实体类将在目标/测试类中进行扫描。 要处理它，请将jar-file元素添加到此persistance.xml：

/src/test/resources/META-INF/persistence.xml

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <persistence-unit name="com.some.project">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <jar-file>${project.basedir}/target/classes</jar-file>
        <properties>
            <property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/test_database" />
            <property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" />
            <property name="javax.persistence.jdbc.user" value="user" />
            <property name="javax.persistence.jdbc.password" value="..." />
        </properties>
    </persistence-unit>
</persistence>

然后，将测试资源的过滤添加到您的pom.xml：

<project>
    ...
    <build>
        ...
        <testResources>
            <testResource>
                <directory>src/test/resources</directory>
                <filtering>true</filtering>
            </testResource>
        </testResources>
        ...
    </build>
...
</project>

这将起作用，因为jar文件可以定位到目录，而不仅仅是jar文件。

Answer 5

我尝试了ClassLoaderProxy方法但遇到的问题是，JPA带注释的类不会被hibernate作为持久化类处理。

所以决定不使用persistence.xml就试一试。 优点是maven构建和Eclipse JUnit测试无需修改即可运行。

我有一个用于JUnit测试的persitent支持类。

public class PersistenceTestSupport {

    protected EntityManager em;
    protected EntityTransaction et;

    /**
     * Setup the the {@code EntityManager} and {@code EntityTransaction} for
     * local junit testing.
     */
    public void setup() {

        Properties props = new Properties();
        props.put("hibernate.hbm2ddl.auto", "create-drop");
        props.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
        props.put("hibernate.connection.url", "jdbc:mysql://localhost/db_name");
        props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
        props.put("hibernate.connection.username", "user");
        props.put("hibernate.connection.password", "****");

        Ejb3Configuration cfg = new Ejb3Configuration();
        em = cfg.addProperties(props)
            .addAnnotatedClass(Class1.class)
            .addAnnotatedClass(Class2.class)
            ...
                    .addAnnotatedClass(Classn.class)
            .buildEntityManagerFactory()
            .createEntityManager();

        et = em.getTransaction();
    }
}

我的测试类只是扩展PersistenceTestSupport并调用TestCase.setup（）中的setup（）。

唯一的缺点是保持持久化的类，但对于JUnit测试，这对我来说是可以接受的。

Answer 6

我更喜欢使用不同的persistence.xml作为Rich Seller 帖子进行测试和制作的解决方案（谢谢!!）。

但需要改变：

<copy file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml"/>

对于：

<move file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>

为了使persistence.xml.proper不嵌入.jar文件中

Answer 7

Persistence.xml用作搜索实体类的起点，除非您明确列出所有类并添加。 因此，如果您想要使用另一个文件覆盖此文件，例如从src / test / resources，您必须在第二个persistence.xml中指定每个实体类，否则将找不到实体类。

另一种解决方案是使用maven-resources-plugin（'copy-resources'目标）覆盖文件。 但是你必须覆盖它两次，一次用于测试（例如阶段过程测试类），一次用于真正的包装（阶段'准备包'）。

Answer 8

这个答案可能听起来很傻但我正在寻找一种方法让我通过Run As - > JUnit Test从eclipse运行这些JUnit Test 。 这就是我的方式：

@BeforeClass
public static void setUp() throws IOException {
    Files.copy(new File("target/test-classes/META-INF/persistence.xml"), new File("target/classes/META-INF/persistence.xml"));
    // ...
}

我只是将test / persistence.xml复制到classes / persistence.xml。 这有效。

Answer 9

保留两个persistence.xml文件的副本。 一个用于测试，另一个用于正常构建。

默认生命周期将构建persistence.xml复制到src / test / resources / META-INF

创建一个单独的配置文件，在运行时将测试persistence.xml复制到src / test / resources / META-INF

Answer 10

另一种方法是使用单独的persistence.xml进行测试（测试/../ META-INF / persistence.xml，但如下覆盖Scanner： -

测试persistence.xml需要包含

<property name="hibernate.ejb.resource_scanner" value = "...TestScanner" />

新类TestScanner的代码如下。

import java.lang.annotation.Annotation;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Set;
import org.hibernate.ejb.packaging.NamedInputStream;
import org.hibernate.ejb.packaging.NativeScanner;


public class TestScanner extends NativeScanner
{

@Override
public Set <Class <?> > 
getClassesInJar (URL jar, Set <Class <? extends Annotation> > annotations)
{  return super.getClassesInJar (getUpdatedURL (jar), annotations); }

@Override
public Set <NamedInputStream> 
getFilesInJar (URL jar, Set <String> patterns)
{  return super.getFilesInJar (getUpdatedURL (jar), patterns); }

@Override
public Set <Package> 
getPackagesInJar (URL jar, Set <Class <? extends Annotation> > annotations)
{  return super.getPackagesInJar (getUpdatedURL (jar), annotations); }

private URL getUpdatedURL (URL url)
{
  String oldURL = url.toExternalForm ();
  String newURL = oldURL.replaceAll ("test-classes", "classes");
  URL result;
  try {
    result = newURL.equals (oldURL) ? url : new URL (newURL);
  } catch (MalformedURLException e)
  {  // Whatever  }
  return result;
}

}

Answer 11

我正在尝试做同样的事情。 我有一个适合我的解决方案 - 你的可能会有所不同（你可能不喜欢这个解决方案......它有点低级别）。

我在网上看到一篇文章，他们使用自定义类加载器来做类似的事情，作为灵感。 如果有人能看到如何改进那么建议将是受欢迎的顺便说一句。 对于部署，我依赖于EntityManager的容器注入，但是为了测试我自己使用以下代码创建它：

final Thread currentThread = Thread.currentThread();
final ClassLoader saveClassLoader = currentThread.getContextClassLoader();
currentThread.setContextClassLoader(new ClassLoaderProxy(saveClassLoader));

EntityManagerFactory emFactory = Persistence.createEntityManagerFactory("test");
em = emFactory.createEntityManager();

然后ClassLoaderProxy大约尽可能少，只需将META-INF / persistence.xml的请求重定向到META-INF / test-persist.xml：

public class ClassLoaderProxy extends ClassLoader {

    public ClassLoaderProxy(final ClassLoader parent) {
        super();
    }

    @Override
    public Enumeration<URL> getResources(final String name) throws IOException {
        if (!"META-INF/persistence.xml".equals(name)) {
            return super.getResources(name);
        } else {
            System.out.println("Redirecting persistence.xml to test-persist.xml");
            return super.getResources("META-INF/test-persist.xml");
        }
    }
}

只是为了解释一下这个：

1. 有两个persistence.xml文件（一个名为persistence.xml，用于测试之外，另一个名为test-persist.xml，用于测试）。
2. 自定义类加载器仅对单元测试有效（部署一切正常）
3. 自定义类加载器将对“META-INF / persistence.xml”的请求重定向到测试版本（“META-INF / test-persist.xml”）。

我原来遇到了一些问题，因为Hibernate将（以某种方式）恢复到用于加载Hibernate的类加载器（至少我认为这是正在发生的事情）。 我已经发现将ClassLoader切换代码（第一个块）作为静态块放在你的测试用例中它将在Hibernate之前加载但是，根据你的单元测试结构，你可能还需要在其他地方放置相同的代码（呸）。

Answer 12

使用OpenEJB时，可以使用备用描述符覆盖persistence.xml： http ： //tomee.apache.org/alternate-descriptors.html

Answer 13

这是Rich Seller的答案的扩展，正确处理Hibernate在类路径上找到多个persistence.xml文件并预先测试状态恢复。

建立：

为部署/打包创建一个持久性文件，为测试创建一个：

• SRC /主/资源/ persistence.xml中

• src / test / resources / persistence- testing .xml

在你的pom.xml中将它添加到插件部分：

        <plugin>
            <artifactId>maven-antrun-plugin</artifactId>
            <version>1.3</version>
            <executions>
                <execution>
                    <id>copy-test-persistence</id>
                    <phase>process-test-resources</phase>
                    <configuration>
                        <tasks>
                            <echo>renaming deployment persistence.xml</echo>
                            <move file="${project.build.outputDirectory}/META-INF/persistence.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml.proper"/>
                            <echo>replacing deployment persistence.xml with test version</echo>
                            <copy file="${project.build.testOutputDirectory}/META-INF/persistence-testing.xml" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>
                        </tasks>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
                <execution>
                    <id>restore-persistence</id>
                    <phase>prepare-package</phase>
                    <configuration>
                        <tasks>
                            <echo>restoring the deployment persistence.xml</echo>
                            <move file="${project.build.outputDirectory}/META-INF/persistence.xml.proper" tofile="${project.build.outputDirectory}/META-INF/persistence.xml" overwrite="true"/>
                        </tasks>
                    </configuration>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

优于其他解决方案的优势

• 无需额外的Java代码
• 类路径上只有一个persistence.xml
• 构建和测试都按预期工作
• 描述控制台上的输出（回声）
• 对于包装，状态是100％恢复。 没有剩余的文件

Answer 14

此用例的另一个选项是添加多个持久性单元，一个用于生产，另一个用于测试并相应地注入EntityManagerFactory。

将两个持久性单元放入实际项目的persistence.xml中，并让测试用例注入正确的EntityManager。 下面的例子说明了如何用guice做到这一点。 请注意，为了完整性，我已经留下了一些模拟嘲弄，mockito特定代码已经相应标记，并且不需要注入。

public class HibernateTestDatabaseProvider extends AbstractModule {
    private static final ThreadLocal<EntityManager> ENTITYMANAGER_CACHE = new ThreadLocal<>();

    @Override
    public void configure() {
    }

    @Provides
    @Singleton
    public EntityManagerFactory provideEntityManagerFactory() {
        return Persistence.createEntityManagerFactory("my.test.persistence.unit");
    }

    @Provides
    public CriteriaBuilder provideCriteriaBuilder(EntityManagerFactory entityManagerFactory) {
        return entityManagerFactory.getCriteriaBuilder();
    }

    @Provides
    public EntityManager provideEntityManager(EntityManagerFactory entityManagerFactory) {
        EntityManager entityManager = ENTITYMANAGER_CACHE.get();
        if (entityManager == null) {
            // prevent commits on the database, requires mockito. Not relevant for this answer
            entityManager = spy(entityManagerFactory.createEntityManager());


            EntityTransaction et = spy(entityManager.getTransaction());
            when(entityManager.getTransaction()).thenReturn(et);
            doNothing().when(et).commit();

            ENTITYMANAGER_CACHE.set(entityManager);
        }
        return entityManager;
    }
}

Answer 15

使用persistence.xml将测试放在自己的maven项目中

Answer 16

我建议使用不同的maven配置文件，你可以过滤你的database.proprerties文件，每个配置文件有一个database.properties。

这样，除了.properties之外，您不必保留任何其他配置文件的副本。

<properties>
    <!-- Used to locate the profile specific configuration file. -->
    <build.profile.id>default</build.profile.id>
    <!-- Only unit tests are run by default. -->
    <skip.integration.tests>true</skip.integration.tests>
    <skip.unit.tests>false</skip.unit.tests>
    <integration.test.files>**/*IT.java</integration.test.files>
</properties>
<profiles>
    <profile>
        <id>default</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <!--
                Specifies the build profile id, which is used to find out the correct properties file.
                This is not actually necessary for this example, but it can be used for other purposes.
            -->
            <build.profile.id>default</build.profile.id>
            <skip.integration.tests>true</skip.integration.tests>
            <skip.unit.tests>false</skip.unit.tests>
        </properties>
        <build>
            <filters>
                <!--
                    Specifies path to the properties file, which contains profile specific
                    configuration. In this case, the configuration file should be the default spring/database.properties file
                -->
                <filter>src/main/resources/META-INF/spring/database.properties</filter>
            </filters>
            <resources>
                <!--
                    Placeholders found from files located in the configured resource directories are replaced
                    with values found from the profile specific configuration files.
                -->
                <resource>
                    <filtering>true</filtering>
                    <directory>src/main/resources</directory>
                    <!--
                        You can also include only specific files found from the configured directory or
                        exclude files. This can be done by uncommenting following sections and adding
                        the configuration under includes and excludes tags.
                    -->
                    <!--
                    <includes>
                        <include></include>
                    </includes>
                    <excludes>
                        <exclude></exclude>
                    </excludes>
                    -->
                </resource>
            </resources>
        </build>
    </profile>
    <profile>
        <id>integration</id>
        <properties>
            <!--
                Specifies the build profile id, which is used to find out the correct properties file.
                This is not actually necessary for this example, but it can be used for other purposes.
            -->
            <build.profile.id>integration</build.profile.id>
            <skip.integration.tests>false</skip.integration.tests>
            <skip.unit.tests>true</skip.unit.tests>
        </properties>
        <build>
            <filters>
                <!--
                    Specifies path to the properties file, which contains profile specific
                    configuration. In this case, the configuration file is searched
                    from spring/profiles/it/ directory.
                -->
                <filter>src/main/resources/META-INF/spring/profiles/${build.profile.id}/database.properties</filter>
            </filters>
            <resources>
                <!--
                    Placeholders found from files located in the configured resource directories are replaced
                    with values found from the profile specific configuration files.
                -->
                <resource>
                    <filtering>true</filtering>
                    <directory>src/main/resources</directory>
                    <!--
                        You can also include only specific files found from the configured directory or
                        exclude files. This can be done by uncommenting following sections and adding
                        the configuration under includes and excludes tags.
                    -->
                    <!--
                    <includes>
                        <include></include>
                    </includes>
                    <excludes>
                        <exclude></exclude>
                    </excludes>
                    -->
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

在单击测试的确定性和集成测试失败的帮助下，您已经完成了。

    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.12</version>
    <configuration>
        <junitArtifactName>org.junit:com.springsource.org.junit</junitArtifactName>
        <!--see: https://issuetracker.springsource.com/browse/EBR-220-->
        <printSummary>false</printSummary>
        <redirectTestOutputToFile>true</redirectTestOutputToFile>
        <!-- Skips unit tests if the value of skip.unit.tests property is true -->
        <skipTests>${skip.unit.tests}</skipTests>
        <!-- Excludes integration tests when unit tests are run. -->
        <excludes>
            <exclude>${integration.test.files}</exclude>
        </excludes>
    </configuration>
</plugin>


<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>2.12</version>
    <configuration>
        <!-- Skips integration tests if the value of skip.integration.tests property is true -->
        <skipTests>${skip.integration.tests}</skipTests>
        <includes>
            <include>${integration.test.files}</include>
        </includes>
        <forkMode>once</forkMode>
        <!--
                            <reuseForks>false</reuseForks>
                            <forkCount>1</forkCount>
        -->
    </configuration>
    <executions>
        <execution>
            <id>integration-test</id>
            <goals>
                <goal>integration-test</goal>
            </goals>
        </execution>
        <execution>
            <id>verify</id>
            <goals>
                <goal>verify</goal>
            </goals>
        </execution>
    </executions>
</plugin>

现在你需要mvn test你的单元测试和mvn verify -Pintegration你的集成测试。 显然，您应该在指定的（在配置文件中）路径（或其他位置并更改路径）中创建database.properties文件

基于参考： http ： //www.petrikainulainen.net/programming/tips-and-tricks/creating-profile-specific-configuration-files-with-maven/