Maven一览

构建与依赖

构建过程

构造过程包含的主要环节：

• 清理：删除上一次构建的结果，为下一次构建做好准备
• 编译：Java源程序编译成*.class字节码文件
• 测试：运行提前准备的测试程序
• 报告：针对刚才的测试结果生成一个全面的信息
• 打包：
  • Java工程：jar包
  • Web工程：war包
• 安装：把一个Maven工程经过打包操作生成的jar包或war包安装到Maven仓库
• 部署：将准备好的jar包或war包部署到服务器上运行
  • 部署jar包：将一个jar包部署到Nexus私服服务器上
  • 部署war包：借助相关Maven插件(如cargo)，将war包部署到Tomcat服务器上

依赖管理

依赖管理中要解决的具体问题：

• jar包的下载：使用Maven之后，jar包会从规范的远程仓库下载到本地
• jar包之间的依赖：通过依赖的传递性自动完成
• jar包之间的冲突：通过对依赖的配置进行调整，让某些jar包不会被导入

Maven的工作机制

image

Maven安装与配置

1. 下载与安装，如手动安装最好安装到非中文无空格的目录中

官网下载或Idea中自带

2. 配置，对应的是conf/settings.xml

   1. 配置本地仓库存放位置，目录如果不存在则会由maven执行命令时自动创建

      <localRepository>D:\JavaLib\.m2\repository</localRepository>

   2. 配置镜像仓库，配置使用阿里的镜像仓库，因为中央仓库在国外，访问速度太慢

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

   3. 配置Maven工程的基础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. 配置环境变量
   1. 配置MAVEN_HOME：指向bin目录的上一级
   2. 配置PATH：指向bin目录

创建Maven工程

Maven中的坐标

Maven使用三个向量在Maven仓库中唯一定位到一个jar包

• groupId：公司或组织的Id
• artifactId：一个项目或项目中的一个模板id
• version：版本号

三个向量的取值方式：

• groupId：公司或组织域名的倒序，通常也会加上项目名称
  • 如：com.zephon.maven
• artifactId：模块的名称，将来作为Maven工程的工程名
• version：模块的版本号，根据自己的需要设定
  • 例如：SNAPSHOT表示快照版本，正在迭代过程中，不稳定的版本
  • 例如：RELEASE表示正式版本

例：

<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>

则其对应的位置就是：Maven本地仓库根目录.servlet-api\3.1.0.servlet-api-3.1.0.jar

创建本地工作空间

1. 创建本地工作空间(文件夹)
2. 在本地工作空间目录下打开命令行
3. 使用命令生成Maven工程：mvn archetype:generate

• mvn：主命令
• archetype:generate：子命令
  • archetype：插件
  • generate：目标

然后根据提示选择或输入对应的内容即可

4. 根据需要对Maven默认生成的工程中一些依赖版本进行调整 ## pom.xml解读

pom的含义：POM：Project Object Model，项目对象模型。和POM类似的是：DOM(Document Object Model)，文档对象模型。它们都是模型化思想的具体体现。POM理念集中体现在Maven工程根目录下pom.xml这个配置文件中。

• ：根标签，表示对当前工程进行配置、管理
• ：从Maven2开始固定是4.0.0，代表当前pom.xml所采用的标签结构
• ：坐标信息，表示公司或组织
• ：坐标信息，表示项目下某个模块
• ：坐标信息，表示当前模块版本
• ：打包方式
  • jar：生成jar包，说明是一个Java工程
  • war：生成war包，说明是一个Web工程
  • pom：说明这个工程是用来管理其它工程的工程
  • maven-plugin：说明是Maven插件
• ：当前工程名
• 任意地址
• ：在Maven中定义属性值
  • <project.build.sourceEncoding>：在构建过程中读取源码时使用的字符集
• ：配置具体依赖信息，可以包含多个dependency子标签
  • ：配置一个具体的依赖信息
    • ：坐标信息，表示公司或组织
    • ：坐标信息，表示项目下某个模块
    • ：坐标信息，表示当前模块版本
    • ：配置当前依赖的范围

Maven约定的目录结构

