一篇文章带你彻底了解Maven

最新推荐文章于 2022-10-13 16:21:06 发布
最新推荐文章于 2022-10-13 16:21:06 发布
阅读量388 收藏 1
点赞数
分类专栏： 工具 文章标签： maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21963133/article/details/90339672
版权

1.简介

Maven是一个项目管理工具，在当今社会是应用最广泛的项目构建工具之一，其强大的依赖管理功能和它全套的项目打包测试等使其成为了当下项目构建的首选工具。此外，Maven能够很方便的帮你管理项目报告，生成站点，管理JAR文件，等等。

2.安装

maven是属于Apache下的一个顶级开源项目，在浏览器搜索即可进行下载。进入官网中，左边的那一栏是导航菜单，主要是描述了什么是maven、maven的特点和用处、下载、怎样使用、所有的版本、插件、文档、用户中心等等。有兴趣的朋友可以将这些菜单项都浏览一遍。下面我们主要介绍如何进行安装和使用。点击Download即可进入下载页面，目前最新的版本是3.6.1。一般我们选择下载最新版本的就可以了。这里有两个版本一个是二进制的，一个是源码版的。这里我们选择二进制的即可。下载完成之后解压即可。

解压完成之后，我们就需要配置它的环境变量。

这里新建一个MAVEN_HOME只想刚才解压之后的路径

然后在path中加入bin目录的路径即可。

%MAVEN_HOME%\bin;

点击确定在cmd窗口中输入  mvn -version，如果出现maven的版本信息则说明配置成功。

3.maven基础配置。

打开maven目录下面的conf文件下面的settings.xml，将localRepository仓库的地址设置为本地其他的路径，因为默认会在用户目录的.m2目录下面的repository目录下面新建仓库，由于是在c盘，所以这里我们需要将他进行更改。

然后找到mirror镜像的配置，这里我们将添加一个阿里云的镜像，速度在国内是比较快的。镜像可以配置多个。

j

<mirror>
      <id>alimaven</id>
	  <name>aliyun maven</name>
	  <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
	  <mirrorOf>central</mirrorOf>
    </mirror>

4.手动构建第一个HelloWorldmaven项目。

新建一个文件夹名为demo1（项目名），然后在demo1里面创建如下图所示的目录结构，

demo1下面有一个src，然后src下面有main和test里面的结构大致相同，还有一个pom.xml，这里面存放的就是项目的主要配置信息，在这里面我们加入Junit的测试。

<?xml version="1.0" encoding="UTF-8"?>
<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.mvn</groupId>
    <artifactId>demo1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties> 
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    </properties>  
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    

</project>

在main里面新建HelloWorld类

package com.mvn.test;

public class HelloWorld {
    public void sayHello(){
        System.out.println("Hello World");
    }
}

然后在test里面新建HelloWorldTest类，用于测试HelloWorld，

package com.mvn.test;

public class HelloWorldTest {
    public void sayHello(){
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.sayHello();
    }
}

在demo1目录下打开命令行窗口，执行编译命令 mvn compile

编译成功之后，在demo1下面新生成了一个target文件夹。我们先不管这个，再次运行mvn test命令。注意如果是第一次运行的话，会下载一些maven所依赖的一些插件，耗时相对会比较久一点。

成功运行test命令之后，在控制台输出了Hello World。test运行成功之后，我们再来运行一个命令 mvn install。

出现成功提示之后，我们在本地的仓库里面就可以看到我们这个项目的依赖了。

查看我们的仓库，生成了一个新的依赖，目录为com/mvn/demo1，细心的朋友会发现这个目录其实就是pom.xml中groupId和artifactId的合。打开里面的xml可以看到当前我们这个依赖的坐标信息和最后一次更新的时间是一个时间戳的格式。

<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>com.mvn</groupId>
  <artifactId>demo1</artifactId>
  <versioning>
    <versions>
      <version>1.0-SNAPSHOT</version>
    </versions>
    <lastUpdated>20190519034330</lastUpdated>
  </versioning>
</metadata>

打开snapshot文件夹可以看到生成了一个jar包，在项目中，如果引用这个依赖的话，其实就会导入当前这个jar，这里的pom文件跟刚才我们新建的pom文件的内容是一样的。

5.idea集成maven插件。

在实际的开发中，我们都是用一些工具来配合maven进行开发的，下面我们就来看一下在idea中如何来配置并创建maven项目。

