Maven入门

目录

一、Maven简介：

maven高级链接：https://blog.csdn.net/weixin_38568503/article/details/121068171.

（1）传统项目开发存在的问题：

（1.1）没有使用maven：

1. 项目中的jar包必须单独下载并手动“复制”、“粘贴”到WEB-INF/lib目录下，带来的问题是:同样的jar包文件重复出现在不同的项目工程中, 一方面浪费存储空间,另外也让工程比较臃肿。
2. 需要选择正确的jar版本，并手动处理jar文件之间的依赖（如a.jar里面需要使用b.jar的类）

（1.2）使用maven之后：

1. 借助Maven ,可以将jar包仅仅保存在“仓库”中,有需要使用的工程"引用”这个文件接口,并不需要真的把jar包复制过来。
2. Maven会将被依赖的jar包自动下载并引入项目中。

（2）Maven的概述：

（1）Maven是Apache软件基金会组织维护的一款自动化构建工具（使用java语言开发），专注服务于java平台的项目一键构建和jar包依赖管理。

Maven这个单词的本意是：专家，内行，读音是【‘mevn】。

Maven是目前最流行的自动化构建工具，对于生产环境下多框架，多模块的整合开发有重要作用，Maven是一款在大型项目开发中不可或缺的工具。

Maven可以整合多个项目之间的引用关系，我们可以根据业务和分层需要来任意拆分一个项目。

Maven可以把jar包所依赖的其他jar包自动下载并引入到项目中。

类似的自动化构建工具还有Ant,Gradle等。

（2）maven工程对jar包的管理过程：如图所示

（3）Maven项目的一键构建过程：

1. 先来说说什么是构建？指的是项目从编译、测试、运行、打包、安装 ，部署整个过程都交给 maven 进行管理，这个过程称为构建。
2. 一键构建指的是整个构建过程，使用 maven 一个命令可以轻松完成整个工作。

构建是面向过程的，就是一些步骤，完成项目代码的编译，测试，运行，打包，部署等等。

（1）清理:将以前编译得到的旧的class字节码文件删除,为下一次编译做准备
（2）编译:将Java源程序编程成class字节码文件，批量的，maven可以同时把成千上百的文件编译为class。
（3）测试:自动测试，自动调用junit程序
（4）报告:测试程序执行的结果
（5）打包:动态Web工程打war包, Java工程打jar包
（6）安装: Maven特定的概念一将打包得到的文件复制到 "仓库”中的指定位置
（7）部署:将动态Web.工程生成的war包复制到Servlet容器的指定目录下,使其可以运行

Maven项目的一键构建过程图：

（3）Maven的安装和配置：

确保安装了java环境:maven本身就是java写的,所以要求必须安装JDK。
查看java环境:win+r后输入cmd,然后输入:java -version即可查看本机java环境和版本。

Maven的安装和配置请参考：Maven安装和配置

二、Maven的核心概念：

（1）Maven工程约定的目录结构：

maven项目使用的大多人都遵循的目录结构，叫做约定的目录结构。
一个maven项目是一个文件夹，比如项目叫做Hello:（Hello是根目录，也是工程名）

目录结构:
Hello						工程名
|---src						源码
|---|---main				放主程序
|---|---|---java			存放java源文件代码
|---|---|---resources		存放框架或其他工具的配置文件、资源文件
|---|---test				存放测试程序
|---|---|---java			存放java测试代码
|---|---|---resources		存放框架或其他工具的配置文件
|---pom.xml					Maven的核心配置文件

Maven目录详解：

Maven工程的目录结构:
(1). src/main/java —— 存放项目的.java 文件
(2). src/main/resources —— 存放项目资源文件，如 spring, hibernate 配置文件
(3). src/test/java —— 存放所有单元测试.java 文件，如 JUnit 测试类
(4). src/test/resources —— 测试资源文件
(5). target —— 项目输出位置，编译后的 class 文件会输出到此目录
(6). pom.xml——maven 项目核心配置文件
注意：如果是普通的 java 项目，那么就没有 webapp 目录

（2）pom.xml文件：

pom.xml对于Maven工程是核心配置文件,与构建过程相关的一切设置都在这个文件中进行配置。