• pro-maven
  • src：源码目录
    • main：主体程序目录
      • java：Java源代码
        • com：包目录
      • resources：配置文件
    • test：测试程序目录
      • java：Java源代码
        • com：包目录
  • target：编译结果目录
  • pom.xml

目前开发领域的技术发展趋势就是：约定大于配置，配置大于编码

执行Maven的构建

1. 要求

运行Maven的构建相关命令时，必须进入到pom.xml所在目录，如果没有pom.xml所有的目录运行就会报错

2. 清理：mvn clean：删除target目录
3. 编译：
   1. mvn compile：主程序编译，结果存放在target/classes
   2. mvn test-compile：测试程序编译，结果存放在target/test-classes
4. 测试：mvn test：测试，测试报告存放在target/surefire-reports
5. 打包：mvn package：打包，存放在target
6. 安装 ：mvn install：将打包结果安装到本地Maven仓库

使用Maven创建Web工程

1. 通过命令创建：mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.4
2. 手动在main目录下创建java目录、resource目录等
3. 配置依赖，如servlet-api.jar，此处推荐网站，然后选择指定版本对应的dependency复制到pom.xml中

自定义工程依赖

让之前定义的web工程依赖Java工程，最终Java工程会变成jar包放在Web工程的WEB-INF/lib目录下

1. 在Java工程中执行打包、安装命令

2. 在web工程的pom.xml中添加Java工程对应的dependency如：

   <dependency>
     <groupId>com.zephon.maven</groupId>
     <artifactId>pro-java</artifactId>
     <version>1.0-SNAPSHOT</version>
   </dependency>

3. 查看web工程所依赖的jar包列表

   • mvn dependency:list -->列表形式查看
   • mvn dependency:tree --> 树形结构查看

依赖的范围、传递与排除

pom.xml中各个dependency有一个子标签是 可选值：compile/test/provided/system/runtime/import

• import：Maven是单继承的，如果不同体系的依赖信息封装在不同POM中了，没办法继承多个父工程但又需要时，就可以使用import
  • 使用要求：打包类型必须是pom
  • 必须放在dependencyManagement中
• system：引入本地系统但又不在仓库中的jar包，需要用指定路径，通常不建议使用
• runtime：专门用于编译时不需要、但运行时需要的jar包，比如：编译时我们根据接口调用方法，但实际运行时需要的是接口的实现类。

compile和test对比

main目录(空间)	test目录(空间)	开发过程(时间)	部署到服务器(时间)
compile	有效	有效	有效
test	无效	有效	有效

compile和provided对比

main目录	test目录	开发过程	部署到服务器
compile	有效	有效	有效
provided	有效	有效	有效

小结

compile：通常使用的第三方框架的jar包这样在项目实际运行时真正用到的jar包都是以compile范围进行依赖的，比如SSM框架 test：测试过程中使用的jar包，以test范围依赖，如Junit provided：在开发过程中需要用到的"服务器上的jar包"通常以provided范围依赖。如Servlet-api、jsp-api等。而这个范围的jar包之所以不参与部署、不放进war包，不是避免和服务器上已有的同类jar包产生冲突，同时减轻服务器的负担。

可选依赖

• ：取值为true/false
  • 如果为true则表示该依赖可有可无

依赖的传递性

A依赖B，B依赖C，则在A没有配置对C的依赖的情况下，A里面能否直接用C就取决于B依赖C时使用的依赖范围

• B依赖C时使用compile范围：可以传递
• B依赖C时使用test或provided范围：不能传递，所以需要这样的jar包时，就必须在需要的地方明确配置依赖才可以

依赖的排除

由于依赖的传递性，可能在依赖的过程中会存在jar包的冲突问题，这时就需要通过依赖的排除来阻断依赖的传递。 配置方式：

<dependency>
  <groupId>com.zephon.maven</groupId>
  <artifactId>pro-maven-java</artifactId>
  <version>1.0-SNAPSHOT</version>
  <scope>compile</scope>
  <exclusions>
    <exclusion>
      <!- 指定排除的依赖的坐标，不需要写version -->
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
    </exclusion>
  </exclusions>