打开idea的设置。在Build栏目下面的build tools下面点击maven，在右侧就会显示maven的配置界面，这里我们将maven Home设置为我们本地的maven目录，usersettings页选择本地的settings.xml。配置完成之后点击ok即可。

然后就可以创建maven项目了，在idea中依次点击file--new--project。z在弹出的界面的左侧选择maven，sdk选择自己的jdk即可。这里的create from archetype的意思就是通过骨架来创建项目，这种方式创建的项目会默认集成了一些东西，有些公司为了开发方便也会自己集成一套框架来做成一个骨架，开发时只需导入这个骨架然后从骨架创建项目，新生成的项目就会包含这套框架系统。由于我们这里是初学者，我们创建一个纯净的项目，直接点击下一步。

在新的界面中输入groupId和artifactId，groupId一般是组织名，公司网址的反写，artifactId则是我们的模块名。版本号这里默认即可，当然也是可以修改的。点击下一步

在这里设置项目的名字和路径，然后点击finish完成创建。

到此，我们就创建了一个纯净的maven项目了。

6.maven的生命周期。

参考：http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

构建生命周期基础

Maven基于构建生命周期的核心概念。这意味着构建和分发特定工件（项目）的过程被明确定义。。

对于构建项目的人来说，这意味着只需要学习一小组命令来构建任何Maven项目，POM将确保他们获得所需的结果。

有三个内置的构建生命周期：默认（default），清理（clean）和站点（site）。在默认的生命周期处理你的项目部署，清理的生命周期处理项目的清理，而站点的生命周期处理你的项目站点文档的创建。

构建生命周期由阶段组成

这些构建生命周期中的每一个都由不同的构建阶段列表定义，其中构建阶段表示生命周期中的阶段。

例如，默认生命周期包括以下阶段（有关生命周期阶段的完整列表，请参阅生命周期参考）：

  • validate - 验证项目是否正确并且所有必要信息都可用
  • compile - 编译项目的源代码
  • test - 使用合适的单元测试框架测试编译的源代码。这些测试不应要求打包或部署代码
  • package - 获取已编译的代码并将其打包为可分发的格式，例如JAR。
  • verify - 对集成测试结果进行任何检查，以确保满足质量标准
  • install - 将软件包安装到本地存储库中，以便在本地用作其他项目的依赖项
  • deploy - 在构建环境中完成，将最终包复制到远程存储库以与其他开发人员和项目共享。

这些生命周期阶段（以及此处未显示的其他生命周期阶段）将按顺序执行，以完成默认生命周期。鉴于上面的生命周期阶段，这意味着当使用默认生命周期时，Maven将首先验证项目，然后将尝试编译源代码，针对测试运行，打包二进制文件（例如jar），对其运行集成测试包，验证集成测试，将经过验证的软件包安装到本地存储库，然后将已安装的软件包部署到远程存储库。

生命周期参考

下面列出了默认，清理和站点生命周期的所有构建阶段，这些阶段按照指定的顺序执行。

清洁生命周期

阶段描述
pre-clean在实际项目清理之前执行所需的过程
clean删除上一个版本生成的所有文件
post-clean执行完成项目清理所需的过程

默认生命周期

阶段描述
validate验证项目是否正确，并提供所有必要信息。
initialize初始化构建状态，例如设置属性或创建目录。
generate-sources生成任何包含在编译中的源代码。
process-sources处理源代码，例如过滤任何值。
generate-resources生成包含在包中的资源。
process-resources将资源复制并处理到目标目录，准备打包。
compile编译项目的源代码。
process-classes从编译中对生成的文件进行后处理，例如对Java类进行字节码增强。
generate-test-sources生成任何测试源代码以包含在编译中。
process-test-sources处理测试源代码，例如过滤任何值。
generate-test-resource创建用于测试的资源。
process-test-resources将资源复制并处理到测试目标目录中。
test-compile将测试源代码编译到测试目标目录中
process-test-classes从测试编译中对生成的文件进行后处理，例如对Java类进行字节码增强。适用于Maven 2.0.5及以上版本。
test使用合适的单元测试框架运行测试。这些测试不应要求打包或部署代码。
prepare-package在实际包装之前执行准备包装所需的任何操作。这通常会导致包的解包，处理版本。（Maven 2.1及以上）
package获取已编译的代码并将其打包为可分发的格式，例如JAR。
pre-integration-test在执行集成测试之前执行所需的操作。这可能涉及诸如设置所需环境之类的事情。
integration-test如有必要，将程序包处理并部署到可以运行集成测试的环境中。
post-integration-test执行集成测试后执行所需的操作。这可能包括清理环境。
verify运行任何检查以验证包是否有效并符合质量标准。
install将软件包安装到本地存储库中，以便在本地用作其他项目的依赖项。
deploy在集成或发布环境中完成，将最终包复制到远程存储库以与其他开发人员和项目共享。

