maven基本知识
Easul Lv6
  2022-03-20 17:08:26 2022-03-20 17:08   2026-03-10 01:04:03      8.2k 字  36 分钟

学习视频

黑马程序员Maven全套教程

基本概念

POM：Project Object Model
archetype：原型
Maven可以进行依赖管理和项目构建

相关目录结构

折叠代码块 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
project
|-- pom.xml
|-- src
|   |-- main
|   |   |-- java
|   |   |   `-- ml
|   |   |       `-- lightly
|   |   |           `-- App.java
|   |   `-- resources
|   |       `-- my.properties
|   `-- test
|       |-- java
|       |   `-- ml
|       |       `-- lightly
|       |           `-- AppTest.java
|       `-- resources  测试程序专用的配置或资源
`-- target

maven目录

折叠代码块 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|-- bin
|   |-- m2.conf
|   |-- mvn    执行构建的脚本
|   |-- mvn.cmd
|   |-- mvnDebug
|   |-- mvnDebug.cmd
|   `-- mvnyjp
|-- boot
|   |-- plexus-classworlds-2.6.0.jar    maven的类加载器
|   `-- plexus-classworlds.license
|-- conf
|   |-- logging
|   |   `-- simplelogger.properties
|   |-- settings.xml
|   `-- toolchains.xml
`-- lib    maven运行所需要的jar包
    |-- commons-cli-1.4.jar
    |-- 。。。
    `-- wagon-provider-api-3.4.3.jar

仓库

本地仓库（本地从私人仓库获取）
私人仓库（私服没有则私服可以从中央仓库获取）
中央仓库

坐标

groupId下的artifactId下的version就有jar包了

本地仓库配置

在settings.xml修改配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
  <!--在这里配置-->
  <localRepository>/home/easul/.ivy2/cache</localRepository>
</settings>

远程仓库配置

在maven的lib目录下有一个maven-model-builder-3.8.4.jar，里边的pom-4.0.0.xml定义了默认的远程仓库地址

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
<repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
</repositories>

但是因为很慢，所以可以定义加速镜像仓库。
在settings.xml修改配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<mirrors>
  <mirror>
      <!--镜像唯一标识符，用于区分不同的mirror元素-->
      <id>alimaven</id>
      <!--设置镜像哪个仓库，这里镜像的是中央仓库，当访问中央仓库的时候就会默认访问这里的url-->
      <mirrorOf>central</mirrorOf>
      <!--镜像名称-->
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
  </mirror>
  <mirror>
      <id>nexus-aliyun</id>
      <mirrorOf>*</mirrorOf>
      <name>Nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  </mirror>
</mirrors>

在maven目录的conf下是全局settings.xml
在自定义仓库目录放的settings.xml是用户自定义的局部配置文件
如仓库在~/.m2/repository，配置文件就放到~/.m2

maven项目制作

项目目录结构可参考这里

折叠代码块BASH 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
mkdir -p ~/project/src/main/java
mkdir -p ~/project/src/main/resources
mkdir -p ~/project/src/test/java
mkdir -p ~/project/src/test/resources
# 创建一个实际要用的类
mkdir -p ~/project/src/main/java/ml/lightly/demo
touch ~/project/src/main/java/ml/lightly/demo/Demo.java
# 创建一个测试类
mkdir -p ~/project/src/test/java/ml/lightly/demo
touch ~/project/src/test/java/ml/lightly/demo/DemoTest.java
# 创建pom.xml
touch ~/project/pom.xml

实际类

折叠代码块JAVA 复制代码 
1
2
3
4
5
6
7
package ml.lightly.demo;

public class Demo {
    public String say(String name) {
        return "hello" + name;
    }
}

测试类相关代码

折叠代码块JAVA 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package ml.lightly.demo;

import ml.lightly.demo.Demo;
import org.junit.Test;
import org.junit.Assert;

public class DemoTest {
    @Test
    public void testSay() {
        Demo d = new Demo();
        String str = d.say("maven");
        // 使用断言判断返回值是否和真实值一样
        // 第一个参数是预计值，第二个参数是真实值
        Assert.assertEquals("hello maven", str);
    }
}

pom.xml

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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/maven-v4_0_0.xsd">
    <!--maven对象模型版本号，即POM对象版本-->
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>ml.lightly</groupId>
    <artifactId>demo</artifactId>
    <!-- RELEASE是完成版，SNAPSHOT是开发板 -->
    <version>1.0-SNAPSHOT</version>
    <!--打包成什么形式，web工程为war-->
    <packaging>jar</packaging>
    
    <!--依赖jar-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

maven构建常用命令

折叠代码块BASH 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 需要在项目根目录进行构建
# 编译main下的java类
# 会自动下载资源插件和编译插件
# maven-resources-plugin:2.6:resources
# maven-compiler-plugin:3.1:compile
# 编译完成后放到了target/classes
mvn compile
# 清除编译目录编译的文件,删除target
# 会下载清理插件
# maven-clean-plugin:2.5:clean
mvn clean 
# 执行测试单元的测试
# 会下载compile需要使用的插件和测试用的资源和编译插件
# maven-resources-plugin:2.6:testResources
# maven-compiler-plugin:3.1:testCompile
# maven-surefire-plugin:2.12.4:test
# 测试失败会返回类似信息
# Failed tests:   testSay(ml.lightly.demo.DemoTest): expected:<hello[ ]maven> but was:<hello[]maven>
# 测试成功会返回如下信息，先显示每条测试结果，在显示总结果
# Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.066 sec
# 
# Results :
# 
# Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
# 
# 在target/surefire-reports中有测试报告
# 在target/test-classes中生成了测试程序字节码
mvn test
# 打包，只打包源程序
# 会执行compile，test，然后再打包
# 会下载对应的打包插件
# maven-jar-plugin:2.4:jar
mvn package
# 将打的包安装到本地仓库
mvn install

插件创建工程

需要在空目录创建工程

折叠代码块BASH 复制代码 
1
2
3
4
5
6
7
8
9
# 创建java工程
# archetype:generate 指定模板创建工程
# -DarchetypeArtifactId 用来指定模板名称
# -DinteractiveMode 用于指定是否使用交互模式
# pom会自带junit，因为自带的AppTest.java需要使用该插件
mvn archetype:generate -DgroupId=ml.lightly -DartifactId=java-project -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=0.0.1-SNAPSHOT -DinteractiveMode=false
# 创建javaweb工程
# pom中packaging修改成了war
mvn archetype:generate -DgroupId=ml.lightly -DartifactId=java-web -DarchetypeArtifactId=maven-archetype-webapp -Dversion=0.0.1-SNAPSHOT -DinteractiveMode=false

插件生成的java工程目录

折叠代码块 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
.
|-- pom.xml
`-- src
    |-- main
    |   `-- java
    |       `-- ml
    |           `-- lightly
    |               `-- App.java
    `-- test
        `-- java
            `-- ml
                `-- lightly
                    `-- AppTest.java

插件生成的web工程目录

折叠代码块 复制代码 
1
2
3
4
5
6
7
8
9
.
|-- pom.xml
`-- src
    `-- main
        |-- resources
        `-- webapp
            |-- WEB-INF
            |   `-- web.xml
            `-- index.jsp

