pom 文件中mysql pom文件的execution用法

目录

一、pom.xml文件... 1

1、根元素... 1

2、pom版本标签... 1

3、属性标签properties. 1

4、坐标信息... 3

（1）groupId标签... 3

（2）artifactId标签... 3

（3）packaging标签... 3

（4）version标签... 3

（5）name标签... 4

（6）url标签... 4

（7）description标签... 4

（8）developers标签... 4

（9）licenses标签... 4

（10）organization标签... 5

5、依赖标签... 5

（1）dependencies依赖列表标签... 5

（2）dependency依赖项标签... 5

（3）dependency依赖项下的scope标签... 6

（4）dependency依赖项下的optional标签... 6

（5）dependency依赖项下的exclusions排除依赖标签... 6

6、依赖管理标签... 7

（1）dependencyManagement依赖列表... 7

7、build标签... 7

8、parent标签... 8

9、modules标签... 8

二、scope依赖范围... 9

三、依赖的传递... 10

四、依赖冲突... 11

1、短路优先... 11

2、先声明，先优先... 11

五、聚合和继承... 12

1、聚合... 12

2、继承... 13

一、pom.xml文件

1、根元素

project标签--->必须标签，表示标签是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/maven-v4_0_0.xsd">
 
</project>

2、pom版本标签

modelVersion 标签--->必须标签，表示是一个固定的版本，指定了当前pom的版本，必需元素

<modelVersion>4.0.0</modelVersion>

3、属性标签properties

properties标签--->必须标签，可以在该标签中指定端口，字符集，版本号等属性

<properties>
  
<port>8080</port>
<encoding>UTF-8</encoding>
<java.version>1.8</java.version>
<warName>familysf</warName>
<maven.war.plugin.version>3.1.0</maven.war.plugin.version>
<maven.surefire.plugin.version>2.20</maven.surefire.plugin.version>
<maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
<maven.jetty.plugin.version>9.4.5.v20170502</maven.jetty.plugin.version>
<jvm.arg>-Xmx1024m -XX:PermSize=256m -XX:MaxPermSize=512m
         -Dfile.encoding=UTF-8</jvm.arg>
 
</properties>

4、坐标信息

（1）groupId标签

groupId 标签--->必须标签，表示项目的标识，用于标识当前项目属于哪一个实际的项目，和项目创建的包是一样的

<groupId>com.zxr.maven</groupId>

（2）artifactId标签

artifactId标签--->必须标签，表示模块标识，会使用实际的项目名+模块名，一般是该项目的项目名

<artifactId>StudyMaven</artifactId>

（3）packaging标签

packaging标签--->必须标签，表示指定项目的打包方式，不指定，默认为jar ，可以指定为war，zip,pom等

<packaging>war</packaging>

（4）version标签

version标签--->必须标签，表示当前项目的版本号，一般由三个数字表示，第一个0表示大版本号，第二个0表示分支版本号，第三个0表示小版本号

一般用0.0.1-snapshot，其表示一个版本号为0.0.1的快照版

除了快照版，还有alpha内测版，beta公测版，Release稳定版，GA正式发布版本

<version>0.0.1-SNAPSHOT</version>

（5）name标签 

name标签--->必须标签，表示项目的描述名  在产生文档的时候会使用

<name>StudyMaven Maven Webapp</name>

（6）url标签

url标签--->必须标签，表示项目的地址

<url>http://maven.apache.org</url>

（7）description标签

description标签--->非必须标签，表示项目的描述

<description>这里是项目的描述</description>

（8）developers标签

developers标签--->非必须标签，表示指定的作者

<developers>开发人员列表</developers>

（9）licenses标签

licenses标签--->非必须标签，表示许可证的信息

<licenses>许可证的信息</licenses>

（10）organization标签

organization 标签--->非必须标签，表示组织信息

<organization>组织信息</organization>

5、依赖标签

（1）dependencies依赖列表标签

dependencies 标签--->必须标签,表示里面有多个依赖项

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

（2）dependency依赖项标签

dependency 标签--->必须标签，表示有一个依赖项，里面包括了该依赖项的groupId，artifactId，version等信息（坐标）

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

（3）dependency依赖项下的scope标签

scope 标签--->非必须标签，标签内为test时表示该项依赖（这个jar）只能在test时起到作用，打包编译发布后不起作用

<scope>test</scope>

（4）dependency依赖项下的optional标签

optional 标签--->非必须标签，表示设置依赖是否可选，默认为false，为false时，表示子项目默认是继承的，如果是true，表示子项目不是继承的，这个子项目必须引入该依赖

<optional>true</optional>

（5）dependency依赖项下的exclusions排除依赖标签

exclusions标签--->非必须标签，表示排除依赖依赖传递列表，这个标签下面可以排除多个依赖（比如说a依赖于b,b依赖于c，这就是一个传递依赖，但如果a不想依赖c，就可以用这个标签）

<exclusions>
<exclusion>
     
</exclusion>
</exclusions>

6、依赖管理标签

（1）dependencyManagement依赖列表

