Maven总结

一、什么是Maven，Maven的作用是什么

​ Maven是一款服务于Java平台的自动化构建工具。Maven是一款用于 Java 项目的管理工具，它不仅可以用作包管理，还有许多的插件，可以支持整个项目的开发、打包、测试及部署等一系列行为。

1. 例如：如果没有使用Maven工具去构建项目时，当做 Java 项目需要第三方依赖包时，我们都是将别人打好的 Jar 包下载到本地，然后比如手动创建lib文件夹，把jar包复制到里面，然后指定添加到项目。所以每当新建一个项目的时候，又得重新下载，重新指定，这个过程操作麻烦。而用了 Maven 之后，需要什么包，直接在 pom.xml 中添加几行 xml 代码（添加所依赖jar包的坐标），指定包名、版本等，就可以了，这样maven就可以自动根据你添加的依赖下载所需要的jar包了。
2. 其次，maven还具有热部署，热运行的功能。当你脱离idea等开发工具，使用maven也可以让你的项目运行起来，比如运行web项目，我们可以先下载tomcat的插件，然后运行即可如：mvn tomcat7:run，Maven 是跨平台的，这意味着无论是在 Windows 上，还是在 Linux 或者 Mac 上，都可以使用同样的命令
3. maven还可以很好帮我们管理项目，如统一控制项目的版本（jdk的版本、整个工程的jar包的版本）、添加插件，可以避免使用的jar包版本不同，产生问题。

二、概述

1、maven的下载和安装

????小知识点： 作为一个java程序员 apache 网站的规律得知道都是 项目名.apache.org

下载地址：http://maven.apache.org/

配置环境变量：

1. 解压
2. 配置MAVEN_HOME
3. 配置path，%MAVEN_HOME%bin
4. 重新打开cmd执行 mvn -v ，出现以下界面，成功

2、maven的核心配置文件

maven的核心配置文件：

（1）配置路径

先建立好这个文件夹，然后添加这个命令，指定下载的jar包到这个目录，不然默认下载到：C:UsersSayHello.m2repository（C盘的用户的当前用户的.m2文件夹的repository文件内）

<localRepository>D:/repository</localRepository>

（2）配置阿里云镜像

要不啥也下不动

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

（3）配置全局编译jdk版本

<profile>
<id>jdk-1.8</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.8</jdk>
</activation>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
</properties>
</profile>

3、常常鲜，体验

maven标准目录

src
|--main
|--java
源代码目录
|--resources
资源目录
|--test
|--java
测试代码目录
|--resources
测试资源目录
|--target
|--classes
编译后的class文件目录
|--test-classes 编译后的测试class文件目录
pom.xml
Maven工程配置文件

这是大部分Maven工程的目录结构，在这个基础上可以合理地增删目录。

根据这个目录结构，到本地新建一个文件夹创建一个项目：

mian里面写一个Java文件：

public class Hello{
public static void main(String args[]){
System.out.println("Hello maven!");
}
}

可以再resources文件夹下新建db.properties配置文件，或随便帮一个文件；

然后回到项目的地址，如我这里是aaa

cmd回车；

执行，以下命令，可能会从网上下载内容，是在下载插件，不要担心。

mvn compile

结果，并生成target目录

结果发现，我们的项目target内竟然多了一些文件，其次我们编译后的class和配置文件都统一被放在了classes文件夹内：

4、maven的生命周期（重点）

默认（default）的生命周期包括以下阶段（该阶段经过简化，实际上更加复杂）：

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

mvn install

此命令在执行安装之前按顺序（验证（validate），编译（compile），打包（package）等）执行每个默认生命周期阶段。在这种情况下，您只需要调用最后一个构建阶段来执行，安装（install）。

在构建环境中，使用以下调用将工件清理地构建并部署到共享存储库中。

mvn clean deploy

相同的命令可以在多模块场景（即具有一个或多个子项目的项目）中使用。Maven遍历每个子项目并执行清洁（clean），然后执行部署（deploy）（包括所有之前的构建阶段步骤）。