站点生命周期

阶段描述
pre-site在实际项目站点生成之前执行所需的过程
site生成项目的站点文档
post-site执行完成站点生成所需的流程，并准备站点部署
site-deploy将生成的站点文档部署到指定的Web服务器

7.pom.xml详解

首先我们来看一下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>
 
  <!-- The Basics -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <dependencies>...</dependencies>
  <parent>...</parent>
  <dependencyManagement>...</dependencyManagement>
  <modules>...</modules>
  <properties>...</properties>
 
  <!-- Build Settings -->
  <build>...</build>
  <reporting>...</reporting>
 
  <!-- More Project Information -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>
 
  <!-- Environment Settings -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

project：整个配置文件的根标签

modelVersion：模块版本号这时maven的版本号，这里我们不用管。

模块基础配置：

groupId：组织名，公司名等，一般是公司网址的反写。如taobao.com,则可以写成com.taobao

artifactId：模块名，这个必须是唯一的，如taobao-pay。

version：当前模块的版本号

packing：打包方式，常见的有：jar，war，pom

name：项目名称

parent：父工程

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
</parent>

dependencyManagement：依赖管理，一般用于定义依赖的版本号，在父工程中。

dependencies：项目的依赖

dependency：用于定义一个依赖。

  结构为：其中scope用于指明此依赖的作用范围，主要有五个可选值。

* compile，缺省值，适用于所有阶段，会随着项目一起发布。 
* provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。 
* runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。 
* test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。 
* system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。

 exclusions：用排除依赖中的一些依赖。

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.1.3.RELEASE</version>  
      <scope>provided</scope>  
      <!-- 去除内嵌tomcat -->
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

models：父工程中所包含的子模块定义在这里。

<modules>
        <module>../cfcc-core</module>
        <module>../cfcc-app</module>
        <module>../cfcc-browser</module>
        <module>../cfcc-demo</module>
    </modules>

properties：定义变量，以便后续的使用

     

构建设置

build：这里进行一些插件，打包相关的设置，如：在我们的springboot项目中，如果需要将resources下面的所有静态文件打包到jar中，就可以向下面这样设置。还有mybatis代码生成插件的配置等。

<build>
        <resources>
            <resource>
                <directory>${basedir}/src/main/webapp</directory>
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>false</filtering>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>1.4.2.RELEASE</version>
                <configuration>

            </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                    <configurationFile>${basedir}/src/main/resources/generator/generatorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                </configuration>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>com.yifeng.yfcore.YfCore</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

reporting：相比于build中的插件，打包相关构建的配置，这个阶段主要是作用于site站点相关的配置。

  <reporting>
    <excludeDefaults></excludeDefaults>
    <outputDirectory>${basedir}/target/site</outputDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-project-info-reports-plugin</artifactId>
        <version>2.0.1</version>
        <reportSets>
          <reportSet>
            <id>sunlink</id>
            <reports>
              <report>javadoc</report>
            </reports>
            <inherited>true</inherited>
            <configuration>
              <links>
                <link>http://java.sun.com/j2se/1.5.0/docs/api/</link>
              </links>
            </configuration>
          </reportSet>
        </reportSets>
      </plugin>
    </plugins>
  </reporting>

execludeDefaults：执行site时，是否生成报表，默认false

outputDirectory：报表的生成目录，默认为target下面的site目录下

plugin：报表所用到的一些插件。

8.继承和聚合：

继承：用于父子工程之间的依赖。比如我们在开发一个大的系统时，由于需要管理的依赖比较多，项目被分成了很多的模块，这时我们就需要一个统一的父工程来管理我们公用的一些依赖和版本号，而此时的父工程一般定义成pom工程，然后在子工程中就可以直接引用这个父工程，而且不用写版本号。比如我们大家比较熟悉的springboot项目开发中，我们需要在开始的时候引入parent，然后直接在下面定义我们需要的依赖就可以了。如下面的这个父工程，就只有一个pom.xml（以前的一个老项目的配置）。