依赖

依赖配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

依赖传递

  • 依赖具有传递性
    • 直接依赖: 当前项目的依赖
    • 间接依赖: 依赖中引用的依赖，本项目是可以直接使用的
  • 依赖传递冲突问题
    • 即本项目和依赖项目用了相同的依赖，但版本不同
    • 路径优先: 把依赖看成一棵树，如果依赖中出现了相同资源，层级越深，优先级越低（高层级依赖会覆盖低层级）
    • 声明优先: 资源在相同层级被依赖，资源配置靠前的覆盖配置靠后的
    • 特殊优先: 同级配置了相同资源的不同版本，后边覆盖前边的(如果一个pom写了同一个依赖的两个版本，后边覆盖前边的)

如果项目三依赖项目二，可以直接在dependency添加项目二的依赖

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
<!--项目三的pom-->
<dependencies>
    <dependency>
        <groupId>ml.lightly</groupId>
        <artifactId>demo-project-2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

如果项目三需要的依赖在项目二中已经有了该依赖
则项目三依赖项目二的时候会自动引用项目二的依赖，不需要再多添加该依赖了

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!--项目二的pom-->
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<!--项目三的pom-->
<!--因为项目二中引用了junit，这里不引用junit也是可以用的-->
<dependencies>
    <dependency>
        <groupId>ml.lightly</groupId>
        <artifactId>demo-project-2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

可选依赖