注意：在我们开发阶段，有一些生命周期的阶段，比如验证（validate）这些，基本很少用到。只要使用关键的几个基本能满足需求。

5、Maven 常用命令

下面maven比较常见的一些命令。

6、Maven的版本规范（我们的项目）

所有的软件都用版本

Maven使用如下几个要素来定位一个项目，因此它们又称为项目的坐标。

• groudId 团体、组织的标识符。团体标识的约定是，它以创建这个项目的组织名称的逆向域名开头。一般对应着JAVA的包的结构，例如org.apache。
• artifactId 单独项目的唯一标识符。比如我们的tomcat, commons等。不要在artifactId中包含点号(.)。
• version 项目的版本。
• packaging 项目的类型，默认是jar，描述了项目打包后的输出。类型为jar的项目产生一个JAR文件，类型为war的项目产生一个web应用。

Maven在版本管理时候可以使用几个特殊的字符串 SNAPSHOT，LATEST，RELEASE。比如"1.0-SNAPSHOT"。各个部分的含义和处理逻辑如下说明：

• SNAPSHOT 这个版本一般用于开发过程中，表示不稳定的版本。
• LATEST 指某个特定构件的最新发布，这个发布可能是一个发布版，也可能是一个snapshot版，具体看哪个时间最后。
• RELEASE 指最后一个发布版。

7、在idea中配置maven

把画红线的东西全部配置成自己的。最后一个是仓库，在你的其他盘找一个地方新建repository文件夹，自己要知道，选中，如果勾选不了就选择都选override。

如果不选择仓库会把jar包下载至C盘的下边目录，不好维护，还占用c盘空间。当然idea和maven可能会有bug。

C:UsersSayHello.m2repository

两处都要配置，一个是当前项目的maven配置，一个是新建项目的maven配置。

三、Maven依赖（重点）

maven管理依赖也就是上述maven的第一个功能，也就是jar包我们不用自己下载，会从一些地方自动下载

• maven远程仓库: https://mvnrepository.com/
• maven远程仓库: https://maven.aliyun.com/mvn/search

maven工程中我们依靠在pom.xml文件进行配置完成jar包管理工作（依赖）

如果我们需要在工程中引入某个jar包，只需要在pom.xml中引入jar包的坐标，而这个坐标就叫做依赖，比如引入log4j的依赖：

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>

Maven 通过 groupId、 artifactId 与 version 三个向量来定位Maven仓库其jar包所在的位置，并把对应的jar包引入到工程中来。

jar包会自动下载，流程如下

1、依赖范围

了解、classpath是个什么东西

顾明思议，就是编译好的class文件所在的路径，编译后会把编译好的class文件和配置文件都放在classpath。

事实上，我们的类加载器（classloader）就是去对应的classpath中加在class二进制文件。

普通的java工程的classpath就是最外层的目录，如out目录。

web项目的classpath是 WEB-INF/classes

maven工程会将src/main/java 和 src/main/resources 文件夹下的文件全部打包在classpath中。运行时他们两个的文件夹下的文件会被放在一个文件夹下。

maven 项目不同的阶段引入到classpath中的依赖是不同的，例如，

• 编译时，maven 会将与编译相关的依赖引入classpath中
• 测试时，maven会将测试相关的的依赖引入到classpath中
• 运行时，maven会将与运行相关的依赖引入classpath中

而依赖范围就是用来控制依赖于这三种classpath的关系。

maven工程的classpath在target/classes文件夹内

什么是依赖范围？就是在依赖里面添加一个scope标签，scope标签就是依赖范围的配置

该项默认配置compile,可选配置还有test、provided、runtime、system、import。

其中compile、test和provided使用较多，下面依次介绍。

有些jar包（如selvlet-api）运行时其实是不需要的，因为tomcat里有，但编译时是需要的，因为编译的时候没有tomcat环境

有些jar只在测试的时候才能用到。比如junit，真是运行不需要的