</dependency>

依赖的继承

Maven工程之间，A工程继承B工程，本质上是A工程的pom.xml中的配置继承了B工程中的pom.xml配置 作用：在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本 背景：

• 对于一个大型项目进行模块拆分
• 一个project下面，创建多个module
• 每个module都需要配置自己的依赖信息

需求：

• 每个module中各自维护各自的依赖信息容易发生出入，不易统一管理
• 使用同一框架内的不同jar包，应该是同一个版本，所以整个项目中使用的框架版本需要统一
• 使用框架时所需要的jar包组合(或依赖信息组合)需要经过长期摸索和反复调试，最终确定一个可用组合

基于这些，通过在父工程中为整个项目维护依赖信息的组合，既保证了整个项目使用规范、准确的jar包，又能将以往的经验沉淀下来，节约时间和精力

操作

以Spring为例，使用Spring时要求所有Spring自己的jar包版本必须一致，为了能够对这些jar包版本进行统一管理，就要使用继承这个机制，将所有版本信息统一在父工程中进行很管理

1. 创建父工程，然后对父工程修改它的打包方式为pom，只有打包方式为pom的Maven工程才能管理其它Maven工程，打包方式为pom的Maven工程不写业务代码，专门管理其它Maven的工程

   <groupId>com.zephon.maven</groupId>
   <artifactId>pro-parent</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>pom</packaging>

2. 创建模块工程；进入parent工程的根目录，然后创建模块工程，例如pro1,pro2

3. 查看parent工程的pom.xml，可以发现有新的变化，即加入了modules标签

   <modules>
     <module>pro1</module>
     <module>pro2</module>
   </modules>

4. 查看子工程的pom.xml，也可以发现已经配置好了父工程信息，此时，如果子工程的groupId、version和父工程一样则可以省略

   <parent>
     <groupId>com.zephon.maven</groupId>
     <artifactId>pro-parent</artifactId>
     <version>1.0-SNAPSHOT</version>
   </parent>

5. 在父工程中统一管理依赖信息，进入parent的pom.xml，添加相关

即使在父工程中配置了对依赖的管理，子工程中需要使用具体哪个依赖时还是需要明确配置 此时，对于已经在父工程中配置的依赖，子工程中配置的依赖引用时可以不写

• 如果不写，则默认使用父工程中配置的
• 如果写了，则使用子工程配置的

绝大部分情况下子工程还是遵从父工程统一管理的依赖

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.0.0.RELEASE</version>
    </dependency>
  </dependencies>
</dependencyManagement>

配置自定义属性优化

1. 在中定义属性
2. 修改dependency中的version，通过${}引用之前定义的属性值

   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
     <spring.version>4.0.0.RELEASE</spring.version>
   </properties>
   
   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-core</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-context</artifactId>
         <version>${spring.version}</version>
       </dependency>
       <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>${spring.version}</version>
       </dependency>
     </dependencies>
   </dependencyManagement>

模块聚合

好处：

• 一键执行Maven命令：很多构建命令都可以在“总工程”中一键执行
  • 以mvn install为例：Maven要求有父工程时先安装父工程；有依赖工程时，先安装被依赖的工程。自己考虑这些很麻烦，但工程聚合之后，在总工程上执行mvn install可以一键完成安装，而且会自动按照正确顺序执行
• 配置聚合之后，各个模块工程在总工程中展示一个列表，让项目的各个模块一目了然

配置：

<modules>
  <module>pro1</module>
  <module>pro2</module>
  <module>pro3</module>
</modules>

# IDEA中使用Maven IDEA版本：IntelliJ IDEA 2022.1.4 (Ultimate Edition) ## 1. 创建父工程

1. File->New->Project
2. 选择New Project，输入对应的信息，Create

image.png

2. 创建Web子工程

1. 右键parent->New->Module
2. 输入对应的信息，选择Archetype为：org.apache.maven.archetypes:maven-archetype-webapp，点击create

image.png

3. 或者和父工程一样创建，然后点击File->Project Structure
   1. 选择Facets，点击+号，选择Web，选择对应的模块
   2. 然后点击右侧+号添加web.xml文件即可