对外隐藏当前所依赖的资源，这样其他项目依赖该项目时，就无法使用该项目的依赖了

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <!--设置可选依赖，为true即对外隐藏自己使用了哪些依赖-->
        <optional>true</optional>
    </dependency>
</dependencies>

排除依赖

主动断开依赖的资源，不需要指定资源版本
即项目三依赖了项目二，但不想看到项目二中的某些依赖

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!--项目二的pom-->
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<!--项目三的pom-->
<dependencies>
    <dependency>
        <groupId>ml.lightly</groupId>
        <artifactId>demo-project-2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!--需要添加该标签-->
        <!--这样就隐藏了项目二中依赖的junit，不需要加版本号-->
        <exclusions>
            <exclusions>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </exclusions>
        </exclusions>
    </dependency>
</dependencies>

依赖范围

  • 通过scope设置jar可以在哪个生命周期使用
  • 作用范围
    • 主程序有效（main文件夹范围）
    • 测试程序有效（test文件夹范围）
    • 是否参与打包（package指令范围，会打包到jar中）
折叠代码块YAML 复制代码 
1
2
3
4
compile: 默认设置，主程序，测试程序，打包阶段都可用，如log4j
test: 测试程序用，主程序，打包阶段不可用，如junit
provided: 主程序，测试程序可用，打包阶段不可用，如servlet-api
runtime: 打包阶段可用，主程序，测试程序不可用，如jdbc
折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

如果项目二的依赖设置范围为test或provided，项目三依赖项目二，则无法看到该依赖
如果项目二的依赖设置范围为compile或runtime，项目三依赖项目二，项目二可以看到该依赖

依赖范围传递性

横行是直接依赖的范围（项目三中的项目二），竖行是间接依赖的范围（项目二中的某些依赖），中间是组合后的结果（项目三中项目二依赖的范围）

image

项目构建的生命周期

折叠代码块YAML 复制代码 
1
2
3
clean: 清理工作
default: 核心工作，如编译，测试，打包，部署等
site: 产生报告，发布站点等

clean生命周期

折叠代码块YAML 复制代码 
1
2
3
pre-clean: 执行一些在clean之前完成的工作
clean: 移除上次构建生成的文件
post-clean: 执行一些clean之后立即完成的工作

default生命周期

下边的指令执行，就会导致上边的指令一同执行

折叠代码块YAML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
validate: 验证项目是否正确且包含所有必要的信息可用于完成构建过程
initialize: 建立初始化状态，例如设置属性
generate-sources: 生成包含在编译阶段中的任何源代码
process-sources: 处理源代码，比如过滤任意值
generate-resources: 生成将会包含在项目包中资源文件
process-resources: 复制和处理资源到目标目录，准备打包阶段
compile: 编译该项目的源代码
process-classes: 处理编译生成的文件，例如Java类的字节码增强/优化
generate-test-sources: 生成包含在编译阶段中的任何测试源代码
process-test-sources: 处理测试源代码，例如过滤器任何值
generate-test-resources: 为测试创建资源文件
process-test-resources: 复制和处理测试资源到目标目录
test-compile: 编译测试源代码到测试目标目录
process-test-classes: 处理测试源码编译生成的文件
test: 使用合适的单元测试框架进行测试（JUnit）
prepare-package: 在实际打包之前，执行任何必要的操作为打包做准备
package: 提取编译后的代码打包成可分发格式的文件，如JAR、WAR或EAR文件
pre-integration-test: 在执行集成测试前进行必要的动作。例如，设置所需的环境
integration-test: 处理和部署项目到可以运行的集成测试环境
post-integration-test: 在执行集成测试完成后的必要动作。例如：清理集成测试环境
verify: 运行任何检查，验证包是有效的，符合质量审核规定
install: 将包安装到本地存储库，它可以用作本地其他项目的依赖
deploy: 复制最终的包到远程仓库与其他开发者和项目共享

site生命周期

折叠代码块YAML 复制代码 
1
2
3
4
pre-site: 执行一些需要在生成站点文档之前完成的工作
site: 生成项目的站点文档
post-site: 执行一些需要在生成站点文档之后完成的工作，为部署做准备
site-deploy: 将生成的站点文档部署到特定服务器

插件

  • 插件与生命周期内的阶段绑定，执行到对应生命周期，则执行相应插件
  • 默认maven在各个生命周期都绑定有预设的功能
  • 通过插件也可以自定义其他功能（需要在pom.xml中配置）
  • maven的插件库提供了所有插件，如有需要可以参考

