Maven基础

ever_up973

已于 2022-08-16 19:40:48 修改

阅读量1.9k

点赞数 1

分类专栏： Maven 文章标签： maven mybatis java

于 2022-08-16 00:40:12 首次发布

本文链接：https://blog.csdn.net/hariya/article/details/125648921

版权

Maven 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

学习目标

Maven简介
下载与安装
Maven基础概念
第一个Maven项目(手工制作)
第一个Maven项目(IDEA生成)
依赖管理
生命周期与插件

学习内容

Maven简介
下载与安装
Maven基础概念
第一个Maven项目(手工制作)
第一个Maven项目(IDEA生成)
依赖管理
生命周期与插件

学习产出

1、 Maven简介

当我们在传统项目管理状态分析时，传统的项目需要用到各种 jar 包，例如：mybatis、log4j、JUnit、也会用到别人开发的模块时也会导入其他的模块jar 包。当mybatis版本需要升级，但是其他的包不需要升级，这时就会出现问题，管理时会非常麻烦。
当用到别人开发的模块，别人的模块升级但是自己不知道的话，就会出现各种的问题。
1、jar包不统一，jar包不兼容，开发的环境是在自己的电脑上，但是真实的运行环境是在Linux服务器上，很难能做到一模一样。
正常的做法是将源代码放到服务器上重新编译重新打包，但是在windows系统上有些成员和方法在linux系统上获取的结果不同，这样就会导致功能出错。
2、工程升级维护过程操作繁琐，当需要在Linux上编译时，可能会因为版本或者环境配置问题等而出错。

1.1 Maven是什么

Maven的本质是一个项目的管理工具，将项目开发和管理过程抽象成一个项目对象模型。（POM）
POM (Project Object Model)：项目对象模型

通过加载pom.xml文件就可以了解到项目信息，这个文件代表的就是一个项目，项目里面用的东西可以利用依赖管理来做，自己的项目做完也可以当成一个资源来供Maven管理，依赖管理（Dependency）和项目对象模型（POM）是双向的。

依赖管理所需要用到的资源在计算机中保存的位置称为本地仓库。保存公共的信息在私服仓库中，私服仓库从中央仓库中调取。

Maven除了做依赖管理还可以做项目构建，帮助管理整个开发过程，被称为构建声明周期/阶段。可以利用不同的插件来完成不同的需求。

Maven包含的只是中间的部分，这是Maven的核心，上方的部分是对一个项目操作的过程中对应的内容，下方的插件内容是已经做好的。

1.2 Maven的作用

项目构建：提供标准的、跨平台的自动化项目构建方式。
依赖管理：方便快捷的管理项目依赖的资源（jar包），避免资源间的版本冲突问题
统一开发结构：提供标准的、统一的开发结构

2、下载和安装

进入maven的官网，https://maven.apache.org/index.html，然后点击右边的Download，找到对应的下载的资源。

下载过后解压到自己想放置的文件夹中（尽量放除C盘之外的盘），方便保存。

这个就是maven的安装包解压后的文件内容。

bin目录：这是所有maven可运行指令。

boot目录：里面有jar包，那是maven的类加载器。maven要自己管理一套java的运行程序，maven是java做的有独立的类加载器。

conf目录：配置管理maven的。
logging是日志，里面的setting.xml文件是核心配置。

lib目录：里面是maven运行所依赖的所有jar包。后面查询某些文件时也会从这里面查询。

在系统环境中配置环境，

在系统变量中新建一个系统变量，变量名为MAVEN_HOME，变量值为D:\idea\apache-maven-3.8.5
在Path中添加变量值 D:\idea\apache-maven-3.8.5\bin，然后全部确定。
用管理员身份打开命令提示符，然后输入mvn

出现这样的情况说明maven配置好了，里面的FAILURE说明的是命令有问题。

3、Maven基础概念

3.1 仓库

仓库：用于存储资源，包含各种 jar 包。

本地仓库：是个人的计算机上的 jar 包资源。
中央仓库：maven团队维护的仓库，全球的大多数的 jar 包都在这个仓库中，但是每个用户都去访问中央仓库，并且中央仓库的服务器不在国内，人数多会导致速度非常的慢，所以中间会有一个私服仓库。
私服仓库：本地仓库从私服仓库下载 jar 包，当私服仓库没有的时候本地仓库会向中央仓库下载 jar 包，其他人想调取同样的 jar 包的时候会直接从私服仓库调取，大大提高了效率。

中央仓库和私服仓库两个统称为远程仓库，所以分为了两类，本地仓库内和远程仓库。
私服的作用：