pom: 即Project Object Model：项目对象模型，Maven把一个项目的结构和内容抽象成一个模型，在xml文件中进行声明，以方便进行构建和描述. pom.xml是Maven的灵魂，所以maven环境搭建好之后，所有的学习和操作都是关于pom.xml的。

• ①. modelVersion:Maven模型的版本，对于Maven2和Maven3来说，它的值只能是4.0.0

• ②. groupId:组织id,一般是公司域名的倒写,格式可以为以下两种:

域名倒写,例如 com.baidu
域名倒写+项目名,例如com.baidu.appolo

• ③. artifactId:模块名，通常是工程名；也是模块名称对应groupId中项目中的子项目。

• ④. version:项目的版本号。如果项目还在开发中,是不稳定版本,通常在版本后带 -SNAPSHOT。version使用三位数字标识,例如1.1.0

• ⑤. name:项目的名称：如图：
  

• ⑥. packaging:项目打包的类型,可以使 jar、war、rar、ear、pom,默认是 jar(一般父工程设置为pom,子工程设置为jar),web项目是war包。
  

• ⑦. dependencies | dependency：Maven 的一个重要作用就是管理jar包,为了一个项目可以构建或运行,项目中不可避免的,会依赖很多其他的jar包,在Maven中,这些 jar 就被称为依赖,使用标签dependency来配置。而这种依赖的配置正是通过坐标来定位的,由此我们也不难看出,maven 把所有的 jar包也都视为项目存在了。

• ⑧.properties:使用properties标签内使用自定义标签统一声明版本号,例如project.build.sourceEncoding（项目构建源码编码方式）,可以设置为UTF-8,防止中文乱码,也可定义相关构建版本号,便于日后统一升级(配置属性)。
  如下：

<properties>
	<!--源码编译jdk版本-->		
	<maven.compiler.source>1.8</maven.compiler.source>
	<!--运行代码的jdk版本-->
	<maven.compiler.target>1.8</maven.compiler.target>
	<!--项目构建使用的编码,避免中文乱码-->
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<!--生成报告的编码-->
	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

• ⑨.build:表示与构建相关的配置,例如设置编译插件的jdk版本(构建)

• ⑩.parent:在Maven中,如果多个模块都需要声明相同的配置,例如：groupId、version、有相同的依赖、或者相同的组件配置等,也有类似Java的继承机制,用parent声明要继承的父工程的pom配置(继承)。

• 11.modules:在Maven的多模块开发中,为了统一构建整个项目的所有模块,可以提供一个额外的模块,该模块打包方式为pom,并且在其中使用modules聚合的其它模块,这样通过本模块就可以一键自动识别模块间的依赖关系来构建所有模块,叫Maven的聚合。

• 12.dependencyManagement：作用其实相当于一个对所依赖jar包进行版本管理的管理器。

12.1.在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。

12.2.pom.xml文件中，jar的版本判断的两种途径：

1).如果dependencies里的dependency自己没有声明version元素，那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明，如果有，就继承它，如果没有就会报错，告诉你必须为dependency声明一个version.

2).如果dependencies中的dependency声明了version，那么无论dependencyManagement中有无对该jar的version声明，都以dependency里的version为准。

pom.xml  
//只是对版本进行管理，不会实际引入jar  
<dependencyManagement>  
      <dependencies>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-core</artifactId>  
                <version>3.2.7</version>  
            </dependency>  
    </dependencies>  
</dependencyManagement>  
  
//会实际下载jar包  
<dependencies>  
       <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-core</artifactId>  
       </dependency>  
</dependencies>

• 13.description:描述信息。
• 14.relativePath：

父项目的pom.xml文件的相对路径。默认值为…/pom.xml。maven首先从当前构建项目开始查找父项目的pom文件,然后从本地仓库找,然后从远程仓库找。RelativePath允许你选择一个不同的位置。

如果默认…/pom.xml没找到父元素的pom,不配置relativePath指向父项目的pom则会报错。

• 15.optional：

可选的，可以理解为此功能/此依赖可选，如果不需要某项功能，可以不引用这个包。

• 16.scope的 provided：
  scope是设置依赖范围的。
  provided：提供的，可以理解为此包不由我直接提供，需要调用者/容器提供。

maven常用的scope有compile,provided,runtime,test：

1、complie是默认值，表示在build,test,runtime阶段的classpath下都有依赖关系。

2、test表示只在test阶段有依赖关系，例如junit。