打包源码插件

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<build>
    <plugins>
      <plugin>
        <!-- groupId是maven自己的，可以不写 -->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>3.2.0</version>
        <!-- 用于标记源码的插件执行在什么时候 -->
        <executions>
            <execution>
                <goals>
                    <!-- 
                    jar表示对main源码打包
                    test-jar表示对test源码打包
                    可以同时打多个包
                    -->
                    <goal>jar</goal>
                    <goal>test-jar</goal>
                </goals>
                <!-- 指定在什么阶段运行该插件 -->
                <phase>generate-test-resources</phase>
            </execution>
        </executions>
      </plugin>
    </plugins>
</build>

编译插件

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
<plugin>
    <!-- groupId是maven自己的，可以不写 -->
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>   
    <version>3.1</version> 
    <configuration>   
        <!--设置编译和运行jdk版本-->
        <source>1.8</source>   
        <target>1.8</target>   
    </configuration>   
</plugin>

tomcat插件

在这里搜索tomcat maven，找到org.apache.tomcat.maven字样，然后点击该链接进入
然后找到Apache Tomcat Maven Plugin :: Tomcat 7.x点击进入，8.x可以用页面下边的其他包
这样就可以直接用插件运行web服务

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!--含义为构建，用于放相关插件-->
<build>
    <!-- 用于放所有插件 -->
    <plugins>
        <!-- 放具体插件配置 -->
        <plugin>
            <!-- 去掉复制的原本的dependency即可 -->
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.1</version>
            <!-- 如需对插件进行配置可以设置configuration -->
            <configuration>
                <!--设置tomcat服务器端口-->
                <port>8091</port>
                <!--设置tomcat服务器虚拟路径-->
                <path>/</path>
            </configuration>
        </plugin>
    </plugins>
</build>

跳过测试插件

用于跳过测试阶段

分模块开发与设计

如controller，dao，service等每个包都单独拆为一个工程模块，不放到一起开发
模块相互之间通过接口通信
主模块可以什么都不放，然后去设计子模块即可

折叠代码块 复制代码 
1
2
3
4
5
6
7
8
9
10
11
|-- ssm
|   |-- pom.xml
|   `-- ssm.imi
|-- ssm_controller
|   |-- src
|   |-- pom.xml
|   `-- ssm_controller.imi
`-- ssm_dao
    |-- src
    |-- pom.xml
    `-- ssm_dao.imi

模块拆分问题

  • 如果将已有的项目拆分成子模块，一个子模块pom中引用另一个子模块，编译的时候报错，是因为在本地仓库没有找到这个模块
    可以用mvn install先将该模块安装到本地仓库

多模块构建维护

折叠代码块 复制代码 
1
2
3
4
`-- ssm_controller
    `-- ssm_service
        `-- ssm_dao
            `-- ssm_pojo

模块间有依赖关系，假如一个模块更新，其他模块可能无法使用
所以可以创建一个模块管理所有模块，只要一个更新，其他就都更新（也就是聚合）
这个管理的模块不写任何代码，有pom.xml即可

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>ml.lightly</groupId>
    <artifactId>ssm</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!--这里指定为pom表示该模块只用于构建管理，没有写packaging默认打jar包-->
    <packaging>pom</packaging>

    <!-- 管理的工程列表，用于存放子模块 -->
    <modules>
        <!-- 具体的工程名称，也就是文件夹的名 -->
        <!-- 如果模块在上级，需要写../ssm_controller -->
        <!-- 多个模块有依赖关系，会先从最底层开始编译 -->
        <modules>ssm_controller</modules>
        <modules>ssm_service</modules>
    </modules>
</project>

继承

用于保证子模块之间用的依赖版本相同，且可以沿用父工程配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
<!-- 父模块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">
    <!--子父模块间要继承，父模块的打包方式依旧是pom-->
    <packaging>pom</packaging>
    <!-- 声明此处进行依赖管理 -->
    <dependencyManagement>

        <!-- 声明依赖 -->
        <dependencies>
            <!-- 自己的工程依赖也可以定义在这里 -->
            <dependency>
                <groupId>ml.lightly</groupId>
                <artifactId>ssm_dao</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <!-- 声明此处进行插件管理 -->
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.1</version>
                    <configuration>
                        <port>8091</port>
                        <path>/</path>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