有些jar运行，测试时必须要有，编译时不需要，如jdbc驱动，编译时用的都是jdk中的接口，运行时我们才使用反射注册了驱动。

向以上的这些jar包不是说使用默认的compile一定不行，但是设置成合适的范围更好，当然有事会有问题，比如你引入的servlet-api和tomcat自带的不一样，就会出问题。

1.1 编译依赖范围（compile）

该范围就是默认依赖范围，此依赖范围对于编译、测试、运行三种classpath都有效，举个简单的例子，假如项目中有fastjson的依赖，那么fastjson不管是在编译，测试，还是运行都会被用到，因此fastjson必须是编译范围（构件默认的是编译范围，所以依赖范围是编译范围的无须显示指定）

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.68</version>
</dependency>

1.2 测试依赖范围(test)

使用此依赖范围的依赖，只对测试classpath有效，在编译主代码和项目运行时，都将无法使用该依赖，最典型的例子就是 Junit, 构件在测试时才需要，所以它的依赖范围是测试，因此它的依赖范围需要显示指定为、、<scope>test</scope>,当然不显示指定依赖范围也不会报错，但是该依赖会被加入到编译和运行的classpath中,造成不必要的浪费 。

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>

1.3 已提供依赖范围(provided)

使用该依赖范围的maven依赖，只对编译和测试的classpath有效，对运行的classpath无效，典型的例子就是servlet-api， 编译和测试该项目的时候需要该依赖，但是在运行时，web容器已经提供的该依赖，所以运行时就不再需要此依赖，如果不显示指定该依赖范围，并且容器依赖的版本和maven依赖的版本不一致的话，可能会引起版本冲突，造成不良影响。

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

1.4 运行时依赖范围(runtime)

使用该依赖范围的maven依赖，只对测试和运行的classpath有效，对编译的classpath无效，典型例子就是JDBC的驱动实现，项目主代码编译的时候只需要JDK提供的JDBC接口，只有在测试和运行的时候才需要实现上述接口的具体JDBC驱动。

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.25</version>
<scope>runtime</scope>
</dependency>

其他的范围不常用，有兴趣自己研究

2、依赖的传递

jar其实也是别人写的工程，他也会依赖其他的jar包，传递性让我们可以不用关系我们所依赖的jar他依赖了哪些jar，只要我们添加了依赖，他会自动将他所依赖的jar统统依赖进来。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1hBYMmiY-1667530055136)(C:UsersSayHelloDesktopimage-20210119142319854.e3076933.png)]

我们只需依赖A.jar，其他的会自动传递进来。

依赖传递的原则：

• 最短路径优先原则：如果A依赖于B，B依赖于C，在B和C 中同时有log4j的依赖，并且这两个版本不一致，那么A会根据最短路径原则，在A中会传递过来B的log4j版本。

• 路径相同先声明原则：如果我们的工程同时依赖于B和A，B和C没有依赖关系，并且都有D的依赖，且版本不一致，那么会引入在pom.xml中先声明依赖的log4j版本。

<dependency>
<groupId>com.xinzi</groupId>
<artifactId>B</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>com.xinzhi</groupId>
<artifactId>A</artifactId>
<version>1.12.2</version>
</dependency>

因为1.2.3先声明，所以获胜。

特别注意：

不同版本的jar选一个会导致一个问题，1.3.2版本高，A.jar可能用到了高版本的一些新的方法，此时因为某些原因系统选择了低版本，就会导致A.jar报错，无法运行。那么就要想办法把低版本排除掉，一般高版本会兼容低版本。

3、依赖的排除

结合上个例子，我们想把低版本的D.jar排除了，就可以这样做，这样系统就只能依赖高版本

<dependencies>
<dependency>
<groupId>com.xinzi</groupId>
<artifactId>B</artifactId>
<version>1.5.3</version>
<exclusions>
<exclusion>
<artifactId>com.xinzhi</artifactId>
<groupId>D</groupId>
</exlcusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.xinzhi</groupId>
<artifactId>A</artifactId>
<version>1.12.2</version>
</dependency>
</dependencies>

