0

我正在使用 Spring 和 OpenJPA 进行项目。我有一个用例，我需要在不同的项目/Maven 模块中创建相同数据源的实体。

方法一：

我的 Maven 项目核心实体有两个模块，其中包含一组具有特定功能的实体。

模块 A - 实体 1、实体 2、实体 3 模块 B - 实体 4、实体 5、实体 6

我为每组实体创建了单独的持久性单元和持久性 xml。当实体在各自的 Maven 模块中得到增强时，它可以正常工作。

方法 2： 在这种方法中，我为上述实体提供了单独的模块，但唯一的区别是我对两组实体都使用了一个持久性单元。我添加了 openjpa-maven-plugin 来增强两个模块中的实体。在这种情况下，当使用 maven 插件增强实体时，它会给出异常，说在运行时没有为模块 A 中的实体找到元数据。是不是因为当实体被增强时，模块A中实体的元数据在运行时会丢失。这个问题不会出现在模块B的实体中。

关于这个问题我有几个问题：

1）是否建议为同一数据源使用多个持久性单元（如方法 1 中所做的那样）？

2）有什么方法可以增强单个持久性单元和不同的Maven模块中的实体？

3）除了使用eclipse和maven插件之外，还有其他实体增强方法吗？

下面是每个模块的 pom.xml 中的插件：

<build>
        <plugins>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>openjpa-maven-plugin</artifactId>
                <version>1.1</version>
                <configuration>
                    <includes>**/entity/**/*.class</includes>
                    <addDefaultConstructor>true</addDefaultConstructor>
                    <enforcePropertyRestrictions>true</enforcePropertyRestrictions>
                    <persistenceXmlFile>${basedir}/src/main/resources/META-INF/moduleApersistence.xml</persistenceXmlFile>
                </configuration>
                <executions>
                    <execution>
                        <id>enhancer</id>
                        <phase>process-classes</phase>
                        <goals>
                            <goal>enhance</goal>
                        </goals>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>org.apache.openjpa</groupId>
                        <artifactId>openjpa</artifactId>
                        <version>${openjpa.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <!--This plugin's configuration is used to store Eclipse m2e settings 
                    only. It has no influence on the Maven build itself. -->
                <plugin>
                    <groupId>org.eclipse.m2e</groupId>
                    <artifactId>lifecycle-mapping</artifactId>
                    <version>1.0.0</version>
                    <configuration>
                        <lifecycleMappingMetadata>
                            <pluginExecutions>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>
                                            org.apache.openjpa
                                        </groupId>
                                        <artifactId>
                                            openjpa-maven-plugin
                                        </artifactId>
                                        <versionRange>
                                            [2.2.0,)
                                        </versionRange>
                                        <goals>
                                            <goal>enhance</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore></ignore>
                                    </action>
                                </pluginExecution>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>
                                            org.codehaus.mojo
                                        </groupId>
                                        <artifactId>
                                            cobertura-maven-plugin
                                        </artifactId>
                                        <versionRange>
                                            [2.5.2,)
                                        </versionRange>
                                        <goals>
                                            <goal>instrument</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore></ignore>
                                    </action>
                                </pluginExecution>
                            </pluginExecutions>
                        </lifecycleMappingMetadata>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
4

1 回答 1

0

将功能概念分组到模块中通常是一个好主意。按照这个想法，描述 ModuleA 的功能概念的类包含在 ModuleA 中是有道理的，而不是根据它们的技术实现进行传播。

  1. 单个或多个持久性单元：这取决于您的应用程序和域对象之间的依赖关系。每个持久性单元都有自己的一级缓存（在此处阅读更多内容）。总结在一行中，这意味着表示的行将Entity4映射到同一事务中的不同实例，具体取决于查询的持久性单元。例如entityManager.find(Entity4.class, 3L)inModuleB将返回一个与您在OneToManyinEntity3中获得的实例不同的实例，ModuleA因为 Entity3 和 Entity4 位于不同的持久性单元中。

    通常，您将彼此无关的实体保存在不同的持久化单元中，而将相互关联的实体保存在同一个持久化单元中。我的建议是保留一个持久性单元，除非你确定你会从几个中受益。保持简单，尽可能避免复杂。

  2. 是的。将你的persistence.xml放在一个单独的模块中。在父 pom 中配置openjpa-maven-plugin，然后将其加载到包含实体的模块中。

父 pom.xml：

    <pluginManagement><plugins>
    ...
    <plugin>
        <groupId>org.apache.openjpa</groupId>
        <artifactId>openjpa-maven-plugin</artifactId>
        <version>${openjpa-maven-plugin.version}</version>
        <executions>
            <execution>
                <id>enhancer</id>
                <phase>process-classes</phase>
                <goals>
                    <goal>enhance</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <addDefaultConstructor>true</addDefaultConstructor>
            <enforcePropertyRestrictions>true</enforcePropertyRestrictions>
            <persistenceXmlFile>${project.parent.basedir}/module-infra/src/main/resources/META-INF/persistence.xml</persistenceXmlFile>
        </configuration>
        <dependencies>
            <dependency>
                <groupId>org.apache.openjpa</groupId>
                <artifactId>openjpa</artifactId>
                <version>${openjpa.version}</version>
            </dependency>
        </dependencies>
    </plugin>

ModuleA 和 ModuleB pom.xml：

    <build><plugins>
    <plugin>
        <groupId>org.apache.openjpa</groupId>
        <artifactId>openjpa-maven-plugin</artifactId>
        <configuration>
            <includes>
                **/*SomeEntity.class
            </includes>
        </configuration>
    </plugin>

module-infra/../persistence.xml（在 osgi 容器中配置非 jta 数据源）

    <?xml version="1.0" encoding="UTF-8"?>
    <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="yourPersistenceUnit" transaction-type="RESOURCE_LOCAL">
            <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>

            <non-jta-data-source>osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=somedb)</non-jta-data-source>

            <class>com.example.modulea.Entity1</class>
            <class>com.example.moduleb.Entity3</class>

            <exclude-unlisted-classes>true</exclude-unlisted-classes>

            <properties>
                <property name="openjpa.TransactionMode" value="local"/>
                <property name="openjpa.ConnectionFactoryMode" value="local"/>
                <property name="openjpa.Log" value="slf4j"/>
            </properties>
        </persistence-unit>
    </persistence>

  1. 从来没听说过。maven插件应该足够了。我从来没有使用过eclipse插件。
于 2014-12-08T11:37:36.443 回答