<!-- 子模块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">
    <!-- 定义该工程的父工程 -->
    <parent>
        <groupId>ml.lightly</groupId>
        <artifactId>ssm</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 指定父工程pom路径 -->
        <relationPath>../ssm/pom.xml</relationPath>
    </parent>

    <!-- 因为子父模块属于同一个组织ID，所以子模块groupId可以不写 -->
    <!-- 且版本应该由父工程定义，子模块最好不写版本 -->
    <!-- 只写artifactId即可 -->
    <artifactId>ssm</artifactId>

    <dependencies>
        <!-- 父工程引入了各个模块，子工程也可以不写版本号 -->
        <dependency>
                <groupId>ml.lightly</groupId>
                <artifactId>ssm_dao</artifactId>
        </dependency>
        <dependency>
            <!--父工程中定义了相关依赖，为了保证依赖版本统一，所以不写version-->
            <!-- scope因为可能每个模块不同，所以可以留下 -->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <!-- 子模块中的插件就可以不写版本号了，配置如果不变也可以不用写 -->
            </plugin>
        </plugins>
    </build>
</project>

子模块继承的资源

折叠代码块YAML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
groupId: 组织ID
version: 项目版本
description: 项目描述信息
organization: 项目组织信息
inceptionYear: 项目创始年份
url: 项目URL地址
developers: 项目开发者信息
contributors: 项目贡献者信息
distributionManagement: 项目部署配置
issueManagement: 项目缺陷跟踪系统信息
ciManagement: 项目的持续集成系统信息
scm: 项目的版本控制系统信息
mailingLists: 项目的邮件列表信息
properties: 自定义Maven属性
dependencies: 项目的依赖配置
dependencyManagement: 项目的依赖管理配置
repositories: 项目的仓库配置
build: 项目源码目录配置，输出目录配置，插件配置，插件管理配置等
reporting: 项目报告输出目录配置，报告插件配置等

继承与聚合

  • 作用
    • 聚合用于快速构建项目
    • 继承用于快速配置
  • 相同点
    • 继承和聚合的打包方式都是pom
    • 聚合和继承都是设计型模块，没有实际模块内容
  • 不同
    • 聚合在父模块配置关系，可以看到子模块都有哪些
    • 继承在子模块配置关系，父模块不知道谁继承了自己的配置

属性

pom中的变量，例如：可以指定jar包的版本号（版本号仓库需要有，不然会去自动下载新版本的jar）

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- 父模块的pom -->
<properties>
    <!-- 名称可以随便定义，一般定义为技术名称.version -->
    <springboot.version>5.1.9.RELEASE</springboot.version>
    <junit.version>4.12</junit.version>
</properties>

<dependencies>
    <dependency>
        <groupId>ml.lightly</groupId>
        <artifactId>ssm_dao</artifactId>
        <!-- ${version}可以直接使用父模块的版本号给子模块 -->
        <version>${version}</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <!-- ${变量名}来使用属性 -->
        <version>${junit.version}</version>
    </dependency>
</dependencies>

属性分类

  • 自定义属性
    折叠代码块XML 复制代码 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <!-- 自定义属性放到properties标签中 -->
    <properties>
        <!-- 名称可以随便定义，一般定义为技术名称.version -->
        <springboot.version>5.1.9.RELEASE</springboot.version>
        <junit.version>4.12</junit.version>
    </properties>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <!-- ${变量名}来使用属性 -->
        <version>${junit.version}</version>
    </dependency>
  • 内置属性
    折叠代码块XML 复制代码 
    1
    2
    3
    4
    5
    <!-- 内置属性默认都是project.xxx，但是project可以省略 -->
    <!-- 项目根目录 -->
    ${basedir}
    <!-- 项目版本号 -->
    ${version}
  • Setting属性
    折叠代码块XML 复制代码 
    1
    2
    3
    <!-- 使用settings.xml中的属性 -->
    <!-- 本地仓库路径 -->
    ${settings.localRepository}
  • Java系统属性
    折叠代码块XML 复制代码 
    1
    2
    3
    4
    <!-- 用的java中System.getProperties()中的属性，系统属性和环境变量属性会混到一起 -->
    <!-- 也可以使用mvn help:system查询，系统属性和环境变量属性会分开的显示 -->
    <!-- 获取用户目录 -->
    ${user.home}
  • 环境变量属性
    折叠代码块XML 复制代码 
    1
    2
    3
    4
    5
    <!-- 用的java中System.getProperties()中的属性，系统属性和环境变量属性会混到一起 -->
    <!-- 也可以使用mvn help:system查询，系统属性和环境变量属性会分开的显示 -->
    <!-- 获取java根目录 -->
    <!-- 环境变量属性需要使用env. -->
    ${env.JAVA_HOME}

