如何包含pom项目中的所有模块

Question

我正在寻找一种方法将所有模块包含在来自另一个pom.xml的项目中。所以在我的情况下，我有一个包装设置为pom的父级pom。它包含3个子模块，在另一个api模块中实现我的接口。我想动态地将所有子模块包含在maven项目中。

在这种情况下，我想将connector1，connector2，connector3包含在另一个模块中，而不必明确指定connector1,2,3。

connectors - packaging: pom 
    connector1 - packaging: jar 
    connector2 - packaging: jar 
    connector3 - packaging: jar 

我试过在我的项目中包括连接器pom，但这没有奏效。我希望用pom指定父包将包含子模块，但这不起作用。有没有任何解决方法如何做到这一点？

更新

这更雷的忿怒，因为我想简单地添加一个连接器，并有该项目包含所有子模块依赖罐子。这会让pom更简单一些。

而不必注册所有子依赖像这么

<dependencies> 
     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1-api</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1-etl</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1-persistence</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2-api</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2-etl</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2-persistence</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2-other</artifactId> 
      <version>0.0.1</version> 
     </dependency> 
     ... 
</dependencies> 

这只是为了澄清原来的问题的例子。它不存在，如果它确实有效，可能会有反响。

<dependencies> 
     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1</artifactId> 
      <version>0.0.1</version> 
      <type>pom</type> 
      <include>submodules</include> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector2</artifactId> 
      <version>0.0.1</version> 
      <type>pom</type> 
      <include>submodules</include> 
     </dependency> 

</dependencies> 

如果我没有记错，我创造了一个订货系统在那里我有一个通用的API，我们的内部系统将使用（REST）模块化项目。我创建了一个路由系统，我可以根据订单的标准（国家，优先税等）将订单发送到单个履行中心。每个履行中心都有自己的api（连接器）。

该示例在原始问题中大大简化，使问题更加简洁。在实际的项目中，每个连接器（1,2,3）都将是一个独立的pom，并带有多个依赖关系罐。一个用于他们的客户端api，然后是一些etl代码来匹配我的原始api。

我不记得我是如何解决这个问题的。我想我只需要包含所有的子依赖项。

Answer 1

一种方法是创建第四个模块，它将3个模块“包装”为依赖关系。这样你可以依靠这个包装模块。

connectors - packaging: pom 
    connector1 - packaging: jar 
    connector2 - packaging: jar 
    connector3 - packaging: jar 
    connectorWrapper - packaging: pom (depends on the above three) 

尽管明确声明每个连接器的依赖关系更为明智，特别是它们只有三个。

替代解决方案：

更动态的方法（虽然非常矫枉过正IMO）是有这个第四模块封装使用定制assembly descriptor在装配实施模块。例如，里面connectorWrapper，你可以写一个assembly.xml：

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd"> 

    <id>impl-modules</id> 
    <formats> 
     <format>jar</format> 
    </formats> 
    <includeBaseDirectory>false</includeBaseDirectory> 
    <fileSets> 
     <fileSet> 
      <directory>${project.basedir}</directory> 
      <includes> 
       <include>pom.xml</include> 
      </includes> 
      <useDefaultExcludes>true</useDefaultExcludes> 
     </fileSet> 
    </fileSets> 
    <moduleSets> 
     <moduleSet> 
      <useAllReactorProjects>true</useAllReactorProjects> 
      <includes> 
       <include>*:connector*</include> 
      </includes> 
      <binaries> 
       <includeDependencies>false</includeDependencies> 
      </binaries> 
     </moduleSet> 
    </moduleSets> 
</assembly> 

注意，描述符告诉组装插件：

1. 包括在当前项目中反应器的所有模块，所以当你运行mvn clean package在根项目中，它将包括所有模块

2. 包括只有实现模块（connector模块如具有*:connector*的include元件中所指定的。

当然，你需要配置Assembly插件使用在connectorWrapper描述符（或任何其它名字，你选择这个包装）：

<plugins> 
    <plugin> 
     <artifactId>maven-assembly-plugin</artifactId> 
     <configuration> 
      <descriptors> 
       <descriptor>assembly.xml</descriptor> 
      </descriptors> 
     </configuration> 
     <executions> 
      <execution> 
       <id>make-assembly</id> 
       <phase>package</phase> 
       <goals> 
        <goal>single</goal> 
       </goals> 
      </execution> 
     </executions> 
    </plugin> 
</plugins> 

然后你就可以运行mvn install根项目安装程序集工件，之后，您可以从其他项目依赖它：

<dependencies> 
    <dependency> 
     <groupId>groupId</groupId> 
     <artifactId>connectorWrapper</artifactId> 
     <version>...</version> 
     <classifier>impl-modules</classifier> <!-- note the classifier --> 
    </dependency> 
</dependencies> 

Answer 2

不完全确定它是否确切y做你所需要的，但在最新的maven版本中，你可以在你的依赖关系上使用范围import。

的第一步是创建一个包含所有依赖关系的POM你想在其他项目包括：

<project> 

    <groupId>com.foo</groupId> 
    <artifactId>connectors</artifactId> 
    <version>0.0.1</version> 
    <packaging>pom</packaging> 

    <dependencies> 
     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1-api</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     <dependency> 
      <groupId>com.foo</groupId> 
      <artifactId>connector1-etl</artifactId> 
      <version>0.0.1</version> 
     </dependency> 

     ... 
    </dependencies>  
</project> 

在项目中要包括你的连接器：

<dependency> 
    <groupId>com.foo</groupId> 
    <artifactId>connectors</artifactId> 
    <version>0.0.1</version> 
    <type>pom</type> 
    <scope>import</scope> 
</dependency> 

查看Importing Dependencies了解更多信息。

另一种方法是使用maven程序集插件并创建一个包含所有需要包含的类（单个jar包）的单个（巨大）jar; （为此，您还需要创建一次带有所有依赖项和程序集插件的pom）。

Answer 3

我会为此write my own maven plugin。从你的声誉和问题来看，你可能会在一小时内准备好一些东西。最有可能比研究和尝试解决方案来做你想做的事更早。