1. Toy模板网首页
  2. > Toy博客

Maven教程--下（包括手动实现）

10月前 作者：尘觉 分类：Toy博客 阅读(21) 违法举报

这篇具有很好参考价值的文章主要介绍了Maven教程--下（包括手动实现）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Maven教程–下（包括手动实现）

前言

注意本篇是需要一定的maven基础的 如果没有请移步Maven教程–上

手动创建Maven 项目- 理解Maven 底层机制

需求说明/图解

用手工的方式，创建maven 项目， 深刻理解Maven 工作机制

完成功能-说明

  1. 编写一个类, 有一个方法sum，可以返回两个数的和
  2. 编写测试类TestSum, 可以测试sum 是否正确.
  3. 使用指令完成Maven 的编译(complile)、测试(test)、打包(package)、安装(install)、清理(clean)等操作

手写方式

完成代码编写

  1. 先根据maven 项目的结构要求，在d 盘: 创建项目结构(如图)

Maven教程--下（包括手动实现）

  1. 创建\Hello.java ,说明: 这个文件可以手写, 也可以从快速入门项目拷贝一份.
public class Hello {
    public String sum(int n1, int n2) {
        System.out.println("sum= " + (n1 + n2));
        return "sum= " + (n1 + n2);
    }
}
  1. 创建HelloTest.java,说明: 这个文件可以手写, 也可以从快速入门项目拷贝一份, 同时注意这个文件是在src\test… 下的…

public class HelloTest {

@Test
public void testSum() {

    Hello hello = new Hello();
    String res = hello.sum(1, 9);

    //使用断言
    /**
     * 1.Assert 是一个断言类,(就是判断实际返回的值和期望值是否相同)
     * 2.如果res 和 "sum=10" 是相同的，则通过断言
     * 3.如果res 和 "sum=10" 是不相同的，则给出提示
     *
     */
    Assert.assertEquals("sum=10", res);
}
  1. 创建pom.xml, 从快速入门项目拷贝一份即可. 放在和src 同级目录即可, 提示:使用记事本来保存, 保证该文件的编码是utf-8
    <!--
        解读:modelVersion
        1. 描述这个pom文件/pom模型遵循的哪个版本
        2. 对应maven2 和 maven3 而言, 这里的modelVersion只能是4.0.0
    -->
    <modelVersion>4.0.0</modelVersion>

    <!--
        解读: 下面是指定该项目的坐标, 是创建项目时，程序员指定
        1. groupId: 组织名
        2. artifactId: 项目名
        3. version: 版本
    -->
    <groupId>com.wedu</groupId>
    <artifactId>java-project-maven</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--
        解读
        1. 这里就是引入项目需要的jar包, 类似传统项目的import jar的作用
        2. 在 dependencies标签内, 可以指定多个需要依赖的jar /导入jar
        3. 引入的jar包需要一个完整的jar包坐标, 从mvn仓库查询得到
    -->
    <dependencies>
        <dependency>
            <!-- 依赖jar的 groupId ： 组织名-->
            <groupId>junit</groupId>
            <!-- 依赖jar的 artifactId ： 项目名-->
            <artifactId>junit</artifactId>
            <!-- 依赖jar的 version ： 版本-->
            <version>4.12</version>
        </dependency>

Maven教程--下（包括手动实现）

完成编译

  1. 执行如下指令，完成maven 项目的编译，会得到源代码对应的class 文件(如图)

Maven教程--下（包括手动实现）

  1. 编程成功，会自动创建target 目录，并生成对应的.class 文件(如图)

Maven教程--下（包括手动实现）

  1. 细节说明： 第一次速度慢，需要下载相关jar，后面就快了.

完成测试

  1. 执行如下指令，完成maven 项目的测试，(如图)

Maven教程--下（包括手动实现）

  1. 测试指令执行完毕，会生成Test 源文件的class , 还会输出测试结果.

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

  1. 细节说明： 第一次速度慢，需要完成一些初始化工作，后面就快了.

完成打包