4、聚合和继承

分布式开发必须要用

聚合模块（父模块）的打包方式必须为pom，否则无法完成构建。

在聚合多个项目时，如果这些被聚合的项目中需要引入相同的Jar，那么可以将这些Jar写入父pom中，各个子项目继承该pom即可。，父模块的打包方式必须为pom，否则无法构建项目。

通过在各个子模块中配置来表明其继承与哪一个父模块：

<parent>
<artifactId>parent</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>childern-two</artifactId>

可以被继承的POM元素如下：

• groupId：项目组ID，项目坐标的核心元素

• version：项目版本，项目坐标的核心因素

• properties：自定义的Maven属性 一般用于同一制定各个依赖的版本号

• dependencies：项目的依赖配置 公共的依赖

• dependencyManagement：项目的依赖管理配置

• repositories：项目的仓库配置

• build：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等

一些对项目的描述

• description：项目的描述信息
• organization：项目的组织信息
• inceptionYear：项目的创始年份
• url：项目的URL地址
• developers：项目的开发者信息
• contributors：项目的贡献者信息
• distributionManagement：项目的部署配置
• issueManagement：项目的缺陷跟踪系统信息
• ciManagement：项目的持续集成系统信息
• scm：项目的版本控制系统
• malilingLists：项目的邮件列表信息
• reporting：包括项目的报告输出目录配置、报告插件配置等

四、POM文件

1、基础配置

一个典型的pom.xml文件配置如下：

<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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- 模型版本。必须是这样写，现在是maven唯一支持的版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成， 如com.xinzhi，maven会将该项目打成的jar包放本地路径：/com/xinzhi/ -->
<groupId>com.xinzhi</groupId>
<!-- 本项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
<artifactId>test</artifactId>
<!-- 本项目目前所处的版本号 -->
<version>1.0.0-SNAPSHOT</version>
<!-- 打包的机制，如pom,jar,
war，默认为jar -->
<packaging>jar</packaging>
<!-- 为pom定义一些常量，在pom中的其它地方可以直接引用 使用方式 如下 ：${file.encoding} -->
<!-- 常常用来整体控制一些依赖的版本号 -->
<properties>
<file.encoding>UTF-8</file.encoding>
<java.source.version>1.8</java.source.version>
<java.target.version>1.8</java.target.version>
</properties>
<!-- 定义本项目的依赖关系，就是依赖的jar包 -->
<dependencies>
<!-- 每个dependency都对应这一个jar包 -->
<dependency>
<!--一般情况下，maven是通过groupId、artifactId、version这三个元素值（俗称坐标）来检索该构件， 然后引入你的工程。如果别人想引用你现在开发的这个项目（前提是已开发完毕并发布到了远程仓库），-->
<!--就需要在他的pom文件中新建一个dependency节点，将本项目的groupId、artifactId、version写入， maven就会把你上传的jar包下载到他的本地 -->
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<!-- 依赖范围 -->
<scope>complie</scope>
<!-- 设置
依赖是否可选，默认为false,即子项目默认都继承。如果为true,
则子项目必需显示的引入
-->
<optional>false</optional>
<!-- 依赖排除-->
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
...
</project>

一般来说，上面的几个配置项对任何项目都是必不可少的，定义了项目的基本属性。

除了dependencies我们还用到了dependencyManagement，区别如下

dependencies

• 即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）。
• 继承下来就会被编译，如果子项目根本不用这个依赖会增加子工程的负担。

dependencyManagement：通常会在父工程中定义，目的是统一各个子模块的依赖版本，有不用实际依赖

• 只是声明依赖，并不实现引入
• 子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；
• 只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

2、构建配置