image.png

3. Maven图形界面操作

1. 点击右侧Maven工具
2. 选择对应模块展开，点击Lifestyle或Plugins，选择要执行的操作

image.png

3. 对于一些组合的命令，可以点击图中对应的m输入执行，并且需要注意执行范围

image.png

4. 导入外来模块

1. 将对应的文件夹复制到项目中
2. 点击File->Project Structure->Modules
3. 点击+号，Import Module，选择对应的文件夹
4. 如果是Web模块，则还需要到Project Structure的Facets中确认配置web.xml

Maven中的生命周期、插件和目标

三个生命周期

生命周期的作用：为了让构建过程自动化完成，Maven设定了三个生命周期，生命周期中每个环节对应构建过程中的一个操作 每个生命周期内的操作，执行了后面的操作，则前面的会自动执行，而不同生命周期的操作则不是这样，例如，需要clean和install就必须：mvn clean install，而如果是test和install则只用mvn install

生命周期名称	作用	各个环节
Clean	清理操作相关	pre-clean clean post-clean
Site	生成站点相关	pre-site site post-site deploy-site
Default	主要构建过程	validate generate-sources process-sources generate-resources process-resources：复制并处理资源文件至目标目录，准备打包 compile：编译项目main目录下的源代码 process-classes generate-test-sources process-test-sources generate-test-resources process-test-resources：复制并处理资源文件至目标测试目录 test-compile：编译测试源代码 process-test-classes test：使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署 prepare-package package：接受编译好的代码，打包成可发布的格式，如Jar pre-integration-test integration-test post-integration-test verify install：将包安装到本地仓库，以让其它项目依赖 deploy：将最终的包复制到远程仓库，以让其它开发人员共享或部署到服务器上运行(需借助插件)

插件和目标

Maven的核心程序仅仅负责宏观调度，不做具体工作，具体工作都是由Maven插件完成的，例如：编译就是由maven-compile-plugin-3.1.jar插件来的执行的 一个插件可以对应多个目标，而每个目标都和生命周期中的某个环节对应。 例如：Default生命周期中有Compile和test-compile两个和编译相关的环节，对应compile和test-compile两个目标，而这两个目标都是由maven-compile-plugin-3.1.jar插件来执行

Pom的四个层次

• 超级POM：

Maven在构建过程中有很多默认设定，这些要素都是被Maven定义过的，定义的位置就是超级POM，所以我们自己定义的POM即使没有明确的指定父工程，其实也继承了超级POM(Super POM)。 超级POM中的定义：

<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>

• 父POM：自定义的父级POM，Maven和Java类一样，也是单继承的
• 当前POM：当前pom.xml中配置的POM
• 有效POM：隐含的一层，但是实际上生效的一层，继承关系中所有POM叠加到一起最终生成有效POM
  • 查看有效POM：mvn help:effective-po # 属性的声明与引用

1. help插件

目标	说明
help:active-profiles	列出当前已激活的profile
help:all-profiles	列出当前工程所有可用profile
help:describe	描述一个插件和/或Mojo的属性
help:effective-pom	以XML格式展示有效的POM
help:effective-settings	为当前工程以XML格式展示计算得到的settings配置
help:evaluate	计算用户在交互模式下给出的Maven表达式
help:system	显示平台详细信息列表，如系统属性和环境变量

2. 使用help:evaluate查看属性值

1. 定义属性

   <properties>
     <spring.version>4.0.0.RELEASE</spring.version>
   </properties>

2. 运行命令：mvn help:evaluate

3. 运行结果： > [INFO] --- maven-help-plugin:3.2.0:evaluate (default-cli) @ parent --- > [INFO] No artifact parameter specified, using 'com.zephon:parent:pom:1.0-SNAPSHOT' as project. > [INFO] Enter the Maven expression i.e. ${project.groupId} or 0 to exit?: > ${spring.version} > [INFO] > 4.0.0.RELEASE

3. 通过Maven访问系统属性