3、provided表示在build,test阶段都有依赖，在runtime时并不输出依赖关系而是由容器提供，例如web war包都不包括servlet-api.jar，而是由tomcat等容器来提供。

4、runtime表示在构建编译阶段不需要，只在test和runtime需要。这种主要是指代码里并没有直接引用而是根据配置在运行时动态加载并实例化的情况。虽然用runtime的地方改成compile也不会出大问题，但是runtime的好处是可以避免在程序里意外地直接引用到原本应该动态加载的包。例如JDBC连接池。

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<!--Maven模型的版本,对于Maven2和Maven3来说,它只能是4.0.0-->
	<modelVersion>4.0.0</modelVersion>
	<!--父工程的坐标-->
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
	<!--公司名或组织名的域名倒序-->
    <groupId>com.atguigu.gulimall</groupId>
	<!--模块名-->
    <artifactId>gulimall-order</artifactId>
	<!--版本号-->
    <version>0.0.1-SNAPSHOT</version>
	<!--名称-->
    <name>gulimall-order</name>
	<!--描述-->
    <description>谷粒商城-订单服务</description>

	<!--配置信息,一般统一版本号使用-->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR3</spring-cloud.version>
    </properties>

	<!--依赖-->
    <dependencies>
        <dependency>
            <groupId>com.atguigu.gulimall</groupId>
            <artifactId>gulimall-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 <!--插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

maven工程类型：

（3）坐标gav:

数学中的坐标：

在空间上，使用x、y、z三个向量可以唯一的定位空间中的任何一个点。

（3.1）Maven的坐标：

Maven把任何一个插件都作为仓库中的一个项目进行管理，用一组（三个）向量组成的坐标表示。坐标在仓库中可以唯一定位一个maven项目。

gav介绍：

groupid：组织名，通常是公司或组织域名的倒序+项目名
artifactid：模块名，通常是工程名
version：版本号

需要特别指出的是，项目在仓库中的位置是由坐标来决定的：groupid，artifactid，version这三个决定项目在仓库中的路径。artifactid和version决定jar包的名称。

（3.2）Maven工程的坐标与仓库中路径的对应关系：
如：

<groupId> org.springframework </groupId>
<artifactId> spring-core </artifactId>
<version>4.0.0.RELEASE </version>

则本地仓库中的位置为：

org/springframework/spring-core/4.0.0.RELEASE/spring-core-4.0.0.RELEASE.jar

（3.3）项目中如何使用gav:

1. 每个Maven项目，都需要有一个自己的gav坐标。（自定义自己项目的坐标地址gav）
2. 依赖管理：需要使用其他的jar包，同样也需要使用gav坐标作为标志。

搜索gav坐标的默认地址： https://mvnrepository.com/ .

pom.xml中定义自己项目的坐标地址gav：

pom.xml加入别人依赖的方式：

（4）Maven仓库repository：

maven仓库工作原理：我们写完的工程交给maven管理，他就能自动帮我们管理，那我们依赖的jar包从哪里获取呢？

我们发现maven的安装包才8M，我们需要的jar包有时候都几百兆，而为了获取这些依赖的jar包，maven有一个仓库的概念，maven依据pom中的坐标去我们的本地仓库检测找相应的jar包，有相应版本的jar，则直接使用，没有则从互联网下载到我们本地仓库并使用，这样就可以使我们的工程运行起来。

maven的这种方式类似于java中的import导入一样。

（4.1） 仓库的分类：

首先maven仓库分为本地仓库和远程仓库，而远程仓库又包括私服和中央仓库。

（1）本地仓库：

• 当前电脑上部署的仓库目录（可以是自己创建的一个存放jar包的目录），为当前电脑上多有Maven工程服务。用来存储从远程仓库或中央仓库下载的插件和jar包，项目使用一些插件或jar包，优先从本地仓库查找。

默认本地仓库位置在 ${user.dir}/.m2/repository，${user.dir}表示windows用户目录。

（2）远程仓库：如果本地需要插件或者jar包，本地仓库没有，默认去远程仓库下载。远程仓库可以在互联网内也可以在局域网内:

• 私服：是一种特殊的远程仓库因为他是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的maven用户使用。