保存具有版权的资源，包含购买或自主研发的jar
中央仓库中的jar都是开源的，不能存储具有版权的资源
一定范围内共享资源，仅对内部开放，不对外共享

3.2 坐标

坐标是什么：
Maven中的坐标用于描述仓库中资源的位置。

Maven主要组成：
groupld：定义当前Maven项目隶属组织名称（通常是域名反写，例如: org.mybatis)
artifactId：定义当前Maven项目名称(通常是模块名称，例如CRM、SMS)
version：定义当前项目版本号
packaging：定义该项目的打包方式

Maven坐标的作用：
使用唯一标识，唯一性定位资源位置，通过该标识可以将资源的识别与下载工作交由机器完成

Maven仓库地址：
https://mvnrepository.com/

4、本地仓库配置

打开 conf 目录下的 setting.xml 文件，然后在50行坐标可以找到默认的 jar 包会保存在哪里。

Default后面可以看出，默认的 jar 包保存到用户目录下的 .m2文件，这个可以在用户文件夹下的 .m2 文件可以看出。

可以在下面加代码改变默认下载的资源在哪个目录。

<localRepository>D:\idea\repository</localRepository>

当前目录位置在 D:\idea\repository文件夹中。

Maven默认的连接的仓库的国外的仓库，下载会非常的慢，所以需要修改下载的地址。

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

所以就需要访问国内的，国内的有一个阿里的仓库，在 setting文件中配置阿里云镜像仓库。

在 setting.xml 文件中的大概第160行的位置会找到 mirrors 标签，在这个标签里添加阿里云仓库的URL地址等。

<mirror>
        <!-- 此镜像的唯一标识符，用来区分不同的mirror元素 -->
        <id>nexus-aliyun</id>
        <!-- 对哪种仓库进行镜像，就是代替了那种仓库 -->
        <mirrorOf>central</mirrorOf>
        <!-- 镜像名称 -->
        <name>Nexus aliyun</name>
        <!-- 镜像 URL -->
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>

最后的添加成品：
在这里插入图片描述
小结

配置本地仓库（资源下载的目录）
配置阿里云的镜像仓库（资源从哪去下载）

5、第一个Maven项目

5.1 手动制作

创建一个文件夹工程，命名为 project，在 project 工程里创建一个名为 src 的文件夹，在 src 文件夹里分别创建名为 main 和 test 的文件夹。在两个文件夹里都创建名为 java 的文件夹和 resources 的文件夹。

main文件：用来写程序的
test文件：用来写测试程序的
java文件：java源程序
resources文件：配置文件

这是基本的工程结构。需要不断地去优化和增加；
下面写代码进行运行和测试

在 main 目录下的 java 文件夹创建 com （一般的习惯是这样明明德）文件夹，在此文件夹里面创建zpd（这个是个人名字缩写，个人习惯，可以更改）文件夹，然后在 zpd 文件夹下名为Demo.java(后缀为java)的文本文件，在文本文件中写：

package com.zpd;

public class Demo{
	public String say(String name){
	System.out.println("Hello "+name);
	return "Hello "+name;
	}
}

相同的办法在 test 目录下创建相同名字的文件夹，但是在 zpd 文件夹里，文件名更改为 DemoTest.java 方便区分。DemoTest.java 的代码如下：

package com.zpd;

import org.junit.Test;
import org.junit.Assert;

public class DemoTest{
	@Test
	public void testSay(){
		Demo  d = new Demo();
		String s = d.say("maven");
		Assert.assertEquals("Hello maven",s);
	}
}

只是有文件和测试文件依旧没办法运行，缺少重要的 pom.xml 文件。
并且这个文件是和 src 目录是同层的。
创建 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!--maven对应模型的版本-->
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zpd</groupId>
    <artifactId>Demomaven</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

这整个maven工程就算是目录结构完成了。
然后接下来该构建这个项目，使用命令来构建。

Maven项目构建命令

Maven构建命令使用mvn开头，后面添加参数功能，可以一次性执行多个命令，使用空格分开。

mvn compile #编译
mvn clean #清理
mvn test #测试
mvn package #打包
mvn install #安装到本地仓库

win + R，然后 cmd 命令进入到命令面板，进入到自己工程对应的文件夹，如果不在默认的C盘，需要先改变盘，然后用 cd 命令访问工程的文件夹，我的位置是D:\大学\前后端\后\中级\project

然后输入指令mvn compile

就会进行下载插件，然后在Maven库对应的本地仓库中，就会有对应的下载的 jar 包文件
Maven本地仓库
在执行命令的时候，就是执行的我们写入的，阿里云的私服地址，每一个插件的下载乃都会有提示，并且可以找到。