<build>
<!-- 产生的构件的文件名，默认值是${artifactId}-${version}。 -->
<finalNasourceDirectory>${basedir}srcmainjava</sourceDirectory>
<!--项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
<>${basedir}targetclasses</outputDirectory>
<!--被编译过的测试class文件存放的目录。 -->
<testOutputDirectory>${basedir}targettest-classes
</testOutputDirectory>
<!-- 以上配置都有默认值，就是约定好了目录就这么建 -->
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
<!--单元测试相关的所有资源路径，配制方法与resources类似 -->
<testResources>
<testResource>
<targetPath />
<filtering />
<directory />
<includes />
<excludes />
</testResource>
</testResources>
<!--使用的插件列表 。 -->
<plugins>
<plugin>
...具体在插件使用中了解
</plugin>
</plugins>
<!--主要定义插件的共同元素、扩展元素集合，类似于dependencyManagement， -->
<!--所有继承于此项目的子项目都能使用。该插件配置项直到被引用时才会被解析或绑定到生命周期。 -->
<!--给定插件的任何本地配置都会覆盖这里的配置 -->
<pluginManagement>
<plugins>...</plugins>
</pluginManagement>
</build>

我们常用的几个配置

关于资源处理的配置

有些小伙伴就喜欢在src中填写配置文件

<!-- 处理资源被过滤问题 -->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>

添加本地jar包

本地jar，如：支付宝jar包放到 src/main/webapp/WEB-INF/lib 文件夹下，如果没有配置，本地没问题，但是线上会找不到sdk类，为什么要引入，因为支付宝jar包再中央仓库没有

<!-- geelynote maven的核心插件之-complier插件默认只支持编译Java 1.4，因此需要加上支持高版本jre的配置，在pom.xml里面加上 增加编译插 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
<compilerArguments>
<!-- 本地jar，支付宝jar包放到
src/main/webapp/WEB-INF/lib 文件夹下，
如果没有配置，本地没问题，但是线上会找不到sdk类
为什么要引入，因为支付宝jar包再中央仓库没有，再比如oracle连接驱动的jar
-->
<extdirs>${project.basedir}/src/main/webapp/WEB-INF/lib</extdirs>
</compilerArguments>
</configuration>
</plugin>

3、仓库配置

<repositories>
<repository>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>

pom.xml里面的仓库与setting.xml里的仓库功能是一样的。主要的区别在于，pom里的仓库是个性化的。比如一家大公司里的setting文件是公用的，所有项目都用一个setting文件，但各个子项目却会引用不同的第三方库，所以就需要在pom.xml里设置自己需要的仓库地址。

5、多环境配置

<profiles>
<profile>
<id>dev</id>
<build>
<finalName>dev</finalName>
</build>
<repositories>
<repository>
<id>ali</id>
<name>ali repo</name>
<url>https://maven.aliyun.com/repository/central</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
</profile>
<profile>
<id>test</id>
<build>
<finalName>test</finalName>
</build>
<repositories>
<repository>
<id>ali</id>
<name>ali repo</name>
<url>https://mirrors.huaweicloud.com/repository/maven/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
</profile>
<profile>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<id>pro</id>
<build>
<finalName>pro</finalName>
</build>
</profile>
</profiles>

5、项目信息配置（知道）