版本管理

折叠代码块YAML 复制代码 
1
2
3
4
5
6
7
SNAPSHOT: 快照版本，未完成版，需要大写，发布的时候才能识别版本
RELEASE: 发布版本，完成版，需要大写，发布的时候才能识别版本
工程版本号约定: <主版本>.<次版本>.<增量版本>.<里程碑版本>
    - 主版本: 项目有重大架构的变更(spring5与spring4的区别)
    - 次版本: 有较大的功能增加和变化，或全面系统的修复漏洞
    - 增量版本: 表示有重大漏洞的修复，临时修改下
    - 里程碑版本: 一个版本的里程碑

资源配置

主要用于配置其他配置文件的内容

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<!-- 在pom中定义jdbc的相关属性 -->
<properties>
    <jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
</properties>


<build>
    <!-- 再在build中配置资源文件对应的信息 -->
    <!-- 这是修改main下的resources -->
    <resources>
        <resource>
            <!-- 指定资源目录，需要从pom的位置来算 -->
            <!-- <directory>../ssm_dao/src/main/resources</directory> -->
            <!-- 或者使用basedir指定项目基础路径更方便，相当于通配格式，可以寻找所有子模块下的src/main/resources -->
            <directory>${project.basedir}/src/main/resources</directory>
            <!-- 指定该文件参与过滤 -->
            <filtering>true</filtering>
        </resource>
        
    </resources>
    <!-- 这是修改test下的resources -->
    <testResources>
        <testResource>
            <!-- 或者使用basedir指定项目基础路径更方便，相当于通配格式，可以寻找所有子模块下的src/test/resources -->
            <directory>${project.basedir}/src/test/resources</directory>
            <!-- 指定该文件参与过滤 -->
            <filtering>true</filtering>
        </testResource>
    </testResources>
</build>
折叠代码块PROPERTIES 复制代码 
1
2
<!-- 在其他文件就可以直接使用pom中定义的变量了，需要先在pom中进行资源配置 -->
jdbc.url=${jdbc.url}

多环境兼容

生产环境，开发环境，测试环境用不同的配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!-- 创建多环境 -->
<profiles>
    <!-- 定义生产环境 -->
    <profile>
        <!-- 定义环境唯一名称 -->
        <id>pro_env</id>
        <!-- 定义环境专用属性值 -->
        <!-- 因为线上线下的jdbc连接不同,所以可以将该属性的定义从根下的properties转移到环境定义中的properties -->
        <properties>
            <jdbc.url>jdbc:mysql://127.0.0.1:3306/ssm_db</jdbc.url>
        </properties>
    </profile>
    <!-- 定义开发环境 -->
    <profile>
        <!-- 定义环境唯一名称 -->
        <id>dev_env</id>
        <!-- 定义环境专用属性值 -->
        <!-- 因为线上线下的jdbc连接不同,所以可以将该属性的定义从根下的properties转移到环境定义中的properties -->
        <properties>
            <jdbc.url>jdbc:mysql://192.168.3.2:3306/ssm_db</jdbc.url>
        </properties>
        <!-- 设置默认启动该环境 -->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
</profiles>

pom中定义好环境之后,想要在不同的情况下用不用的环境可以如下操作

折叠代码块BASH 复制代码 
1
2
3
# -P 指定环境名称
# 生命周期可以选compile,test,package,install各种周期
mvn package -P dev_env

跳过测试

用于已经有了测试用例，但是代码还没有开发完，或者快速打包等
不过测试还是很重要的，如果有一个下载付费的权限忘了设置，则会有灾难性结果

用命令指出跳过测试

折叠代码块BASH 复制代码 
1
2
# -D 指定跳过测试
mvn install -D skipTests

pom指出跳过测试