  1. 执行如下指令，完成maven 项目的打包，输出jar, 可以供其它模块使用(如图)

Maven教程--下（包括手动实现）

  1. 打包后，在target 目录生成对应的打包文件jar

Maven教程--下（包括手动实现）

完成安装

  1. 为了演示方便, 把当前maven 的settings.xml 的仓库恢复到默认的, 修改D:\program\apache-maven-3.6.3-bin\apache-maven-3.6.3\conf\settings.xml

Maven教程--下（包括手动实现）

  1. 执行install 指令，能完成maven 项目的安装，会把打包得到的jar, 提交到本地仓库

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

  1. 说明: 如果没有修改settings.xml 成默认的仓库路径, install 后, 生成的jar 会在指定的仓库路径下.
  2. 注意当把hello-project-1.0.jar 提交到本地仓库后，该jar 也可以被其他maven 项目使用了,非常方便

完成清理

  1. 执行如下指令，完成maven 项目的清理，会清除生成的target 目录

Maven教程--下（包括手动实现）

  1. 应用场景，比如我们希望把源码进行拷贝或移植， 或者希望来一次全新的bulid，就可以先进行clean

小结Maven 构建指令

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

mvn compile #编译
mvn clean #清理
mvn test #测试
mvn package #打包
mvn install #安装

IDEA 创建Maven Web 工程

需求说明/图解

使用IDEA 创建Maven WEB 项目, 可以运行hello,world 页面

注意体会Maven WEB 项目和前面创建的Maven java 项目不同

创建Maven web 项目

创建maven web 工程

web-hello-maven 工程

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

创建成功的maven web 项目结构

Maven教程--下（包括手动实现）

创建的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">
  <modelVersion>4.0.0</modelVersion>

  <!--
  解读
  1. groupId 、artifactId、version就是 maven项目坐标
  2. packaging: 打包方式，默认是jar, 因为当前是web项目，所以这里打包成war
  -->
  <groupId>com.wyxedu</groupId>
  <artifactId>web-hello-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>web-hello-maven Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <!-- maven项目的属性, 根据实际情况，可以修改 -->
  <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>
  </properties>


  <dependencies>
    <!-- 默认引入的jar -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!--默认引入的maven插件, 前面说过mvn的各种指令compile/install/test等都是由插件完成的 -->

  <build>
    <finalName>web-hello-maven</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

配置Tomcat 服务器&运行

  1. 为maven web 项目配置tomcat

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

war：先打包成war 包，再把该war 包部署到服务器上

war exploded：直接把文件夹、class 文件等等移到Tomcat 上进行部署。因此这种方式支持热部署，一般在开发的时候都是使用这种模式

Maven教程--下（包括手动实现）

依赖管理

依赖配置

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

依赖的举例

<!-- 解读:
1. 这里就是引入项目需要的jar 包, 类似传统的import jar 的作用
2. 在dependencies 标签内，可以指定多个需要依赖的jar/导入的jar
3. 引入的jar 包需要一个完整的jar 包坐标，从mvn 仓库查询即可得到-->
<dependencies>
    <!-- 引入的一个具体的依赖jar, 包括一个完整的依赖坐标-->
    <dependency>
        <!-- 依赖的gruopid: 组织名-->
        <groupId>junit</groupId>
        <!-- 依赖的项目名-->
        <artifactId>junit</artifactId>
        <!-- 依赖的版本-->
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

依赖传递

直接依赖

一句话: 在当前项目中通过依赖配置建立的依赖关系

举例说明
  1. 创建maven_A java 项目

Maven教程--下（包括手动实现）

  1. 在maven_A 项目中引入mysql5.1.47 , 这时我们就说maven_A 项目直接依赖mysql5.1.47jar
<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
</dependencies>
  1. 如图

Maven教程--下（包括手动实现）

间接依赖

一句话: 当前项目直接依赖资源(比如m1), 而m1 又依赖资源(m2)，我们就说当前项目间接依赖资源(m2)

举例说明
  1. 创建maven_B java 模块(为了好理解，我们放在一个项目中)

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

