`

Maven 聚合与继承

 
阅读更多

一、聚合

1.新建account项目，POM文件为

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.iteye.xujava</groupId>
	<artifactId>account</artifactId>
	<version>1.0.0</version>
	<packaging>pom</packaging>
	<name>account</name>

	<modules>
		<module>account-email</module>
		<module>account-persist</module>
	</modules>
</project>

 

2.在Eclipse中删除account-email,account-persist,将两个项目文件夹放在account文件夹下，在Eclipse重新引入这两个项目，修改account-persist中的service.properties内容为：persist.file=E:/mavenspace/account/account-persist/target/test-classes/persist-data.xml

 

3.运行mvn clean test

4.运行mvn clean install

 

二、继承

修改三个工和的POM文件

account的POM文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.iteye.xujava</groupId>
	<artifactId>account</artifactId>
	<version>1.0.0</version>
	<packaging>pom</packaging>
	<name>Account</name>

	<modules>
		<module>account-email</module>
		<module>account-persist</module>
	</modules>

	<properties>
		<springframework.version>2.5.6</springframework.version>
		<junit.version>4.9</junit.version>
	</properties>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-core</artifactId>
				<version>${springframework.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>${springframework.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</artifactId>
				<version>${springframework.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context-support</artifactId>
				<version>${springframework.version}</version>
			</dependency>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>${junit.version}</version>
				<scope>test</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	
	<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-resources-plugin</artifactId>
					<configuration>
						<encoding>UTF-8</encoding>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
</project>

 

account-email的POM文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>com.iteye.xujava</groupId>
		<artifactId>account</artifactId>
		<version>1.0.0</version>
                <!-- 当父项目的POM在上层时，其实可以不写relativePath -->
		<relativePath>../pom.xml</relativePath>
	</parent>

	<artifactId>account-email</artifactId>
	<name>Account Email</name>

	<properties>
		<javax.mail.version>1.4.1</javax.mail.version>
		<greenmail.version>1.3.1b</greenmail.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
		</dependency>
		<dependency>
			<groupId>javax.mail</groupId>
			<artifactId>mail</artifactId>
			<version>${javax.mail.version}</version>
		</dependency>
		<dependency>
			<groupId>com.icegreen</groupId>
			<artifactId>greenmail</artifactId>
			<version>${greenmail.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
	</dependencies>
</project>

 

account persist中的POM文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>com.iteye.xujava</groupId>
		<artifactId>account</artifactId>
		<version>1.0.0</version>
		<relativePath>../pom.xml</relativePath>
	</parent>

	<artifactId>account-persist</artifactId>
	<name>Account Persist</name>

	<properties>
		<dom4j.version>1.6.1</dom4j.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>dom4j</groupId>
			<artifactId>dom4j</artifactId>
			<version>${dom4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
	</dependencies>

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

 

运行mvn clean test

运行mvn clean install

 

三、超级POM

    超级POM位置在%M2_HOME%/lib/maven-model-builder-3.0.5.jar\org\apache\maven\model中，为pom-4.0.0.xml。

内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!-- START SNIPPET: superpom -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <!-- 仓库 -->
  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>http://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <!-- 插件仓库 -->
  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Central Repository</name>
      <url>http://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <build>
    <!-- 项目主输出目录 -->
    <directory>${project.basedir}/target</directory>
	<!-- 项目主代码输出目录 -->
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
	<!-- 最终构建的名称格式 -->
    <finalName>${project.artifactId}-${project.version}</finalName>
	<!-- 测试代码的输出目录 -->
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
	<!-- 主源码目录 -->
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
	<!-- 脚本源码目录 -->
    <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
	<!-- 测试源码目录 -->
    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <resources>
      <resource>
	    <!-- 主资源目录 -->
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
		<!-- 测试资源目录 -->
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>
    <pluginManagement>
      <!-- NOTE: These plugins will be removed from future versions of the super POM -->
      <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
	  <!-- 设定核心插件版本 -->
      <plugins>
        <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <version>1.3</version>
        </plugin>
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <version>2.2-beta-5</version>
        </plugin>
        <plugin>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

  <reporting>
    <outputDirectory>${project.build.directory}/site</outputDirectory>
  </reporting>

  <profiles>
    <!-- NOTE: The release profile will be removed from future versions of the super POM -->
    <profile>
      <id>release-profile</id>

      <activation>
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>

      <build>
        <plugins>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-javadoc-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>
<!-- END SNIPPET: superpom -->

 

四、反应堆

    1.在一个多模块的Maven项目中，反应堆指所有模块组成的一个构建结构。
    2.裁剪反应堆
      -am:--also-make同时构建所列模块的依赖模块
      -amd:-also-make-dependents 同时构建依赖于所列模块的模块
      -pl:--projects<arg> 构建指定的模块，模块间用逗号分隔
      -rf:-resume-from<arg>从指定模块回复反应堆

    3.例子

      mvn clean install(默认)

 

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Account ........................................... SUCCESS [1.341s]
[INFO] Account Email ..................................... SUCCESS [3.637s]
[INFO] Account Persist ................................... SUCCESS [2.348s]
[INFO] Account Captcha ................................... SUCCESS [3.149s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

 

mvn clean install -pl account-email,account-persist（指定构建的模块）
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Account Email ..................................... SUCCESS [4.316s]
[INFO] Account Persist ................................... SUCCESS [2.152s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
 
    mvn clean install -pl account-email -am(同时构建所指定模块的依赖模块)
  
[INFO] Reactor Summary:
[INFO]
[INFO] Account ........................................... SUCCESS [0.739s]
[INFO] Account Email ..................................... SUCCESS [3.627s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
 

    mvn clean install -pl account-parent -amd(同时构建依赖于所列模块的模块,假设有account-parent模块，其他模块都依赖于它) 

 

 

    mvn clean install -rf account-persist（在完整反应堆构建顺序的基础上指定从哪个模块开始构建，原来大排在它之前的将不执行,原来Account和Account Email排在Account Persist之前，参考默认执行）

 

[INFO] Reactor Summary:
[INFO]
[INFO] Account Persist ................................... SUCCESS [4.326s]
[INFO] Account Captcha ................................... SUCCESS [2.864s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

 

 mvn clean install -pl account-parent -amd -rf account-captcha(首先-pl account-parent构建出Email、Persist、Captcha三个模块,然后 -rf account-captcha从Captcha开始构建，Capthca在完整的反应堆中又是最后一个构建，则最终只构建Captcha。假设有account-parent模块，其他模块都依赖于它) 

 

分享到：
| Maven account-persist例子
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    maven聚合与继承配置

    **三、继承与聚合的结合** 在实际项目中，聚合和继承往往结合使用。`parent`项目作为一个聚合项目，包含了多个子项目，同时作为父项目，它定义了通用的配置供子项目继承。这种方式有助于保持项目结构清晰，减少代码...

    Maven聚合与继承实例详解.docx

    Maven聚合（Aggregation）功能则允许我们将多个Maven项目组合成一个单一的构建单元。通过在父POM中使用`&lt;modules&gt;`标签，可以列出所有子模块，Maven在构建时会按顺序编译和打包每个子模块。这在处理大型多模块项目时...

    maven依赖+继承+聚合

    最后是"Maven聚合"。聚合（Aggregation）是指在单个Maven项目中管理多个子项目的能力。在`pom.xml`中定义`modules`标签，可以将多个子项目包含进来。这样，当我们在顶层项目上执行命令时，Maven会递归地构建所有子...

    maven聚合和继承

    Maven聚合（Aggregation）是用来管理多个相关项目的方式，这些项目可能共享一部分代码或者有共同的构建目标。在POM中，我们可以通过设置`&lt;modules&gt;`标签来指定一个父项目下的子项目。这样，当我们在父项目执行构建...

    maven继承与聚合代码

    **二、Maven聚合** Maven的聚合功能则用于管理多个相关项目，把它们组合成一个整体。这主要通过`&lt;modules&gt;`标签来实现，它允许在一个POM中列出一系列子模块，使得我们可以一次性构建这些模块。聚合POM并不直接影响...

    maven聚合项目

    总结来说，这个"Maven聚合项目"是一个集成了聚合、继承、插件管理和私服使用的实例，展示了如何高效地管理和构建多模块的Java项目。通过这种方式，开发团队可以更有效地协同工作，保证项目的稳定性和一致性。

    Maven的聚合与继承DEMO（以及前后端分离）

    在本文中，我们将深入探讨 Maven 的聚合与继承特性，并结合前后端分离的实践，来创建一个高效的开发环境。Maven 是 Java 开发中广泛使用的构建工具，它通过配置管理依赖关系，简化项目的构建、测试和部署过程。让...

    maven聚合工程demo

    总结来说，"maven聚合工程demo"是一个利用 Maven 聚合和继承机制，结合 SSH 框架构建的多模块 Java Web 应用项目。通过聚合，我们可以高效地管理多个子项目，通过继承，我们保持了配置的一致性。同时，"META-INF" 和...

    maven聚合实例

    "maven聚合实例"正是讨论如何通过Maven的聚合（Aggregation）功能来组织这些子项目。 Maven聚合允许我们在一个父项目中管理多个子项目，这个父项目被称为"聚合模块"或"顶级模块"，在本例中是`demo-top`。这种结构...

    maven聚合项目模板

    "maven聚合项目模板"是指使用Maven创建的一种特殊结构，用于组织多个相关但独立的子项目，使得这些子项目可以作为一个整体进行构建和管理。这种方式在大型项目或者有多个子模块的项目中非常常见。 1. **模块分组**...

    apache-maven-3.9.2.zip配置好的阿里云仓库文件

    10. Maven聚合与继承：Maven支持项目间的聚合和继承，聚合允许将多个项目组合在一起作为一个整体进行构建，而继承则允许共享部分POM配置，减少重复代码。 总的来说，这个预配置好的“apache-maven-3.9.2.zip”文件...

    maven 依赖，聚合，继承，插件运行应用

    在"Maven 依赖，聚合，继承，插件运行应用"这个主题中，我们将深入探讨这四个核心概念。 1. **依赖管理**：Maven依赖是项目中各个模块之间共享代码的关键机制。当你在POM.xml文件中声明一个依赖，Maven会自动下载并...

    通过Maven的聚合和继承特性创建多模块项目示例

    Maven，作为Java开发中的构建工具，提供了强大的聚合（Aggregation）和继承（Inheritance）特性，使得多模块项目的管理变得高效且有序。本文将深入探讨如何利用这两个特性来创建一个复杂的多模块项目，并通过提供的...

    Maven 实战源码

    6. Maven聚合与继承： - 聚合项目将多个模块组合在一起，方便一次性构建所有子模块。 - 继承项目提供了一种共享配置的方式，子项目可以从父项目继承部分配置。 7. Maven profile： - 用于定义不同环境（如开发、...

    Maven使用培训PPT（巨全）

    ### Maven聚合与继承介绍 Maven支持项目聚合，意味着可以将多个模块打包为一个大项目进行管理，这对于大型项目非常有用。同时，Maven通过parent和modules元素支持项目继承，可以定义一个父POM来复用和管理子模块的...

    Maven安装配置教程及仓库、POM坐标系、Maven工程、继承与聚合

    ### Maven安装配置教程及仓库、POM坐标系、Maven工程、继承与聚合 #### Maven安装与配置 在开始之前，我们首先需要了解Maven是什么。Maven是Apache的一个项目，是一个项目管理和综合工具，主要用来帮助Java项目...

    Maven.Definitive.Guide

    8. Maven聚合与继承： - 聚合（Aggregation）：将多个Maven项目组合在一起进行构建，便于管理大型项目。 - 继承（Inheritance）：子项目继承父项目的POM，可以共享配置，减少重复代码。 9. 配置Maven： - `...

    java maven 聚合项目 分模块 socket 双向通信实例demo

    在Java开发中，Maven聚合项目（Aggregator Project）是一种管理多模块项目的方式，它允许开发者在一个父项目中集合并构建多个子项目。这样的结构有助于代码的组织和依赖管理，特别是当项目涉及到多个独立但相互关联...

    java_maven高级笔记

    6. **Maven聚合与继承** - **聚合项目**：一个POM可以包含多个模块，方便管理多模块项目。 - **继承关系**：子POM可以从父POM继承配置，减少重复代码。 7. **Maven的生命周期与构建过程** - **清理**：clean生命...

Magicbox
Global site tag (gtag.js) - Google Analytics