如${sun.cpu.isalist}，则输出amd64，其它的还有如(可在Java中通过System.getProperties()获取)：

java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=D:\Program\Scoop\apps\oraclejdk8\current\jre\bin
java.vm.version=25.201-b09
java.vm.vendor=Oracle Corporation
java.vendor.url=http://java.oracle.com/
path.separator=;
java.vm.name=Java HotSpot(TM) 64-Bit Server VM
file.encoding.pkg=sun.io
user.country=CN
user.script=
sun.java.launcher=SUN_STANDARD
sun.os.patch.level=
java.vm.specification.name=Java Virtual Machine Specification
user.dir=D:\Code\JavaCode\parent
java.runtime.version=1.8.0_201-b09
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\endorsed
os.arch=amd64
java.io.tmpdir=C:\Users\Zephon\AppData\Local\Temp\
line.separator=

java.vm.specification.vendor=Oracle Corporation
user.variant=
os.name=Windows 10
sun.jnu.encoding=GBK
java.library.path=D:\Program\Scoop\apps\oraclejdk8\current\bin;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\WINDOWS\System32\OpenSSH\;D:\Program\Scoop\apps\vscode\current\bin;D:\Program\Scoop\apps\oraclejdk8\current\bin;D:\Program\Scoop\shims;C:\Users\Zephon\AppData\Local\Microsoft\WindowsApps;C:\Program Files\Bandizip\;D:\Program\Scoop\apps\nuwen-mingw-without-git\17.1\bin;C:\Users\Zephon\AppData\Local\Microsoft\WindowsApps;.
java.specification.name=Java Platform API Specification
java.class.version=52.0
sun.management.compiler=HotSpot 64-Bit Tiered Compilers
os.version=10.0
user.home=C:\Users\Zephon
user.timezone=
java.awt.printerjob=sun.awt.windows.WPrinterJob
file.encoding=UTF-8
java.specification.version=1.8
java.class.path=D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\charsets.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\deploy.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\access-bridge-64.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\cldrdata.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\dnsns.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\jaccess.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\jfxrt.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\localedata.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\nashorn.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\sunec.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\sunjce_provider.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\sunmscapi.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\sunpkcs11.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext\zipfs.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\javaws.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jce.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jfr.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jfxswt.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jsse.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\management-agent.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\plugin.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\resources.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\rt.jar;D:\Code\JavaCode\parent\target\classes;D:\Program\Scoop\apps\IntelliJ-IDEA-Ultimate\current\IDE\lib\idea_rt.jar
user.name=Zephon
java.vm.specification.version=1.8
sun.java.command=com.zephon.Test
java.home=D:\Program\Scoop\apps\oraclejdk8\current\jre
sun.arch.data.model=64
user.language=zh
java.specification.vendor=Oracle Corporation
awt.toolkit=sun.awt.windows.WToolkit
java.vm.info=mixed mode
java.version=1.8.0_201
java.ext.dirs=D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
sun.boot.class.path=D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\resources.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\rt.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\sunrsasign.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jsse.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jce.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\charsets.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\lib\jfr.jar;D:\Program\Scoop\apps\oraclejdk8\current\jre\classes
java.vendor=Oracle Corporation
file.separator=\
java.vendor.url.bug=http://bugreport.sun.com/bugreport/
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.endian=little
sun.desktop=windows
sun.cpu.isalist=amd64

4. 访问系统环境变量

通过\({env.系统环境变量}查看，如\){env.JAVA_HOME}

5. 访问project属性

1. 使用表达式${project.xxx}可访问当前POM中的元素值
2. 访问一级标签：\({project.xxx}，如\){project.artifactId}
3. 访问子标签：\({project.xxx.yyy}，如\){project.parent.artifactId}
4. 访问列表标签：\({project.标签名[下标]}，如\){project.build.plugins[0]}

6. 访问settings全局配置

${settings.标签名}可以访问settings.xml中配置的元素值，如${settings.localRepository}

7. 用途

• 在当前pom.xml文件中引用属性

• 资过滤功能：在非Maven配置文件中引用属性，由Maven在处理资源时将引用属性的表达式替换为属性值 # Pom.xml扩展