时间长的原因是插件都没有在本地仓库里，需要从阿里云的私服中下载，但是再来编译一次的话时间会变的非常的少。
在target目录中就是编译完成的东西。
想要删除可以用DOX命令，mvn clean进行清理，第一次还是需要下载对应的插件，执行命令后，targert 目录就会被删除。

mvn test 命令一看就知道是进行测试的，第一个执行会下载那些对应的插件

会生成target 目录，在目录中多了两个文件夹，上方的图片说明出，进行测试，
测试结果：Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.071 sec
测试运行一个，失败0个，错误0个，跳过0个，用了0.071S，
总结果：Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
Hello maven就是运行的结果。
terget目录中有一个名为surefire-reports的目录，这个目录是执行mvn test才会出现的目录，里面是测试的报告，txt 文件是简略的测试结果报告，xml 文件是详细的报告结果，包含JDK版本，测试的环境是什么样的，文件的字符集等，最后一条是测试结果。（了解）
在test-classes目录中，里面的是测试程序生成的字节码。

mvn package命令，是将工程进行打包的，同样的方法运行，在target文件夹中会出现源程序的 jar 包。

在打包的过程执行了compile，先进行编译，然后testCompile测试程序的编译，最后进行了test测试，下面显示了测试的结果，最后执行的打包的插件。

mvn install命令，这是安装命令，这是将当前打包的东西安装到仓库中，在仓库中有这个jar包，这个会安装到com文件夹里，为什么是在com文件夹呢，因为在pom.xml文件中的groutId标签里写的是com.zpd，然后后面的zpd决定了放置的目录，artifactId标签又决定了一层目录，版本号也决定了一层目录。

	<groupId>com.zpd</groupId>
    <artifactId>Demomaven</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

安装会将前面的编译，测试，打包都进行一遍。
上方的就是Maven的项目构建，Maven是一个项目构建的工具。

插件创建工程

创建工程

mvn archetype:generate
	-DgroupId={project-packaging}
	-DartifactId={project-name}
	<!--用的模板名称-->
	-DarchetypeArtifactId=maven-archetype-quickstart
	-DinteractiveMode=false

创建java工程

mvn archetype:generate 
	-DgroupId=com.zpd -DartifactId=java-project -DarchetypeArtifactId=maven-archetype-quickstart  -Dversion=0.0.1-snapshot  -DinteractiveMode=false

创建web工程

mvn archetype:generate 
	-DgroupId=com.zpd -DartifactId=web-project 
	-DarchetypeArtifactId=maven-archetype-webapp 
	-Dversion=0.0.1-snapshot 
	-DinteractiveMode=false

直接在命令面板上输入指令，生成的目录名称不能是跟刚才的那个，里面不能是maven的结构，所以需要注意DartifactId的的命名不能是已经创建的Maven工程。
用相同的办法去创建 web 工程，在pom.xml 文件中，多出了一句话。打包的时候打 war 包。

  <packaging>war</packaging>

可以对 web 工程里面的目录等进行查看。
Maven中web工程目录和java工程目录的差距是web中多了一个webapp的文件夹。

5.2 IDEA自动生成

首先在IDEA中配置Maven，在左上角找到settings

在搜索框中搜索maven

修改右边的内容

如图，修改这三个内容的路径，
第一个的Maven home path修改为自己的maven文件
第二个修改为自己maven文件中conf目录下的settings.xml文件
第三个如果自己改变就不用修改，如果依旧是C盘中的，修改为自己创建的本地仓库。

然后点右下角，apply—>ok

配置完成后在右上角找如图

在弹出的界面中左边点击Modules

然后确定，选择Maven

next，然后会弹出弹框

默认下面是没有的，需要点击Artifact Coordinates，上面是Maven工程的名字和工程路径，下面是如果打成 jar 包后，jar 包在本地仓库的位置和名称以及版本。
next，会出现

在main中将java目录设置成上方的Sources目录，先点击java，后点击上方的Sources（蓝色的）
将main中的resouces设置成上方的Resources
将test中的java设置成上方的Test（绿色的）
resorces设置成上方的Test resources

最后Apply—>OK

在右边会有Maven的管理面板的按钮

里面含有各种的插件

可以在pom.xml文件中写入一个依赖

   <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

在右边的Maven中刷新，就会在面板中出现写入的依赖。

如果刷新后面板依旧没有这个依赖的显示，说明是maven配置的问题，在一开始的配置中，最好用3.6.1这个版本。

然后在main中的java中，右键new一个新的class文件，名为com.zpd.Demo
这种命名方式用 . 隔开说明是一个层级目录，最后一组才是真正的文件名。