  1. 修改D:\java_projects\maven_B\pom.xml , 引入junit4.12
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>
  1. 修改D:\java_projects\maven_A\pom.xml , 引入maven_B
<dependencies>
    <!-- 引入maven_B -->
    <dependency>
        <groupId>com.wyx</groupId>
        <artifactId>maven_B</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
</dependencies>
  1. 观察maven_A 和maven_B 的依赖情况

Maven教程--下（包括手动实现）

依赖冲突

路径优先
  1. 路径优先∶当依赖中出现相同的资源时，层级越深，优先级越低，层级越浅，优先级越高
  2. 示意图说明:

Maven教程--下（包括手动实现）

  1. 解释项目A 依赖情况
    1. 如果1 度资源有junit 4.1 , 而2 度资源有junit4.2
    2. 根据路径优先原则, 项目A 生效的是junit4.1
  2. 举例说明.
  1. 创建maven_C(为了方便观察，仍然放在一个项目中), 创建方式和maven_B 类似，就不截图了

Maven教程--下（包括手动实现）

  1. 修改D:\java_projects\maven_C\pom.xml, 引入junit4.13
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
    </dependency>
</dependencies>
  1. 修改D:\java_projects\maven_B\pom.xml, 引入maven_C
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_B</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- 引入maven_C -->
        <dependency>
            <groupId>com.wyx</groupId>
            <artifactId>maven_C</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>
  1. 刷新工程，看看maven_A 生效的就是路径优先的maven_B 的junit4.12

Maven教程--下（包括手动实现）

  1. 为了验证是哪个junit 生效了， 还可以通过代码来验证, 写一段代码D:\java_projects\maven_A\src\main\java\HelloTest.java

Maven教程--下（包括手动实现）

声明优先
  1. 声明优先∶当资源在相同层级被依赖时，配置顺序靠前的覆盖配置顺序靠后的
  2. 示意图说明:

Maven教程--下（包括手动实现）

图解项目A 依赖情况

  1. 如果1 度(灰框)资源有junit 4.1 , 而1 度(蓝框)资源有junit4.2
  2. 根据声明优先原则, 要看项目A , 在pom.xml 引入的顺序，先引入的就是生效的
  1. 举例说明.
  1. 创建maven_D(为了方便观察，仍然放在一个项目中), 创建方式和maven_B 类似，就不截图了

Maven教程--下（包括手动实现）

  1. 修改D:\java_projects\maven_D\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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_D</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>
</project>
  1. 修改D:\java_projects\maven_A\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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_A</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- 引入maven_D -->
        <dependency>
            <groupId>com.wyx</groupId>
            <artifactId>maven_D</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- 引入maven_B -->
        <dependency>
            <groupId>com.wyx</groupId>
            <artifactId>maven_B</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>
</project>

Maven教程--下（包括手动实现）

  1. 为了验证是junit4.13.2 生效还是junit4.12 生效， 写一段代码D:\java_projects\maven_A\src\main\java\HelloTest.java

Maven教程--下（包括手动实现）

特殊优先
  1. 特殊优先∶当同级配置了相同资源的不同版本，后配置的覆盖先配置的(提醒：要尽量避免这种没有意义的冲突)
  2. 修改D:\java_projects\maven_A\pom.xml, 引入mysql5.1
<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_A</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- 引入maven_D -->
        <dependency>
            <groupId>com.wyx</groupId>
            <artifactId>maven_D</artifactId>
        
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- 引入maven_B -->
        <dependency>
            <groupId>com.wyx</groupId>
            <artifactId>maven_B</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- 引入mysql5.1.43 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.43</version>
        </dependency>
    </dependencies>

</project>
  1. 根据特殊优先原则: maven_A 生效的是mysql5.1.43

Maven教程--下（包括手动实现）

  1. 测试完后，注销到引入mysql5.1.43 , 这里是为了验证.

可选依赖

一句话: 可选依赖指对外隐藏当前所依赖的资源- 不透明

举例说明
  1. 需求: 隐藏maven_D 项目的junit 依赖，不让其他项目来使用
  2. 修改D:\java_projects\maven_D\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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_D</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <!-- 解读
            1. option 默认是false , 即不隐藏
            2. option 设置为true , 即隐藏-->
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>
  1. 刷新maven 管理器，看maven_A 的变化

Maven教程--下（包括手动实现）