• 中央仓库：是maven公司提供的最大的仓库，里面拥有最全的jar包资源，所以私服上也没有的时候就会去中央仓库找，因为中央仓库是外网下载速度慢，所以我们需要搭建自己的私服。

• 中央仓库镜像：为了分担中央仓库的流量,提升用户访问速度。

（4.2） Maven 仓库的工作方式:

（4.3） Maven仓库中保存的内容：

1.Maven自身所需的插件
2.第三方框架或工具的jar包
3.自己开发的Maven工程

maven远程网上仓库：链接: https://mvnrepository.com/ .

（5）Maven生命周期：

Maven的生命周期是对项目开发中涉及到的构建过程进行的抽象和统一，其包含了项目的clean:清理、compile:编译、test:测试、package:打包、validate:验证、verify:验证、install:安装、deploy:部署、site:站点生成等几乎整个构建过程。由于Maven的生命周期是抽象的，所以具体的工作实际上是通过插件去完成的。

①. maven 对项目构建过程分为三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”,这三套生命周期分别是：

1. Clean Lifecycle 在进行真正的构建之前进行一些清理工作
2. Default Lifecycle 构建的核心部分，编译，测试，打包，部署等
3. Site Lifecycle 生成项目报告，站点，发布站点
   
   ②.对于我们程序员而言,无论我们要进行哪个阶段的构建,直接执行相应的命令即可,无需担心它前边阶段是否构建,Maven都会自动构建。这也就是Maven这种自动化构建工具给我们带来的好处

③.构建生命周期的不同阶段：

（6）Maven常用命令：

更多命令请参考：https://www.cnblogs.com/wkrbky/p/6352188.html

mvn clean   清除已编译产生的target文件夹内容，可以配合相应命令一起使用，如mvn clean package， mvn clean test