也就是跳过测试插件的使用

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<build>
    <plugins>
      <plugin>
        <!-- groupId是maven自己的，可以不写 -->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.12.4</version>
        <!-- 设置跳过所有测试 -->
        <!-- <configuration>
            <skipTests>true</skipTests>
        </configuration> -->
        <!-- 指定排除和运行哪些测试 -->
        <configuration>
            <includes>
                <!-- **代表任意包，然后加上java文件名 -->
                <!-- 文件名也支持通配符，Demo*A.java表示Demo开头，A.java结尾的文件 -->
                <include>**/DemoTest.java</include>
            </includes>
            <excludes>
                <exclude></exclude>
            </excludes>
        </configuration>
      </plugin>
    </plugins>
</build>

私服

安装

折叠代码块BASH 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
mkdir ~/software && cd ~/software
mkdir nexus
cd nexus
# 在这里下载最新安装包
# https://help.sonatype.com/repomanager3/product-information/download
wget https://download.sonatype.com/nexus/3/nexus-3.38.0-01-unix.tar.gz 
# 程序目录 ~/software/nexus/nexus-3.38.0-01
# 工作目录 ~/software/nexus/sonatype-work
# 内容目录 ~/software/nexus/sonatype-work/nexus3/blobs/default/content
tar -zxvf nexus-3.38.0-01-unix.tar.gz
rm -rf nexus-3.38.0-01-unix.tar.gz
cd ~/software/nexus/nexus-3.38.0-01/bin
./nexus run nexus
# 启动时间比较长，等到提示 Started Sonatype Nexus OSS 3.38.0-01 即可访问
# 访问地址为ip:8081

# 修改默认配置文件
vi ~/software/nexus/nexus-3.38.0-01/etc/nexus-default.properties
# 可以修改运行IP和端口

# 修改服务器相关配置，包括内存等等
vi ~/software/nexus/nexus-3.38.0-01/bin/nexus.vmoptions

资源获取

自己的包可以上传到私服的某个仓库
如果需要中央仓库的包可以先访问私服，私服再从中央服务器拿
从而简化仓库访问流程，只需要访问私服即可

折叠代码块YAML 复制代码 
1
2
3
4
5
6
7
宿主仓库: 放无法从中央仓库获取的资源，需要自己维护
    - 用于放自主研发的资源
    - 用于放第三方非开源项目
代理仓库: 通过nexus访问其他公共仓库（如中央仓库），然后缓存到本地
仓库组: 用于仓库的分类
    - 将若干宿主仓库或代理仓库组成一个群组，简化配置
    - 仓库组不保存资源，属于设计型仓库

先在ip:8081的右上角进行登录，用户名admin，密码在~/software/sonatype-work/nexus3/admin.password
匿名访问可以关闭掉

界面简介
image

创建宿主仓库

主要创建的就是maven2的仓库
设置=》Repository=》Repositories=》create repository=》找到maven2（hosted）
然后Name可以写成local-release，表示本地的发布版仓库，然后拉到最后create repository

将仓库添加到群组

这样的话只访问群组就可以访问多个仓库了
设置=》Repository=》》Repositories=》点击maven-public=》在下边的Members添加新仓库即可=》save

手动上传组件到仓库

浏览=》Upload=》选择local-release=》Browse选择jar包=》然后添加groupId,artifactId,version
Generate a POM file with these coordinates可以勾选，会生成对应的pom文件=》Browse里的仓库就可以看到jar包了

删除组件

浏览=》Browse=》选择local-release=》选择目录或包=》点击右边的Delete即可

获取仓库组路径

浏览=》Browse=》点击仓库组右边的copy即可获取仓库组url路径

包的上传与下载

  • 本地先将包安装到本地仓库，然后本地仓库将包发布到私服
    • 发布到私服需要私服的用户名密码，以及私服的仓库路径
    • 用户名密码是通用的，所以可以配置到maven的settings.xml
    • 上传的仓库地址，每个项目不同，所以需要在pom.xml中指定
  • 本地从私服下载依赖，都是本地仓库从一个仓库组下载
    • 仓库组是公用的，可以配置到maven的settings.xml
    • 从私服下载也需要用户名密码，配置到maven的settings.xml

本地仓库访问私服配置

在maven的settings.xml中配置私服访问权限，用于访问私服
这里需要指定私服的仓库

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<servers>
    <!-- release仓库 -->
    <server>
        <!-- id配置成私服的仓库名称 -->
        <id>local-release</id>
        <!-- 仓库用户名与密码也配一下 -->
        <username>admin</username>
        <password>admin</password>
    </server>
    <!-- snapshot仓库 -->
    <server>
        <!-- id配置成私服的仓库名称 -->
        <id>local-snapshot</id>
        <!-- 仓库用户名与密码也配一下 -->
        <username>admin</username>
        <password>admin</password>
    </server>