<!--项目的名称, Maven产生的文档用 -->
<name>banseon-maven </name>
<!--项目主页的URL, Maven产生的文档用 -->
<url>http://www.clf.com/ </url>
<!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时 -->
<!--（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签），不鼓励使用纯文本描述。 -->
<!-- 如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->
<description>A maven project to study maven. </description>
<!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
<inceptionYear />
<!--项目开发者列表 -->
<developers>
<!--某个项目开发者的信息 -->
<developer>
<!--SCM里项目开发者的唯一标识符 -->
<id> HELLO WORLD </id>
<!--项目开发者的全名 -->
<name> banseon </name>
<!--项目开发者的email -->
<email> banseon@126.com</email>
<!--项目开发者的主页的URL -->
<url />
<!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
<roles>
<role> Project Manager</role>
<role>Architect </role>
</roles>
<!--项目开发者所属组织 -->
<organization> demo</organization>
<!--项目开发者所属组织的URL -->
<organizationUrl>http://hi.clf.com/ </organizationUrl>
<!--项目开发者属性，如即时消息如何处理等 -->
<properties>
<dept> No </dept>
</properties>
<!--项目开发者所在时区， -11到12范围内的整数。 -->
<timezone> -5</timezone>
</developer>
</developers>
<!--项目的其他贡献者列表 -->
<contributors>
<!--项目的其他贡献者。参见developers/developer元素 -->
<contributor>
<name />
<email />
<url />
<organization />
<organizationUrl />
<roles />
<timezone />
<properties />
</contributor>
</contributors>
<!--该元素描述了项目所有License列表。应该只列出该项目的license列表，不要列出依赖项目的license列表。 -->
<!--如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->
<licenses>
<!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->
<license>
<!--license用于法律上的名称 -->
<name> Apache 2 </name>
<!--官方的license正文页面的URL -->
<url>http://www.clf.com/LICENSE-2.0.txt </url>
<!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->
<distribution> repo</distribution>
<!--关于license的补充信息 -->
<comments> Abusiness-friendly OSS license </comments>
</license>
</licenses>
...还有很多

还有一些可以了解的不常用的配置如报表配置、问题管理配置、项目集成配置、profile配置有兴趣的自行学习一下

五、Maven仓库

任何的构件都有唯一的坐标，Maven根据这个坐标定义了构件在仓库中的唯一存储路径，

Maven仓库分为2类：

• 本地仓库
• 远程仓库，远程仓库又分成3种：
  • 中央仓库
  • 私服
  • 其它公共库

maven项目使用的仓库一共有如下几种方式：

1. 中央仓库，这是默认的仓库
2. 镜像仓库，通过 settings.xml 中的 settings.mirrors.mirror 配置
3. 全局profile仓库，通过 settings.xml 中的 settings.repositories.repository 配置
4. 项目仓库，通过 pom.xml 中的 project.repositories.repository 配置
5. 项目profile仓库，通过 pom.xml 中的 project.profiles.profile.repositories.repository 配置
6. 本地仓库

搜索顺序如下：

本地仓库 > settings.xml的profile内的repository > pom文件内的profile内的repository > pom文件内的repositorys > settings.xml的镜像 > 中央仓库

1、本地仓库

本地仓库是Maven在本地存储构建的地方。Maven的本地仓库，在安装maven后并不会创建，它是在第一次执行Maven命令的时候才被创建。

Maven本地仓库的默认位置：无论是Windows还是Linux，在用户的目录下都有一个**.m2/repository/的仓库目录，这就是Maven仓库的默认位置。**

在Maven的目录下的conf目录下，有一个settings.xml文件，是Maven的配置文件，在里面可以修改本地仓库的位置。

修改本地仓库位置：

<!-- 本地仓库的路径。默认值为 -->
<localRepository>D:/repository</localRepository>

2、远程仓库

远程仓库主要用于获取其它人的Maven构件，其中最主要的就是中央仓库。关于如何在Maven中配置远程仓库，可以查看POM文件章节。

2.1 中央仓库

中央仓库是默认的的远程仓库，Maven在安装的时候，自带的就是中央仓库的配置。

所有的Maven都会继承超级POM，超级POM种包含如下配置：

<repositories>
<repository>
<id>central</id>
<name>Cntral Repository</name>
<url>http://repo.maven.apache.org</url>
<layout>default</layout>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>

中央仓库包含了绝大多数流行的开源Java构件，以及源码、作者信息、SCM、信息、许可证信息等。

还可以在里面配置优先使用的镜像，比如在国内直接连中央仓库速度较慢，一般使用阿里的镜像仓库。

<!--镜像6列表-->
<mirrors>
<!--镜像-->
<mirror>
<id>alimaven</id>
<!--被镜像的服务器ID-->
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</mirror>
</mirrors>

2.2 私服

私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的Maven用户使用。当Maven需要下载构件的时候，它从私服请求，如果私服上不存在该构件，则从外部的远程仓库下载，缓存在私服上之后，在为Maven的下载请求提供服务。