mvn compile   只编译项目代码(执行的是主程序下的代码）。javac命令

mvn package   打包项目(编译了src/main/java下的代码，也编译了java/test/java下的代码，然后打包）

mvn package -Dmaven.test.skip=true   打包项目时跳过单元测试

mvn test        运行单元测试（不仅仅编译了src/main/java下的代码，也编译了java/test/java下的代码）

mvn install     打包后将其安装在本地仓库(执行的时候会打成war包，编译了src/main/java下的代码，也编译了java/test/java下的代码，将这个包安装到了本地仓库中）

mvn deploy      打包后将其安装到pom文件中配置的远程仓库

mvn site        生成站点目录

注意：运行Maven命令时一定要进入pom.xml文件所在的目录！

（7）

一般使用：先清理，后打包，组合使用

（7）Maven插件plugings：

build标签：用于配置和构建项目的。例如设置编译插件的jdk版本。

<build>
    <plugins>
        <!-- 插件定义 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <!-- 对插件进行全局设置，不管此插件绑定到什么阶段都使用同样的配置 -->
            <configuration>
                <!-- 指定编译代码的jdk版本 -->
                <source>1.8</source>
                <!-- 运行java程序使用的jdk版本 -->
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

上述的为全局配置，这样不管绑定到compiler阶段的compiler任务还是绑定到testCompiler任务，都可以使用该配置.

常用插件：

（1）clean插件maven-clean-plugin:2.5：

clean阶段是独立的一个阶段，功能就是清除工程目前下的target目录，对应的插件是 maven-clean-plugin:2.5，2.5是版本号，可以使用maven内置的插件，当然也可以自己在pom中配置，配置方式和上面所说的maven-compiler-plugin配置方式一样。

（2）resources插件maven-resources-plugin:2.6：

resource插件的功能就是把项目需要的配置文件拷贝到指定的目当，默认是拷贝src\main\resources目录下的件到classes目录下，当然可以自己来配置源目录和输出目录。resources插件一般不单独执行，complie插件执行时会先调用resources插件。配置示例如下：

<plugin>  
 <groupId>org.apache.maven.plugins</groupId>  
 <artifactId>maven-resources-plugin</artifactId>  
 <version>2.6</version>  
 <executions>  
   <execution>  
      <id>copy-resources</id>  
      <!-- 在default生命周期的 validate阶段就执行resources插件的copy-resources目标 -->  
      <phase>validate</phase>  
      <goals>  
        <goal>copy-resources</goal>  
      </goals>  
      <configuration>  
      <!-- 指定resources插件处理资源文件到哪个目录下 -->  
         <outputDirectory>${project.build.outputDirectory}</outputDirectory>  
          <!-- 也可以用下面这样的方式（指定相对url的方式指定outputDirectory） <outputDirectory>target/classes</outputDirectory> -->  
          <!-- 待处理的资源定义 -->  
          <resources>  
             <resource>  
                <!-- 指定resources插件处理哪个目录下的资源文件 -->  
                <directory>src/main/${deploy.env}/applicationContext.xml</directory>  
                <!-- 指定不需要处理的资源 <excludes> <exclude>WEB-INF/*.*</exclude> </excludes> -->  
                <!-- 是否对待处理的资源开启过滤模式 (resources插件的copy-resources目标也有资源过滤的功能，这里配置的   
                这个功能的效果跟<build><resources><resource>下配置的资源过滤是一样的，只不过可能执行的阶段不一样， 这里执行的阶段是插件指定的validate阶段，<build><resources><resource>下的配置将是在resources插件的resources目标执行时起作用（在process-resources阶段）) -->  
                <filtering>false</filtering>  
             </resource>  
          </resources>  
      </configuration>  
      <inherited></inherited>  
   </execution>  
 </executions>  
 </plugin>  

（3）compile插件maven-compiler-plugin：
compile插件执行时先调用resouces插件，功能就是把src\mainjava源码编译成字节码生成class文件，并把编译好的class文件输出到target\classes目录下。

（4）test测试插件：
单元测试所用的compile和resources插件和主代码是相同的,但执行的目标不行,目标testCompile和testResources是把src\test\java下的代码编译成字节码输出到target\test-classes,同时把src\test\resources下的配置文件拷贝到target\test-classes。

（5） package打包插件：maven-jar-plugin
这个插件是把class文件、配置文件打成一个jar(war或其它格式)包

（6）deploy发布插件：maven-install-plugin
发布插件的功能就是把构建好的artifact部署到本地仓库,还有一个deploy插件是将构建好的artifact部署到远程仓库

（8）依赖dependency:

依赖：项目中要使用其他的资源jar包。

①. 一个Maven项目正常运行需要其它项目的支持,Maven会根据坐标自动到本地仓库中进行查找。对于程序员自己的Maven项目需要进行安装,才能保存到仓库中

②. 不用maven的时候所有的jar都不是你的,需要去各个地方下载拷贝,用了maven所有的jar包都是你的,想要谁,叫谁的名字就行。maven帮你下载

需要使用maven 来 表示依赖并且管理依赖，通过dependency和gav一起完成依赖的使用。如下：

三、Maven在IDEA中的应用：

（1）IDEA中集成本地maven:

idea中有一个自带的maven.我们一般不用自带的。我们要让idea使用自己本机安装的maven:
（1）选择File–>Settings -->Build,Excution,Deployment–>Build Tools–>Maven

对于本项目的Maven的配置：（局部的maven设置）

如图配置：

对于所有新建的项目的Maven的配置：（全局的maven设置）

（2）IDEA中创建maven项目：

（1）不使用模板创建maven项目：

比如我们组织名：com.fan,项目名：MavenDemo:

maven标准的目录结构：

maven标准目录说明：

注意：这些约定好的目录的名字是不能更改的，如不能更改java文件夹名字等。

自己本项目install安装后的项目的jar的位置：依据本项目的pom的gav去寻找：

（2）使用模板(骨架)创建maven项目：

其中创建java的maven模板我们选择：maven-archetype-quickstart
创建web的maven模板我们选择：maven-archetype-webapp

（3）使用maven创建web工程：

1.创建新工程:File–>New -->Project

2.选择 idea 提供好的 maven 的web 工程模板:

3.项目的gav坐标填写：

4.maven选择：

5.点击 Finish 后开始创建工程，耐心等待，直到出现如下界面。

6.创建java文件夹并标记：

7.然后File–>Project Structure–>Modules:

（4）IDEA中导入Maven工程(module):

①. 新建一个空的project作为工作空间

②. 在项目结构中导入或移除 module

③. 选择要导入的Module：

④. 选择导入方式

⑤. 选择要导入的项目

⑥. 设置导入module所使用的JDK

⑦. 导入后项目结构

⑧. 导入后视图

---

-------------------------------------------------分割线-----------------------------------------------------------

---

---

单独刷新本项目的依赖：常用