<?xml version="1.0" encoding="UTF-8"?>
<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.beyond</groupId>
    <artifactId>beyond-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!-- 集中定义依赖的版本号 -->
    <properties>
        <junit.version>4.12</junit.version>
        <spring.version>4.3.3.RELEASE</spring.version>
        <mybatis.version>3.2.8</mybatis.version>
        <mybatis.spring.version>1.3.1</mybatis.spring.version>
        <mybatis.paginator.version>1.2.15</mybatis.paginator.version>
        <mysql.version>5.1.4</mysql.version>
        <slf4j.version>1.6.4</slf4j.version>
        <jackson.version>2.9.0</jackson.version>
        <druid.version>1.0.9</druid.version>
        <httpclient.version>4.3.5</httpclient.version>
        <jstl.version>1.2</jstl.version>
        <servlet-api.version>3.1.0</servlet-api.version>
        <jsp-api.version>2.0</jsp-api.version>
        <joda-time.version>2.5</joda-time.version>
        <commons-lang3.version>3.3.2</commons-lang3.version>
        <commons-io.version>1.3.2</commons-io.version>
        <commons-net.version>3.3</commons-net.version>
        <pagehelper.version>3.4.2-fix</pagehelper.version>
        <jsqlparser.version>0.9.1</jsqlparser.version>
        <commons-fileupload.version>1.3.1</commons-fileupload.version>
        <jedis.version>2.9.0</jedis.version>
        <solrj.version>4.10.3</solrj.version>
    </properties>

    <!-- 定义依赖的版本 -->
    <dependencyManagement>

        <dependencies>
            <!-- 时间操作组件 -->
            <dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>${joda-time.version}</version>
            </dependency>
            <!-- Apache工具组件 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons-lang3.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons-io.version}</version>
            </dependency>
            <dependency>
                <groupId>commons-net</groupId>
                <artifactId>commons-net</artifactId>
                <version>${commons-net.version}</version>
            </dependency>
            <!-- Jackson Json处理工具包 -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <!-- httpclient -->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>${httpclient.version}</version>
            </dependency>
            <!-- 单元测试 -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <!-- 日志处理 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <!-- Mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis.spring.version}</version>
            </dependency>
            <dependency>
                <groupId>com.github.miemiedev</groupId>
                <artifactId>mybatis-paginator</artifactId>
                <version>${mybatis.paginator.version}</version>
            </dependency>
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>${pagehelper.version}</version>
            </dependency>
            <!-- MySql -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- 连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!-- Spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!-- JSP相关 -->
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet.jsp</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <!-- 文件上传组件 -->
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>${commons-fileupload.version}</version>
            </dependency>
            <!-- Redis客户端 -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${jedis.version}</version>
            </dependency>
            <!-- solr客户端 -->
            <dependency>
                <groupId>org.apache.solr</groupId>
                <artifactId>solr-solrj</artifactId>
                <version>${solrj.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
    <!-- 资源文件拷贝插件 -->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.6</version>
        <configuration>
            <encoding>UTF-8</encoding>
        </configuration>
    </plugin>
    <!-- java编译插件 -->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <encoding>UTF-8</encoding>
        </configuration>
    </plugin>
    </plugins>
        <pluginManagement>
            <plugins>
                <!-- 配置Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>


</project>

聚合：在继承中，项目之间的关系是父子的关系，子的许多东西必须要依赖于父。而在我们的聚合关系中，是由多个子模块共同组成一个大的功能模块，各个子模块相互独立且又存在依赖的关系。相比于继承定义一个统一管理的版本，聚合则是将多个子模块共同组成一个独立的功能模块。在pom的models中引入各个子模块。

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <modules>
        <module>beyond-manager-pojo</module>
        <module>beyond-manager-mapper</module>
        <module>beyond-manager-service</module>
        <module>beyond-manager-web</module>
    </modules>

    <parent>
        <groupId>com.beyond</groupId>
        <artifactId>beyond-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.beyond</groupId>
    <artifactId>beyond-manager</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <dependencies>
        <dependency>
            <groupId>com.beyond</groupId>
            <artifactId>beyond-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <!-- 配置插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

9.依赖的范围、传递和排除

范围：其实在前面已经提到过，在dependency中的scope中可以定义我们的依赖范围。

compile：默认的，编译测试运行时都有效。

provided：编译和测试有效。

runtime：测试运行时有效

test：测试时有效

system：编译测试有效，与本机系统相关联，可移植性差

import：导入的范围，只使用在dependencyManagement中，表示从其他的pom中导入dependency的配置，如在spring的项目中，我们使用springio来管理我们的依赖版本那么就可以这样使用。

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.spring.platform</groupId>
                <artifactId>platform-bom</artifactId>
                <version>Brussels-SR7</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

传递：A依赖B，B依赖C，那么A就依赖C

排除：当我们不需要所依赖的模块中的某一个依赖时，就可以将它排除掉。比如在springboot中排除Tomcat的依赖

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.1.3.RELEASE</version>  
      <scope>provided</scope>  
      <!-- 去除内嵌tomcat -->
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

冲突：

短路优先：A依赖B的xjar包，B依赖C的xjar包，但是版本不同，这时A会使用路径最短的B的xjar包

先声明先优先：A依赖B的xjar包，A也依赖C的xjar包，在A中同时引入了B和C的xjar包，那么谁先声明就依赖谁。

 

 

氵易风灬
关注
专栏目录
java技术专家 【安全框架第零篇】 带你彻底了解Shiro
大壮
12-23 320
java技术专家 【安全框架】 1 带你彻底了解Shiro
IntelliJ IDEA快速入门 | 第三十四篇：IntelliJ IDEA中Maven的配置与使用
李阿昀的博客
04-12 5909
在这篇文章中，咱们来说一下在IntelliJ IDEA当中是如何来配置Maven的。 简单介绍一下Maven Maven是Apache提供的一款自动化构建工具，用于自动化构建和依赖管理。开发团队基本不用花多少时间就能自动完成工程的基础构建配置，因为Maven使用了一个标准的目录结构和一个默认的构建生命周期。现在你知道这点了吧，就是Maven会使得开发者的工作变得更简单。 这里，我来稍微讲讲自动化构建工具的发展历史，最初开发者用的是Make，然后用的是Ant，接下来就出现了Maven，然而在Maven出现之后
了解Maven
qq_42060533的博客
08-09 219
Maven 一、Maven是什么？ 以前没在公司上过班，很少了解Maven，只知道它是整合jar包的一个强大的工具，因为Java开发中会需要导入很多jar包，而如果版本的不一样会导致各种错误，我有挺多次是因为jar包的版本不兼容导致各种报错，所以现在上班了，需要好好熟悉Maven这个强大的工具。 Maven的中文翻译为‘专家’。是Apache组织中一个颇为成功的开源项目，主要服务于基于Java平...
彻底理解maven
weixin_33971205的博客
04-29 177
前言最近解决jar包冲突问题时，很头疼，发现自己对maven的理解太肤浅了，很多细节都一知半解，于是最近又学习了一把maven，总结如下：基本概念maven有两个最基本的概念： pom和lifecycle， 这里的pom不是maven构建过程中使用的pom文件，但他们之间有联系。 pom全称为Project Object Model, 简单说就是要对构建的项目进行建模，将要构建的项目看成是一个对象...
一篇文章掌握Maven
Java笔记虾
12-10 354
Maven是什么？Maven，这个单词来源于犹太语，意味着知识的积累。最初在Jakarta Turbine 项目中用来简化构造项目流程。最终，形成基于Java项目的构建和管理的工具。安装...
maven深入理解（一）
expect521的博客
09-19 611
代码块 <dependency> <groupId>com.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>3.0.2</version> </dependency>1.groupId: 准确的说是项目所在的
想彻底了解maven，有这篇文章足够了(一)——介绍、目录结构、maven的各个命令、maven的生命周期
公众号-老炮说Java
05-21 620
一．简单介绍Maven主要是用来管理项目，主要是对java项目的管理。对java项目进行构建，节省时间，没必要把太多的时间花在项目的构建上项目的构建过程：Clean(清除) 、compile(编译)、test(test)、package(打包) 、install(部署)、site(站点报告生成二、maven项目约束的目录结构Mavenproject     --src       --main  ...
IDEA强制清除Maven缓存的方法示例
08-18
在开发Java项目时，IntelliJ IDEA (IDEA) 是许多开发者首选的集成开发环境，而Maven作为项目管理和构建工具，广泛应用于Java项目。然而，有时Maven的缓存可能会...希望这篇文章能帮助你更好地管理和维护你的Java项目。
maven自定义catalog创建archetype
LFF1991的博客
08-01 8800
1.创建一个maven项目作为模板，官方说创建archetype类型的,我个人没有试验成功，如有可行案例请指点一下。 要说自定义catalog这个坑我个人可是踩得狠了，整整痛苦了我三天时间，也许这是小白必须经历的过程吧！在这里我要感谢一篇文章的博主。正是通过这篇文章我得到了解决问题的思路。如有需要可以参考下列链接： http://blog.csdn.net/wanxu12345678910/ar
了解maven
DSM781314056的博客
02-17 136
Maven 1.什么是maven Maven是一个项目管理I具,使用Maven可以来管理企业级的Java项目开发及依赖(jar包)的管理。 使用Maven开发,可以简化项目配置,统一-项目结构。 总之, Maven可以让开发者的工作变得更简单。 2.什么是依赖管理? 要明白依赖管理,首先要知道什么是依赖? 一个Java项目中往往会依赖一些第三方的jar包。比如JDBC程序中要依赖数据库驱动包,或者在使用c3p0连接池时,要依赖c3p0的jar包,再或者解析xml文件时需要导入dom4j的jar包等。这时我
maven了解
最新发布
qq_53863770的博客
10-13 119
如果对于多个版本没法统一控制,我么可以通过一个变量批量控制使用到了spring-jdbc仓库、本地仓库，远程仓库，不写笔记了你上b上一搜一堆解释的Maven的生命周期、主要分为compile 编译项目的源代码test-compile 编译测试源代码test 进行单元测试，便于打包package 打包成可发布格式install 安装到本地仓库插件和目标、继承、父工程pom文件
想彻底了解maven，有这篇文章足够了(中)
公众号-老炮说Java
03-04 350
五、Maven的依赖传递 1依赖传递测试 首先创建mavenA/mavenB/mavenC三个项目， 验证的是B-&gt;A C-&gt;B ,C不直接依赖A，那么c中有A 、B A-&gt;B, 首先的对A项目进行 maven install ，编译打包上传到本地仓库中，这样该项目才会有坐标，根据坐标才会找到对应的jar(前提必须本地仓库有jar) C-&gt;B ...
简单了解maven
weixin_40139002的博客
04-21 180
简单了解maven maven是什么 [转载来源]（https://www.cnblogs.com/whgk/p/7112560.html） Maven是基于项目对象模型，可以通过一小段的描述信息来管理项目的搭建。Maven的核心功能是合理叙述项目间的依赖关系，通俗点讲，就是通过pom.xml文件的配置获取jar包，不用手动的去添加jar包。 Jar包的来源 maven中jar包主要来源于：本地仓...
Maven-认识Maven（1）
Wizard的博客
08-23 391
   Maven的使用不光可以可以减少项目的大小，同时也可以对项目更加的科学化管理。因为原来的开发项目每个人都有自己的开发习惯，但是引入Maven，可以规范开发，因为Maven更多的是注重约定。例如Maven项目的源码以及编译文件或者测试代码都是放在指定位置文件夹。这样我们在接管公司遗留项目时，可以快速找到相应文件。       对于我这个只是听说但是没用过Maven的人来说，初次接触Maven...
对maven的深入理解
LittleCadet
08-26 578
最近需要做maven的配置管理，这里做个记录，有延伸。 1.对本地仓库的配置： 本地仓库不宜放在C盘：原因：a.本地仓库大小约为1G，占用内存 B.万一重装系统，C盘内容消失，build workSpace时间漫长 更改本地仓库方法：a.在maven安装包的conf/settings.xml中设置D:\tools\maven\m2\r...
maven的简单了解
码小春的博客
12-13 598
前言 在学习Maven之前，我们先来看一下我们现在做的项目都有哪些问题。假设你现在做了一个crm的系统，项目中肯定要用到一些jar包，比如说mybatis，log4j，JUnit等，除了这些之外，你有可能用到你的同事开发的其他的东西，比如说别人做了一个财务模块或做了一个结算的模块，你在这里边有可能要用到这些东西。 假如有一天你们的项目中mybatis进行了一个升级，但是它内部使用的JUnit没有升级，你升级以后的mybatis假如要用5.0的JUnit，而你项目中目前用的是4.0的，会不会冲突.
SpringMVC Maven配置教程：一步步教你搭建环境
"这篇教程主要介绍了如何使用Maven配置Spring MVC项目，内容包括环境准备、创建Maven Web项目、目录结构设定、以及基本的模块划分。" 在开发Java Web应用时，Spring MVC作为主流的MVC框架，常与Maven一起使用进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值