dependencyManagement 标签--->非必须标签，表示依赖的管理，在他的下面也可以声明依赖列表，存在多个依赖，但是它并不会被运行，就是不会营造实际的依赖，主要用于父模块中定义供子模块使用，比如我们在所有的模块中都用到了Junit，我们就可以抽象出来一个Junit供子模块调用

<dependencyManagement>
<dependencies>
<dependency>
         
</dependency>
</dependencies>
</dependencyManagement>

7、build标签

build 标签--->必须标签，通常为我们的构建行为提供相应的支持，plugin（插件标签就在其中提供支持）

<build>
<finalName>StudyMaven</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${maven.surefire.plugin.version}</version>
<configuration>
<skipTests>true</skipTests>
</configuration>
</plugin>
</plugins>
</build>

8、parent标签

parent标签--->非必须标签，用于子模块中对父模块的继承

<parent></parent>

9、modules标签

modules 标签--->非必须标签，用来聚合多个运行的maven项目，如果有很多模块需要编译时，就可以定义多个module，将其聚合编译

<modules></modules>

二、scope依赖范围

在依赖项dependency标签中，存在依赖的范围，用scope标签来表示范围。

例如

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

在maven中提供了三种classpath分别是编译，测试，运行，上面例子中scope

scope属性值：

compile：默认的范围，在编译测试，运行都有效，在依赖项dependency中不写，也就是不指定scope标签，即表示默认；

provided：在编译和测试的时候有效

runtime：在测试和运行时有效

test：只在测试范围内有效

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

improt：导入的依赖范围，它只使用在dependencyManagement中，表示从其它的pom中导入dependency的配置。

三、依赖的传递

a依赖于b,b依赖于c，这就是一个传递依赖，对于a和c来说，a就是传递性的依赖了c.

b依赖于c：先将c编译并发布jar到仓库中，然后在b的pom文件中添加c的坐标即可，如果不先将c编译并发布jar到仓库中，直接在b的pom文件中添加c的坐标，在编译b的时候就会报错（找不到c的jar）；

a依赖于b：同样先将b编译并发布jar到仓库中，然后在a的pom文件中添加b的坐标即可，如果不先将b编译并发布jar到仓库中，直接在a的pom文件中添加b的坐标，在编译a的时候就会报错（找不到b的jar）；

由于maven的传递性，此时在a的引入的依赖（jar）中，就会出现c的jar，这就是传递依赖；

如果a只想依赖b，不想依赖c，此时可以用排除依赖的标签exclusions

<dependencies>
 
<dependency>
<!-- b的坐标 -->
     
<exclusions>
<exclusion>
<!-- c的坐标 -->
</exclusion>
</exclusions>
     
</dependency>
   
</dependencies>

这样在引入b的依赖时，同时排除c的依赖。

四、依赖冲突

如果有A和B同时依赖了同一个不同版本的构建，对于A和B来说，究竟依赖的是哪个构建。

依赖冲突原则：

1、短路优先

优先解析路径较为短的版本

例一：

路径一：A依赖B依赖C依赖X（jar v-2.0）

路径二：A依赖D依赖X（jar v-2.4）

以上两个路径会优先解析路径二。

例二：

路径一：A依赖X（jar v-2.0）

路径二：B依赖A依赖X（jar v-2.4）

现有：C依赖B

在C中会解析2.4版本的X（jar v-2.4），因为C离B近，C离A中间还有一个B，根据短路优先所以会先解析2.4版本

2、先声明，先优先

在路径相同的情况下，谁先声明，先解析谁。

比如说

路径一：A依赖X（jar v-2.0）

路径二：B依赖X（jar v-2.4）

现有：C同时依赖了B和A，此时两个依赖的路径都相同，在pom文件中引入依赖的时候，如果先引入（声明）A的坐标，在引入（声明）B的坐标，则先解析的是A中依赖的X（jar v-2.0）；如果先引入（声明）B的坐标，在引入（声明）A的坐标，则先解析的是B中依赖的X（jar v-2.4）；

五、聚合和继承

1、聚合

将需要编译的多个模块（项目），同时编译，使用聚合。

例：

maven项目一：A

maven项目二：B

maven项目三：C

现需要同时编译，使用聚合

①创建一个maven项目D

②修改maven项目D的pom.xml文件中的<packaging>war</packaging>标签，将packaging标签内war改为pom；<packaging>pom</packaging>

③添加modules标签

<modules>

<module>../A</module>

<module>../B</module>

<module>../C</module>

</modules>

④编译打包项目D，即可完成ABC同时编译打包

2、继承

将多个项目同时用到的jar，整合到一个空项目的pom中（该空项目无java代码及包，无测试代码及包），提供需要用到的项目继承调用。

①创建一个父类项目，修改maven项目A的pom.xml文件中的<packaging>war</packaging>标签，将packaging标签内war改为pom；<packaging>pom</packaging>

在父类使用dependencyManagement标签，将需要作为父类的依赖坐标（这里用Junit测试）放入该标签内；

在其他项目B需要调用到该项目的jar时，通过parent继承父类的pom，也就是在子类的pom.xml中的parent标签先引入父类的坐标即可