Maven私服的优点：

1. 加速构建；
2. 节省带宽；
3. 节省中央maven仓库的带宽；
4. 稳定（应付一旦中央服务器出问题的情况）；
5. 可以建立本地内部仓库；
6. 可以建立公共仓库。

maven 在默认情况下是从中央仓库下载构建，也就是 id 为 central 的仓库。如果没有特殊需求，一般只需要将私服地址配置为镜像，同时配置其代理所有的仓库就可以实现通过私服下载依赖的功能。镜像配置如下：

<mirror>
<id>Nexus Mirror</id>
<name>Nexus Mirror</name>
<url>http://localhost:8081/nexus/content/groups/public/</url>
<mirrorOf>*</mirrorOf>
</mirror>

实战：centOs使用Docker创建Nexus私服

启动Docker，输入命令：

// 安装docker
yum install docker -y
// 启动
systemctl start docker
// 修改镜像路径 自己登陆阿里云-》 容器镜像服务 -》 镜像加速器 -》 centos 就可以了
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://jf8zmt.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
docker run -d -p 8081:8081 --name nexus3 sonatype/nexus3
// 查看运行状态
docker container ls
// 开放端口
firewall-cmd --zone=public --add-port=8081/tcp --permanent
// 获取密码
docker exec -it nexus3 /bin/bash
cd nexus-data/
cat admin.password

运行完毕，在浏览器访问http://192.168.101.129:8081，当前虚拟机的地址加端口进入Nexus页面：

一般来说，Nexus 的仓库分为这么几类：

• hosted 宿主仓库：主要用于部署无法从公共仓库获取的构件（如 oracle 的 JDBC 驱动）以及自己或第三方的项目构件；
• proxy 代理仓库：代理公共的远程仓库；
• group 仓库组：Nexus 通过仓库组的概念统一管理多个仓库，这样我们在项目中直接请求仓库组即可请求到仓库组管理的多个仓库。

以下为了解，对私服进行权限认证（了解）

大部分公共的远程仓库无须认证就可以直接访问，但我们在平时的开发中往往会架设自己的Maven远程仓库，出于安全方面的考虑，我们需要提供认证信息才能访问这样的远程仓库。

配置认证信息和配置远程仓库不同，远程仓库可以直接在pom.xml中配置，但是认证信息必须配置在settings.xml文件中。

这是因为pom往往是被提交到代码仓库中供所有成员访问的，而settings.xml一般只存在于本机。因此，在settings.xml中配置认证信息更为安全。

<server>
<id>releases</id>
<username>admin</username>
<password>admin</password>
</server>
<server>
<id>snapshots</id>
<username>admin</username>
<password>admin</password>
</server>

pom文件

<repositories>
<repository>
<!--仓库 id，repositories 可以配置多个仓库，保证 id 不重复-->
<id>nexus</id>
<!--仓库地址，即 nexus 仓库组的地址-->
<url>http://192.168.120.201:8081/repository/maven-central/</url>
<!--是否下载 releases 构件-->
<releases>
<enabled>true</enabled>
</releases>
<!--是否下载 snapshots 构件-->
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<!-- 插件仓库，maven 的运行依赖插件，也需要从私服下载插件 -->
<pluginRepository>
<!-- 插件仓库的 id 不允许重复，如果重复后边配置会覆盖前边 -->
<id>public</id>
<name>Public Repositories</name>
<url>http://192.168.120.201:8081/repository/maven-public/</url>
</pluginRepository>
</pluginRepositories>
<distributionManagement>
<repository>
<id>releases</id>
<url>http://192.168.120.201:8081/repository/maven-releases/</url>
</repository>
<snapshotRepository>
<id>snapshots</id>
<url>http://192.168.120.201:8081/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>

激活一个环境的方式

mvn clean package -Ptest

六、Maven插件

1、Maven 插件介绍

Maven 实际上是一个依赖插件执行的框架，每个任务实际上是由插件完成。Maven 插件通常被用来：