</servers>

配置什么样的资源来源于私服

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<mirrors>
  <!-- 保留多个mirror，获取依赖是会从上到下依次尝试，上边的没有就尝试下边的mirror -->
  <mirror>
      <id>nexus-aliyun</id>
      <mirrorOf>central</mirrorOf>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  </mirror>
  <mirror>
      <!-- 私服id，可以自定义，需要每个mirror不同 -->
      <id>nexus-local</id>
      <!-- 指定镜像哪些东西，*表示镜像一切 -->
      <mirrorOf>*</mirrorOf>
      <!-- 指定该私服的名称 -->
      <name>local</name>
      <!-- 私服的地址 -->
      <url>http://ip:8081/repository/maven-public/</url>
  </mirror>
</mirrors>

发布到私服的配置

折叠代码块XML 复制代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!-- 在项目的pom中进行配置 -->

<!-- 发布资源管理配置，发布的时候会自动根据release和snapshot来判断发布到哪个仓库 -->
<distributionManagement>
    <repository>
        <!-- maven的settings.xml中配置的server的id，也就是配置的仓库id -->
        <!-- 这里配置的release，release包就发到这里 -->
        <id>local-release</id>
        <!-- url需要获取到该仓库的地址 -->
        <url>http://ip:8081/repository/local-release/</url>
    </repository>
    <snapshotRepository>
        <!-- maven的settings.xml中配置的server的id，也就是配置的仓库id -->
        <!-- 这里配置的snapshot，snapshot包就发到这里 -->
        <id>local-snapshot</id>
        <!-- url需要获取到该仓库的地址 -->
        <url>http://ip:8081/repository/local-snapshot/</url>
    </snapshotRepository>
</distributionManagement>

发布包到私服

折叠代码块BASH 复制代码 
1
mvn deploy

私服报错

Could not download page bundle

设置=》System=》Capabilities=》Outreach Management=》修改为Disable

  • 本文标题：maven基本知识
  • 本文作者：Easul
  • 创建时间：2022-03-20 17:08:26
  • 本文链接：https://blog.212490197.xyz/article/tools/maven/basic-knowledge/
  • 版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
复制版权信息
 评论
来发评论吧~
Powered By Valine
v1.5.2
  1. 1. 学习视频
  2. 2. 基本概念
  3. 3. 相关目录结构
  4. 4. maven目录
  5. 5. 仓库
  6. 6. 坐标
  7. 7. 本地仓库配置
  8. 8. 远程仓库配置
  9. 9. maven项目制作
  10. 10. maven构建常用命令
  11. 11. 插件创建工程
  12. 12. 依赖
    1. 12.1. 依赖配置
    2. 12.2. 依赖传递
    3. 12.3. 可选依赖
    4. 12.4. 排除依赖
    5. 12.5. 依赖范围
    6. 12.6. 依赖范围传递性
  13. 13. 项目构建的生命周期
    1. 13.1. clean生命周期
    2. 13.2. default生命周期
    3. 13.3. site生命周期
  14. 14. 插件
    1. 14.1. 打包源码插件
    2. 14.2. 编译插件
    3. 14.3. tomcat插件
    4. 14.4. 跳过测试插件
  15. 15. 分模块开发与设计
    1. 15.1. 模块拆分问题
  16. 16. 多模块构建维护
  17. 17. 继承
    1. 17.1. 子模块继承的资源
  18. 18. 继承与聚合
  19. 19. 属性
    1. 19.1. 属性分类
  20. 20. 版本管理
  21. 21. 资源配置
  22. 22. 多环境兼容
  23. 23. 跳过测试
    1. 23.1. 用命令指出跳过测试
    2. 23.2. pom指出跳过测试
  24. 24. 私服
    1. 24.1. 安装
    2. 24.2. 资源获取
    3. 24.3. 创建宿主仓库
    4. 24.4. 将仓库添加到群组
    5. 24.5. 手动上传组件到仓库
    6. 24.6. 删除组件
    7. 24.7. 获取仓库组路径
    8. 24.8. 包的上传与下载
    9. 24.9. 本地仓库访问私服配置
    10. 24.10. 发布到私服的配置
    11. 24.11. 发布包到私服
  25. 25. 私服报错
    1. 25.1. Could not download page bundle