• ：对构建过程进行自己的定制

  • ：当前工程在构建过程中使用的最终名称
  • ：构建过程中用到的插件
    • ：具体插件，内容又包含插件的坐标和插件所需要的依赖信息
      • ：坐标信息
      • ：坐标信息
      • ：坐标信息
      • ：执行部分
        • ：
          • ：唯一标识
          • ：关联的生命周期阶段
          • ：关联的生命周期目标，可配置一个生命周期对应多个目标
          • ：配置信息
    • 注：每个插件能够做哪些配置，都是各个插件自己规定的，无法一概而论
  • ：统一管理插件，子工程使用时可省略版本号

build标签的典型应用：配置JDK版本

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

上述配置也可通过properties配置

<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>

source：调用java编译器时传入的-source参数，即提供与指定发行版的源兼容性 target：调用Java编译器命令时传入的-target参数，即生成特定VM版本的类文件

版本仲裁

假设模块同时依赖多个模块，多个模块之间又存在jar包冲突，此时就需要决定选择哪个版本：

• 最短路径优先
• 路径相同时先声明者优先

Profile

用来配置项目的不同运行环境对应的激活配置信息，可以在两种配置文件中配置

• settings.xml

• pom.xml

• • ：唯一标识 ，命令行调用时可以通过：-D激活对应的profile
  • ：激活方式
    • ：是否默认激活
    • ：表示当前profile可以根据jdk版本来激活
  • 其它标签，当前profile被激活后要采纳的配置，可以包括：
    • build
      • defaultGoal
      • finalName
      • resources
      • testResources
      • plugins
    • reporting
    • modules
    • dependencies
    • dependencyManagement
    • repositories
    • pluginRepositories
    • properties ## 激活Profile

1. POM中没有在profile标签里就是默认profile，默认被激活
2. 环境信息包括：JDK版本()、操作系统参数()、文件()、属性()等各个方面，一个profile一旦被激活，则它定义的所有配置都会覆盖原来POM中对应层次的元素
3. 如果存在多个激活条件：
   1. Maven 3.2.2之前：遇到第一个满足的条件即可激活
   2. Maven 3.2.2及之后，必须所有条件都满足才激活
4. 命令行激活：

• mvn help:active-profiles：列出活动的profile
• mvn compile -P ## 资源属性过滤 Maven能通过profile实现各不同运行环境切换，提供一种资源属性过滤机制，通过属性替换实现不同环境使用不同的参数。 > 实际开发中一般不用，实际开发中一般用Spring框架中的类似机制

1. 配置profile

   <profiles>
       <profile>
           <id>devJDBCProfile</id>
           <properties>
               <dev.jdbc.user>root</dev.jdbc.user>
               <dev.jdbc.password>atguigu</dev.jdbc.password>
               <dev.jdbc.url>http://localhost:3306/db_good</dev.jdbc.url>
               <dev.jdbc.driver>com.mysql.jdbc.Driver</dev.jdbc.driver>
           </properties>
           <build>
               <resources>
                   <resource>
                       <!-- 表示为这里指定的目录开启资源过滤功能 -->
                       <directory>src/main/resources</directory>
   
                       <!-- 将资源过滤功能打开 -->
                       <filtering>true</filtering>
                   </resource>
               </resources>
           </build>
       </profile>
   </profiles>

2. 创建待处理资源文件

   dev.user=${dev.jdbc.user}
   dev.password=${dev.jdbc.password}
   dev.url=${dev.jdbc.url}
   dev.driver=${dev.jdbc.driver}

3. 执行处理资源命令：mvn clean resources:resources -PdevJDBCProfile

4. 延伸：

标签下有时会看到和标签

• ：指定执行resource阶段是要包含到目标位置的资源
• ：指定执行resource阶段时要排除的资源 # 导入体系外jar包 命令行：

  mvn install:install-file -Dfile=[体系外jar包路径] \
  -DgroupId=[给体系外jar包强行设定坐标] \
  -DartifactId=[给体系外jar包强行设定坐标] \
  -Dversion=1 \
  -Dpackage=jar