  1. 测试完毕后，别忘了恢复原来状态.

排除依赖

一句话: 排除依赖指主动断开依赖的资源， 被排除的资源无需指定版本- 不需要

举例说明
  1. 需求: maven_A 项目主动排除maven_D 的junit4.13.2 这个依赖
  2. 修改D:\java_projects\maven_D\pom.xml
<!-- 引入maven_D -->
<dependency>
    <groupId>com.wyx</groupId>
    <artifactId>maven_D</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--排除junit-->
    <exclusions>
        <exclusion>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </exclusion>
    </exclusions>
</dependency>
  1. 刷新maven 管理器，看maven_A 的变化, 仍然是拿不到junti4.13.2, 提示: 再通过HelloTest.java 来验证实际使用的junit 版本, 更加清晰了.

Maven教程--下（包括手动实现）

可选依赖和排除依赖区别

一句话: 隐藏依赖是不让其他项目来引用(我不给), 排除依赖是主动不要引入的某个资源(我不要)

依赖范围

作用范围

一句话: 依赖的jar 默认情况可以在任何地方使用， 通过scope 标签设定其作用范围

举例说明

● 作用范围说明
  1. 主程序范围有效(src/main 文件夹范围内)
  2. 测试程序范围有效(src/test 文件夹范围内)
  3. 是否参与打包（package 指令范围内)
  4. compile(默认，在主程序、测试代码、打包都有效)
● 作用范围一览图

Maven教程--下（包括手动实现）

解读

  1. 某个引入的jar 包作用范围是程序员根据，业务的实际需要来设置的，不要认为是固定的。
  2. 比如log4j jar 包，在主程序，测试代码，打包都是需要的, 因此作用范围应当设置为complie
  3. junit 只是测试代码需要，因此作用范围设置为test 合适，但是如果程序员认为在主程序和打包就是要junit, 仍然可以设置为默认compile
  4. 比如servlet-api 是tomcat 自己带的，当把程序打包放到生产环境时，用生产环境tomcat 的servlet-api 即可，所以设置为provided 合适，这样就放在servlet-api 版本冲突.
  5. 比如jdbc, 是第三方的jar , 打包放在生产环境，就应当在自己的包提供jdbc 驱动包,否则程序会因为少驱动包，运行失败
● 看一个案例, 体会依赖范围的特点.
<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_D</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <!-- 解读
            1. option 默认是false , 即不隐藏
            2. option 设置为true , 即隐藏-->
            <optional>false</optional>
            <!-- scope 设置为test, 让他在test 范围有效-->
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
  1. 创建D:\java_projects\maven_D\src\test\java\T2.java, 在test 范围正常使用
import org.junit.Test;

public class T2 {
    @Test
    public void f1(){
    }
}
  1. 创建D:\java_projects\maven_D\src\main\java\T1.java, 在主程序中，报错

Maven教程--下（包括手动实现）

  1. 修改D:\java_projects\maven_D\pom.xml, 发现主程序和测试程序都可以使用了.
<optional>false</optional>
<!-- scope 设置为test, 让他在test范围有效, 默认就是compile,可以不设置-->
<scope>compile</scope>

Maven教程--下（包括手动实现）

Maven教程--下（包括手动实现）

  1. 运行maven web 项目

Maven教程--下（包括手动实现）

Maven 项目构建生命周期

一句话: Maven 构建生命周期描述的是一次构建过程经历了多少个事件

Maven教程--下（包括手动实现）

生命周期的3 大阶段

clean

清理工作

Maven教程--下（包括手动实现）

default

核心工作，例如编译，测试，打包，部署等

Maven教程--下（包括手动实现）

site

产生报告，发布站点等

Maven教程--下（包括手动实现）

生命周期是分阶段执行的