• 打包jar 文件
• 创建 war 文件
• 编译代码文件
• 代码单元测试
• 创建工程文档
• 创建工程报告

插件通常提供了一个目标的集合，并且可以使用下面的语法执行：

mvn [plugin-name]:[goal-name]

例如，一个 Java 工程可以使用 maven-compiler-plugin 的 compile-goal 编译，使用以下命令：

mvn compiler:compile

2、maven-compiler-plugin（重要）

设置maven编译的jdk版本，maven3默认用jdk1.5，maven2默认用jdk1.3

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source> <!-- 源代码使用的JDK版本 -->
<target>1.8</target> <!-- 需要生成的目标class文件的编译版本 -->
<encoding>UTF-8</encoding><!-- 字符集编码 -->
</configuration>
</plugin>

3、tomcat插件

添加插件在build中

<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8080</port>
<uriEncoding>UTF-8</uriEncoding>
<path>/xinzhi</path>
<finalName>xinzhi</finalName>
</configuration>
</plugin>

点击idea右侧的maven我们可以方便的看到我们使用了什么插件，并可以点击执行相应的命令

通过插件和命令我们都可以启动项目了，都不用部署到tomcat里了。

4、war包打插件

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<configuration>
<warName>test</warName>
<webResources>
<resource>
<directory>src/main/webapp/WEB-INF</directory>
<filtering>true</filtering>
<targetPath>WEB-INF</targetPath>
<includes>
<include>web.xml</include>
</includes>
</resource>
</webResources>
</configuration>
</plugin>

执行命令 mvn clean package

5、jar包的插件

• maven-jar-plugin，默认的打包插件，用来打普通的project JAR包；
• maven-shade-plugin，用来打可执行JAR包，也就是所谓的fat JAR包；
• maven-assembly-plugin，支持自定义的打包结构，也可以定制依赖项等。

我们日常使用的以maven-assembly-plugin为最多，因为大数据项目中往往有很多shell脚本、SQL脚本、.properties及.xml配置项等，采用assembly插件可以让输出的结构清晰而标准化。

自己网上查资料深入学习

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<id>make-assembly</id>
<!-- 绑定到package生命周期 -->
<phase>package</phase>
<goals>
<!-- 只运行一次 -->
<goal>single</goal>
</goals>
</execution>
</executions>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>com.xinzi.Test</mainClass> <!-- 你的主类名 -->
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>

查件太多了，基本上所有的功能都是通过查件附加的！

七、Maven项目模板（没啥用，了解）

Archetype 是一个 Maven 插件，其任务是按照其模板来创建一个项目结构。

执行如下命令即可创建Maven项目模板。

mvn archetype:generate

常用的archetype有以下2种：

maven-archetype-quickstart默认的Archetype

• 基本内容包括：
• 一个包含junit依赖声明的pom.xml
• src/main/java主代码目录及一个名为App的类
• src/test/java测试代码目录及一个名为AppTest的测试用例

mvn archetype:generate -DgroupId=com.xinzhi -DartifactId=test -DarchetypeArtifactId=maven-archetype-webapp

maven-archetype-webapp

一个最简单的Maven war项目模板，当需要快速创建一个Web应用的时候可以使用它。生成的项目内容包括：

• 一个packaging为war且带有junit依赖声明的pom.xml
• src/main/webapp/目录
• src/main/webapp/index.jsp文件
• src/main/webapp/WEB-INF/web.xml文件

其实这个模板并不全。

最后

以上就是苹果煎蛋为你收集整理的Maven总结Maven总结一、什么是Maven，Maven的作用是什么二、概述三、Maven依赖（重点）四、POM文件五、Maven仓库六、Maven插件七、Maven项目模板（没啥用，了解）的全部内容，希望文章能够帮你解决Maven总结Maven总结一、什么是Maven，Maven的作用是什么二、概述三、Maven依赖（重点）四、POM文件五、Maven仓库六、Maven插件七、Maven项目模板（没啥用，了解）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。