最后出现的是这种情况。
在Demo文件中写代码：

package com.zpd;

/**
 * @Description
 * @Author zpd
 * @Date 2022/8/9
 */
public class Demo {
    public String say(String name){
        System.out.println("Hello "+name);
        return "Hello " + name;
    }
}

在Test中的创建class文件命名为：com.zpd.TestDemo
在TestDemo中写入代码：

package com.zpd;

import com.zpd.Demo;
import org.junit.Assert;
import org.junit.Test;

/**
 * @Description
 * @Author zpd
 * @Date 2022/8/10
 */
public class TestDemo {
    @Test
    public void testSay(){
        Demo d = new Demo();
        String s = d.say("maven");
        Assert.assertEquals("Hello maven",s);
    }
}

可以点击右边的插件来执行mvn命令；

也可以用另一种操作方式执行命令：

然后应用+确定

接下来用模板
来创建Maven工程

前面的几步都是一样的，但是在New Module时，在选择Maven时需要使用下面的模板

找到并选择这个模板，然后next

对里面的命名进行修改，和不用模板的方法一致，但是工程名不能相同。然后next，跳转到下个界面不需要修改，直接再次next，然后OK。
然后查看目录结构，会发现main和test中都缺少resources，在里面都加上resources。

然后用相同的方法去创建Web工程，在Maven中选择模板的时候选择

然后一个Next 最后OK即可，等待文件加载一下。
然后查看工程目录，将缺少的test和java目录创建出。最后的结果如图：

Tomcat插件安装与Web工程启动
在刚创建的web工程中的webapp目录下的的WEB-INF目录下的xml文件，除了web.xml之外全部删除了，因为现在用不到，在web.xml文件里把系统自动生成的代码删除，回归到最初刚创建的那样；

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

</web-app>

在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 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>web01</name>
  <groupId>com.example</groupId>
  <artifactId>web01</artifactId>
  <version>1.0-SNAPSHOT</version>
  
  <dependencies>
  </dependencies>
  
</project>

在里面导入Maven成插件，然后下载导入进去；
最后的代码如下：

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

  <modelVersion>4.0.0</modelVersion>
  <packaging>war</packaging>

  <name>web01</name>
  <groupId>com.example</groupId>
  <artifactId>web01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
  </dependencies>
  <!--构建-->
  <build>
    <!--插件-->
    <plugins>
      <!--具体的插件配置-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
      </plugin>
    </plugins>
  </build>

</project>

这里面的插件配置信息是在Maven坐标库中搜索得到的。
代码写好后第一次会爆红，是因为对应的jar包还没有在本地仓库中，需要从maven仓库内中去下载，点击右上角的刷新按钮。

下面会显示下载

下载完后面板会报错，然后再刷新一次即可；在右边的Maven控制面板中可以看到新出现一个Maven的插件，展开可以看到各种的操作，里面有个run的，双击即可启动服务器；
也可以用别的方法启动，在工程里，右键

这样也可以成功启动。在webapp目录下创建一个JSP文件，命名为index，里面代码如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>zpd</title>
</head>
<body>
Hello，Maven！
</body>
</html>

在下方的面板上点击本地地址，直接跳到到网页上。

结果如图：

可以修改端口号，和访问地址；在版本号标签下添加：

		<configuration>
          <port>80</port>
          <path>/</path>
        </configuration>

在左下角重启服务器，看看新产生的访问地址

点击依旧可以访问index.jsp，也可以在右上角设置快捷的服务器启动方法；

创建完成后以后服务器启动直接点右上角即可；

对于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 http://maven.apache.org/maven-v4_0_0.xsd">
  <!--指定pom的模型版本-->
  <modelVersion>4.0.0</modelVersion>
  <!--打包方式-->
  <packaging>war</packaging>

  <name>web01</name>
  <!--组织id-->
  <groupId>com.example</groupId>
  <!--项目id-->
  <artifactId>web01</artifactId>
  <!--版本号-->
  <version>1.0-SNAPSHOT</version>
  <!--设置当前工程的所有依赖-->
  <dependencies>
    <!---->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <!--构建-->
  <build>
    <!--插件-->
    <plugins>
      <!--具体的插件配置-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

6、依赖管理

6.1 依赖配置

依赖是指当前项目运行所需要的 jar ，一个项目可以设置多个依赖

格式

 <!--设置当前工程的所有依赖 jar 包-->
  <dependencies>
    <!--设置具体的依赖-->
    <dependency>
      <!--依赖所属的群组id-->
      <groupId>junit</groupId>
      <!--依赖所属的项目id-->
      <artifactId>junit</artifactId>
      <!--依赖版本号-->
      <version>4.12</version>
    </dependency>
  </dependencies>