一句话: 项目构建生命周期分很多阶段，并不是每次都完整执行，而是根据用户的要求来执行的【比如你执行compile， 那么就执行到complie 这个阶段，如果你执行install, 则会执行compile->test->package->install】

举例说明

1、演示compile

Maven教程--下（包括手动实现）

2、演示install

Maven教程--下（包括手动实现）

maven 插件

介绍

1、插件与生命周期内的某个阶段绑定，在执行到对应生命周期时, 由对应插件来完成任务/功能.

2、maven 插件很多，先看一张图:

Maven教程--下（包括手动实现）

3、通过插件可以自定义其他功能

4、文档: http://maven.apache.org/plugins/index.html

自定义插件-应用实例

需求: 在pom.xml 加入自定义插件，能够在对maven_D 项目打包时，能输出主程序和测试程序的源码

完成步骤
  1. 当前package 只会得到项目的jar

Maven教程--下（包括手动实现）

  1. 修改D:\java_projects\maven_D\pom.xml, 加入maven 插件并配置(注意: 加入自定义插件后，可能会爆红,重启项目即可.)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         韩顺平Java 工程师
         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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wyx</groupId>
    <artifactId>maven_D</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <!-- 解读
            1. option 默认是false , 即不隐藏
            2. option 设置为true , 即隐藏-->
            <optional>false</optional>
            <!-- scope 设置为test, 让他在test 范围有效-->
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <!--在build 时，自定义的插件-->
    <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>
                            <!-- 对测试程序输出源码打包-->
                            <goal>test-jar</goal>
                        </goals>
                        <!-- 在generate-test-resources 阶段执行-->
                        <phase>generate-test-resources</phase>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
  1. 观察一下maven 项目管理器

Maven教程--下（包括手动实现）

  1. 再次执行maven-D 的intall 操作, 会得到两个新的jar ,分别包含了主程序和测试程序的源码。(说明: 测试时,需要保证src/main/… 和src/test/… 两个目录下有java 源代码,否则不会生成源码jar)

Maven教程--下（包括手动实现）

  1. 解压得到jar , 可以看到源码了.

Maven教程--下（包括手动实现）

maven 插件-maven 构建生命周期关系图

Maven教程--下（包括手动实现）

图解

  1. 在maven 项目构建生命周期中，每个阶段的执行都有相应的插件完成

  2. 各个插件执行过程中，会附带输出内容，比如jar/war/xml/源码

  3. 程序员可以使用maven 默认的插件，也可以自定义插件，完成定制任务.

  4. 自定义插件引入成功, 是可以看到

Maven教程--下（包括手动实现）文章来源地址https://www.toymoban.com/news/detail-486250.html