配置多个依赖在dependencies标签里添加新的dependency标签。

6.2 依赖传递

在刚刚创建的两个工程里，当项目A需要用到个项目B时，就需要将项目B变成资源配置到项目A里面。

将项目B里面的pom.xml文件里面的对应的坐标复制到项目A里面；

在项目A里面用dependency标签包含这些坐标。

web01中有 junit 依赖，在test中的使用的时候导入后可以直接使用；
这就是依赖的传递性，项目A中可以使用项目B中所有的资源。

直接依赖：

在当前项目中通过依赖配置建立的依赖关系。

间接依赖：

被资源的资源如果依赖其他资源，当前项目间接依赖其他资源。

依赖传递冲突问题

路径优先

当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高

声明优先

当资源出现在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的

特殊优先

当同级配置了相同资源的不同版本，后配置的覆盖先配置的

6.3 可选依赖

指对外隐藏当前所依赖的资源—不透明
在项目B的pom.xml中

   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <optional>true</optional>
    </dependency>

控制这个资源不被别人看到

6.4 依赖排除

排除依赖指主动断开依赖的资源，被排除的资源无需指定版本-----不需要
在项目A的pom.xml中

<dependency>
      <groupId>com.example</groupId>
      <artifactId>web01</artifactId>
      <version>1.0-SNAPSHOT</version>
      <exclusions>
        <exclusion>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

这样就排除了所以的 log4j 资源。
主动断开可选依赖的资源

6.5 依赖范围

依赖的 jar 默认情况下可以在任何情况下使用，可以通过scope标签设定其作用范围。

作用范围

主程序范围有效（main文件夹范围内）
测试程序范围有效（test文件夹范围内)
是否参与打包（package指令范围内）

依赖范围的传递性

带有依赖范围的资源在进行传递时，作用范围将收到影响

直接依赖相当于项目A，间接依赖相当于项目B，在A中调用B的资源，不同的依赖范围在A中会产生不同的结果。在A中使用privide在B中使用runtime，最后在A中的资源范围是runtime，了解即可…

7、生命周期和插件

7.1 构建生命周期

在前面学的知识可以得出项目必须先进行编译，然后测试、打包，最后进行安装
compile —> test —> package —> install

Maven对项目构建的生命周期划分为3套

clean：清理工作
default：核心工作，例如编译、测试、打包，部署等
site：产生报告，发布站点等

clean周期：
pre-clean：执行一些需要在clean之前完成的工作
clean：移除所以上一次构建生成的文件
post-clean：执行一些需要在clean之后立刻完成的工作

7.2 插件

插件与生命周期内的阶段绑定，在执行到对应生命周期时执行对应的插件功能
默认maven在各个生命周期上绑定有预设的功能
通过插件可以自定义其他功能

在test中的pom.xml下添加插件

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>2.2.1</version>
      </plugin>
    </plugins>
  </build>

在右边的Maven面板中，在Plugins目录下出现了一个新的source插件，在里面继续添加命令。
最后的代码：

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-source-plugin</artifactId>
        <version>2.2.1</version>
        <executions>
          <execution>
               <!--对应的执行位置-->
            <goals>
            <!--对源码进行打包-->
              <goal>jar</goal>
            </goals>
             <!--执行的生命周期过程-->
            <phase>generate-test-resources</phase>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

然后执行右边的命令，先clean清理，然后test，可以发现在target目录里有个新生成的 jar 包，里面就是对main里面的代码进行了打包。install 打包操作会出现两个 jar 包，一个是源码包，另一个是默认需要打一个 jar 包。

如果想对测试代码打包，需要在 goal 标签里进行修改，里面的 jar 修改为 test-jar ，修改后可以进行清理、测试、打包等。install 打包操作会出现两个 jar 包。

如果里面有两个 goal 标签，有 jar 和 test-jar ，然后进行打包，会出现三个 jar 包。

ever_up973

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Maven基础

当我们在传统项目管理状态分析时，传统的项目需要用到各种jar包，例如：mybatis、log4j、JUnit、也会用到别人开发的模块时也会导入其他的模块jar包。当mybatis版本需要升级，但是其他的包不需要升级，这时就会出现问题，管理时会非常麻烦。当用到别人开发的模块，别人的模块升级但是自己不知道的话，就会出现各种的问题。1、jar包不统一，jar包不兼容，开发的环境是在自己的电脑上，但是真实的运行环境是在Linux服务器上，很难能做到一模一样。......
复制链接

扫一扫