到了这里，关于Maven教程--下（包括手动实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【教程】N2N V3内网穿透、异地组网，包括Win/Linux/Android，包括不同内网实现adb远程连接

    目录 一、背景 二、Linux 配置 并运行 N2N - Supernode （必选） 三、Linux -- 配置 并运行 N2N - 边缘节点配置 Edge（可选步骤） 四、Windows -- 配置 并运行 N2N - 边缘节点配置 Edge （可选步骤） （一）配置 TAP 虚拟网卡 （二）配置 N

    2024年02月21日
    浏览(68)
  • idea中Maven引入jar包失败，教你手动导入jar包到Maven仓库

    idea中Maven引入jar包失败，教你手动导入jar包到Maven仓库

    本文主要介绍在Idea中引入jar包失败的情况下，如何手动将所需要的jar包有本地导入到Maven仓库。话不多说直接上步骤 先简单了解一下产生的原因： 引入包爆红的原因可能是jar包不完整，也可能是下载失败了。比如这样 如下图所示，里面没有jar包，就是一个空的指引，所以

    2024年02月09日
    浏览(57)
  • 将本地jar包手动添加到Maven仓库依赖处理

    将本地jar包手动添加到Maven仓库依赖处理

    在日常开发中，经常会遇到一些情况，就是在更新Maven时，从网上下载jar包的时候网络不稳定或者其他原因导致jar包数据缺失而导致的依赖无法正常引入的情况. 还有一些其他情况如个人jar包一类的。 以前以上这些情况，通常我是将本地jar包复制到Maven仓库根据目录结构替换相

    2024年02月09日
    浏览(46)
  • 如何下载远程maven仓库的jar 手动放到本地仓库?

    如何下载远程maven仓库的jar 手动放到本地仓库?

    文章目录 如何下载远程maven仓库的jar 手动放到本地仓库? 简单步骤描述: 详细步骤描述: 案例1: 案例2: 结语 在使用Maven构建Java项目时，通常会从中央仓库或其他远程仓库下载所需的依赖库。但是，有时候我们需要手动下载这些依赖库并将它们放到本地仓库，这里提供一个简单

    2024年02月09日
    浏览(80)

  • spring boot maven 手动打入外部jar包依赖

    有时候拿到第三方sdk是，以前都放在项目的某个目录下，然后通过项目路径去引入非常麻烦，最近找到了一个方法，可以手动将外部的jar包导入到本地的maven仓库中，这样你就可以像其他依赖一样正常使用了。 命令如下 Windows系统举例： 1、在你的jar包路径下，cmd打开dos黑窗口

    2024年02月16日
    浏览(44)
  • Linux 安装maven两种方式(使用yum或手动安装)

    Linux 安装maven两种方式(使用yum或手动安装)

    yum install maven -y 配置阿里云镜像 ​vim /etc/maven/settings.xml​​ ，mirrors节点下添加： 下载maven wget https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz   解压 tar -zvxf apache-maven-3.6.3-bin.tar.gz   移动目录 mv apache-maven-3.6.3 /usr/local/maven 添加环境变量  vi /etc/profile  

    2024年02月08日
    浏览(49)
  • 手动上传本地jar、aar到maven私有仓库nexus

    手动上传本地jar、aar到maven私有仓库nexus

    在此做个笔记

    2024年02月10日
    浏览(49)
  • centos7手动配置jdk1.8环境与maven环境

    centos7手动配置jdk1.8环境与maven环境

    链接：https://pan.baidu.com/s/1_P7jHzH4Lk2jcPWWD7pi4w 提取码：6kkm winscp软件上传压缩包到Linux中 解压 配置环境变量 vi /etc/profile Could not retrieve mirrorlist http://mirrorlist.centos.org/?release=7arch=x86_64repo=osinfra=stock error was 14: curl#6 - “Could not resolve host: mirrorlist.centos.org; 未知的错误” cd /etc/syscon

    2024年02月09日
    浏览(40)
  • Maven 配置本地jar，通过下载第三方jar包，然后手动配置maven jar包依赖 例如：IKExpression

    Maven 配置本地jar，通过下载第三方jar包，然后手动配置maven jar包依赖 例如：IKExpression

    说明：有时候有一些jar包 maven中央仓库和阿里云仓库没有收录的jar包需要手动下载至本地进行手动添加maven依赖，就拿 IK表达式 IKExpression jar 包来说 第一步 下载IKExpression 包 没有这个包的同学可以点击下载阿里云盘分享   第二步 找到自己项目本地maven仓库位置，如果不清楚可

    2024年02月12日
    浏览(49)
  • 【错误记录】Android 编译报错 ( Could not resolve xxx | 手动下载依赖库并进行本地配置 Gradle 依赖的解决方案 | 构建 Maven 依赖下载路径 )

    【错误记录】Android 编译报错 ( Could not resolve xxx | 手动下载依赖库并进行本地配置 Gradle 依赖的解决方案 | 构建 Maven 依赖下载路径 )

    编译 Android Studio 项目时 , 报如下错误 , 下载依赖库失败 ; 报错信息 : 下面是 当前 Android 项目的 Gradle 配置中的 Maven 仓库 ; 其中使用 maven { url \\\"https://repo.spring.io/plugins-release/\\\" } 配置的 Maven 仓库就是对应的地址 ; 使用 google() 函数配置的 Maven 仓库地址 是 https://maven.google.com/ , 可

    2024年04月15日
    浏览(78)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包