【Maven】【学习笔记】关于我把war包打成pom包导致报错，我直接过来嗯学，发现maven有点东西这件事

最新推荐文章于 2024-04-12 18:53:50 发布
最新推荐文章于 2024-04-12 18:53:50 发布
阅读量1k 收藏 3
点赞数 3
分类专栏： 四月猛充 文章标签： maven 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flzjcsg3/article/details/124031908
版权

文章目录

概念

构建

构建过程包含的主要的环节

1、清理 : 删除上一次构建的结果，为下一次构建做准备

2、编译 : java源程序编译成 *.class字节码文件

3、测试 : 运行提前准备号的测试程序

4、报告 : 针对刚才测试的结果生成一个全面的信息

5、打包

  • Java工程 ：jar包
  • Web工程 ： war包

6、安装 ： 把一个Maven工程经过打包操作生成的jar包或war包存入Maven仓库

7、部署

  • 部署 jar 包 ： 把一个jar包部署到Nexus私服服务器上
  • 部署 war 包 ： 借助相关Maven插件（例如cargo），将war包部署到Tomcat服务器上

依赖

依赖管理中要解决的具体问题:

●jar包的下载:使用Maven之后，jar 包会从规范的远程仓库下载到本地

●jar包之间的依赖:通过依赖的传递性自动完成

●jar包之间的冲突:通过对依赖的配置进行调整，让某些jar包不会被导入

Maven工作机制

在这里插入图片描述

坐标

使用三个[向量]在Maven仓库中唯一定位到一个jar包

坐标解释举列
groupId公司或组织的idcom.flzj.maven
artifactId一个项目或者是项目中的一个模块的id
模块的名称，将作为Maven工程的工程名		pro01-flzj-maven
version版本号1.0-SNAPSHOT(表示快照版本)
1.0-RELEASE (表示正式版本)
<groupId>com.flzj.maven</groupId>
<artifactId>pro01-maven-java</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

上面的坐标对应的jar包在Maven 本地程库中的位置 :

D:\Maven\storage\com\flzj\maven\pro01-maven-java\1.0-SNAPSHOT

另外，安装操作还会将pom.xml文件转换为XXX.pom文件-起存入本地仓库。 所以我们在Maven的本地仓库中
想看一个jar包原始的pom.xml文件时，查看对应XXX.pom文件即可，它们是名字发生了改变，本质上是同一
个文件

POM

POM : Project Object Model，项目对象模型

模型化思想

POM表示将工程抽象为一个模型,再用程序中的对象来描述这个模型。这样我们就可以用程序来管理项目了。我
们在开发过程中，最基本的做法就是将现实生活中的事物抽象为模型,然后封装模型相关的数据作为一个对象，这
样就可以在程序中计算与现实事物相关的数据

对pom.xml的解释

<!--根标签：project，表示对当前工程进行配置、管理-->
<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 标签:从Maven 2 开始固定就是 4.0.0-->
    <!-- 代表当前 pom.xml 所采用的标签结构 -->
    <modelVersion>4.0.0</modelVersion>

    <!--坐标信息-->
    <!-- D:\Maven\storage\com\flzj\maven\pro01-maven-java\1.0-SNAPSHOT 在本地仓库的路径 -->
    <groupId>com.flzj.maven</groupId>
    <artifactId>pro01-maven-java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--packaging标签 ： 打包方式-->
    <!--取值 jar : 生成 jar 包 ， 说明这是一个 Java 工程-->
    <!--取值 war : 生成 war 包 ， 说明这是一个 web 工程-->
    <!--取值 pom : 说明这个工程是用来管理其他工程的工程 -->
    <packaging>jar</packaging>

    <name>pro01-maven-java</name>
    <url>http://maven.apache.org</url>

    <!--在 Maven 中定义属性值-->
    <properties>
        <!--在构建过程中读取源码时使用的字符集-->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!--dependencies 标签 ： 配置具体依赖信息，可以包含多个dependcy 子标签-->
    <dependencies>
        <!--dependency 标签 ： 配置一个具体的依赖信息 -->
        <dependency>
            <!--坐标信息-->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <!--scope 标签 ： 配置当前依赖的范围-->
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

约定的目录结构

在这里插入图片描述

意义

Maven为了让构建过程能够尽可能自动化完成，所以必须约定目录结构的作用。例如: Maven 执行编译操作,必须先去Java源程序目录读取Java源代码,然后执行编译,最后把编译结果存放在target目录

约定大于配置

Maven对于目录结构这个问题，没有采用配置的方式，而是基于约定。这样会让我们在开发过程中非常方便。如果每次创建Maven工程后，还需要针对各个目录的位置进行详细的配置，那肯定非常麻烦。目前开发领域的技术发展趋势就是:约定大于配置，配置大于编码

Maven安装和配置

1、下载

Maven – Download Apache Maven

重点关注conf/settings.xml

在这里插入图片描述

2、配置本地仓库

打开conf/settings.xml ，修改配置

<!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
<localRepository>d:\Maven\storage</localRepository>

3、配置镜像仓库

因为访问境外的中央仓库下载满，所以我们改成阿里云提供的镜像仓库

<mirror> 
    <id>alimaven</id>  
    <name>aliyun maven</name>  
    <url>https://maven.aliyun.com/repository/public/</url>  
    <mirrorOf>central</mirrorOf> 
</mirror>

4、配置Maven工程的基础JDK版本

<profile>
    <id>jdk-1.8</id>
    <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
</profile>

5、配置Maven_HOME

Maven是基于java写的，所以我们要先检查JAVA_HOME是否正确

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

配置环境变量的规律

XXX_HOME 通常指向的是 bin目录的上一级

PATH 指向的是bin

Maen命令行

1、生成Maven工程

mvn archetype:generate

我们先来到，我们需要生成的目录，输入

在这里插入图片描述

设置坐标

在这里插入图片描述

2、Maven的构建命令

要求

必须要进入到pom.xml所在的目录

2.1、清理操作

mvn clean ： 删除target目录

2.2、编译操作

mvn compile : 主程序编译(结果放在 target/classes)

mvn test-compile : 测试程序编译(结果放在 target/test-classes)

在这里插入图片描述

在这里插入图片描述

2.3、测试操作

mvn test : 测试的报告存放的目录(target/surefire-reports)

在这里插入图片描述

2.4、打包操作

mvn package : 打包的结果为jar包(存放的目录:target)

在这里插入图片描述

2.5、安装操作

mvn install ： 把jar包，存入到本地仓库中

在这里插入图片描述

另外，安装操作还会将pom.xml文件转换为XXX.pom文件-起存入本地仓库。 所以我们在Maven的本地仓库中
想看一个jar包原始的pom.xml文件时，查看对应XXX.pom文件即可，它们是名字发生了改变，本质上是同一
个文件。

3、生成Web工程

mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.4

在这里插入图片描述

3.1、目录结构

在这里插入图片描述

3.2、将Web工程打包为war包

mvn package，生成 war 包的位置如下图所示

在这里插入图片描述

将web工程部署到tomcat玩玩

在这里插入图片描述

3.3、让Web工程依赖Java工程

在这里插入图片描述

<!-- 配置对Java工程pro01-maven-java的依赖 -->
<!-- 具体的配置方式：在dependency标签内使用坐标实现依赖 -->
<dependency>
    <groupId>com.flzj.maven</groupId>
    <artifactId>pro01-maven-java</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>s

把Java工程的CalculatorTest.java复制到src\test\java\com\flzj下，执行mvn test

package com.flzj.maven;
import org.junit.Test;
import com.flzj.maven.Calculator;
// 静态导入的效果是将Assert类中的静态资源导入当前类
// 这样一来，在当前类中就可以直接使用Assert类中的静态资源，不需要写类名
import static org.junit.Assert.*;
public class CalculatorTest{
    @Test
    public void testSum(){

        // 1.创建Calculator对象
        Calculator calculator = new Calculator();

        // 2.调用Calculator对象的方法，获取到程序运行实际的结果
        int actualResult = calculator.sum(5, 3);

        // 3.声明一个变量，表示程序运行期待的结果
        int expectedResult = 8;

        // 4.使用断言来判断实际结果和期待结果是否一致
        // 如果一致：测试通过，不会抛出异常
        // 如果不一致：抛出异常，测试失败
        assertEquals(expectedResult, actualResult);
    }
}

通过查看 war 包内的结构，我们看到被 Web 工程依赖的 Java 工程确实是会变成 Web 工程的 WEB-INF/lib 目录下的 jar 包

在这里插入图片描述

3.4、查看当前Web工程所依赖的jar包

mvn dependency:list : 正常查看

[INFO] The following files have been resolved:
[INFO]    com.flzj.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile
[INFO]    org.hamcrest:hamcrest-core:jar:1.3:test
[INFO]    javax.servlet:javax.servlet-api:jar:3.1.0:provided
[INFO]    junit:junit:jar:4.12:test

mvn denpendency:tree : 以树形结构查看

[INFO] com.flzj:pro02-maven-web:war:1.0-SNAPSHOT
[INFO] +- junit:junit:jar:4.12:test
[INFO] |  \- org.hamcrest:hamcrest-core:jar:1.3:test
[INFO] +- javax.servlet:javax.servlet-api:jar:3.1.0:provided
[INFO] \- com.flzj.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile

依赖

1、范围

标签的位置：dependencies/dependency/scope

标签的可选值：compile/test/provided/system/runtime/import

main目录（空间）test目录（空间）开发过程（时间）部署到服务器（时间）
compile有效有效有效有效
test无效有效有效无效
provided有效有效有效无效

总结

compile ：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包

test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit

provided ：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar 包产生冲突，同时减轻服务器的负担

2、传递性

在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围。

  • B 依赖 C 时使用 compile 范围：可以传递
  • B 依赖 C 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以

3、依赖的排除

在这里插入图片描述

<excludes>标签 : 配置依赖的排除

<exclude>标签 : 配置一个具体的排除（里面写坐标,不需要写version）

<dependency>
    <groupId>com.flzj.maven</groupId>
    <artifactId>pro01-maven-java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <scope>compile</scope>
    <!-- 使用excludes标签配置依赖的排除	-->
    <exclusions>
        <!-- 在exclude标签中配置一个具体的排除 -->
        <exclusion>
            <!-- 指定要排除的依赖的坐标（不需要写version） -->
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

继承

Maven工程之间，A 工程继承 B 工程

本质上是 A 工程的 pom.xml 中的配置继承了 B 工程中 pom.xml 的配置

作用 : 在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本

1、创建父工程

创建一个Maven工程，然后修改pom.xml的打包方式

<groupId>com.flzj.maven</groupId>
<artifactId>pro3-maven-parent</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
<packaging>pom</packaging>

2、创建子工程

在父工程里面，创建maven工程

在这里插入图片描述

此时父工程的pom.xml 会新增

<modules>  
    <module>pro4-maven-module</module>
    <module>pro5-maven-module</module>
    <module>pro6-maven-module</module>
</modules>

modules 和 module 标签是聚合功能的配置

解读子工程的pom.xml

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
    <!-- 父工程的坐标 -->
    <groupId>com.flzj.maven</groupId>
    <artifactId>pro3-maven-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>
<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.flzj.maven</groupId> -->
<artifactId>pro4-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->

3、在父工程依赖管理

<dependencyManagement> 标签

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        ...
    </dependencies>
</dependencyManagement>

子工程依赖管理

<!-- 子工程引用父工程中的依赖信息时，可以把版本号去掉。	-->
<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。不去由自己决定 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
	</dependency>
	</dependency>
</dependencies>

4、配置自定义属性

<自定义标签> ： 方便版本管理

引用方式： ${flzj.spring.version}

<!-- 通过自定义属性，统一指定Spring的版本 -->
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 自定义标签，维护Spring版本数据 -->
    <flzj.spring.version>4.3.6.RELEASE</flzj.spring.version>
</properties>
....
<!-- 然后去下面引用 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${flzj.spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${flzj.spring.version}</version>
        </dependency>
        ...
    </dependencies>
</dependencyManagement>

聚合

有父工程时先安装父工程；有依赖的工程时，先安装被依赖的工程

配置

<modules> 标签

<modules>  
    <module>pro04-maven-module</module>
    <module>pro05-maven-module</module>
    <module>pro06-maven-module</module>
</modules>

无烧话。。。。。。。。。。。。。。。

FLZJ_KL
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Springboot项目正确打war包maven版pom.rar
11-20
maven版正确的Springboot打war包所需的pom依赖配置文件，童叟无欺，绝不欺骗，如下载后有问题，可联系本人
Maven 教程：基础篇-尚硅谷学习笔记 2022年
08-09
**Maven教程：基础篇——尚硅谷学习笔记 2022年** Maven是一个强大的Java项目管理和构建工具，由Apache软件基金会开发。它通过提供一个标准的项目对象模型（Project Object Model，POM）来简化项目的构建过程，并...
Maven War包 POM配置文件 设置最佳实践
Gavid0124的专栏
10-19 7034
如何为你的Web程序（war包设定配置文件） 约定 http://maven.apache.org/plugins/maven-war-plugin/examples/adding-filtering-webresources.html 上面链接说了： The default resource directory for all Maven projects is src/ma
开发常见问题集锦—Spring部分—版本匹配兼容性问题
最新发布
2401_84048006的博客
04-12 291
很多程序员，整天沉浸在业务代码的 CRUD 中，业务中没有大量数据做并发，缺少实战经验，对并发仅仅停留在了解，做不到精通，所以总是与大厂擦肩而过。我把私藏的这套并发体系的笔记和思维脑图分享出来，理论知识与项目实战的结合，我觉得只要你肯花时间用心学完这些，一定可以快速掌握并发编程。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
关于maven打包时出现jar包版本的多重引用导致最终war包里的版本不是最新的
junjie0324的专栏
12-10 2190
在主maven项目里的pom里加上 com.aiyowei comlib 0.0.14 然后在引用低版本的的项目里最下面加上 com.aiyowei comlib 然后打包就会把最新版本的jar包打进去了
maven 中pom、war、jar详解
liujian8654562的博客
09-16 757
1.pom工程：用在父级工程或聚合工程中。用来做jar包的版本控制。 2.war工程：将会打包成war，发布在服务器上的工程。如网站或服务。 3.jar工程：将会打包成jar用作jar包使用。 补充一下，jdk9 后还可以打包 jmod（Java 模块化），厉害的是这个通过 jlink 命令，可以直接将 jmod 打包为对应环境的可执行的程序，告别了让用户安装 jdk 的步骤，现在也有对应的 ma...
Spring boot 打包项目成 .war
实习打字猿的博客
02-29 145
# 主类继承 SpringBootServletInitializer 并重写 configure import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boo...
maven学习笔记
12-16
**Maven学习笔记** 在Java开发领域，Maven是一个不可或缺的构建工具，它极大地简化了项目的构建、管理和依赖管理过程。Maven通过一个统一的项目对象模型（Project Object Model，POM），使得开发者可以轻松地定义...
maven学习笔记.rar
06-10
** Maven学习笔记详解 ** Maven，作为Java项目管理和构建工具，是开发人员不可或缺的利器。它通过使用一种标准化的项目对象模型（Project Object Model，POM）来管理项目的依赖关系，构建过程以及配置信息。Maven...
Maven学习笔记.zip
10-20
**Maven学习笔记** 在Java开发领域，Maven是一个不可或缺的构建工具，它极大地简化了项目的构建、管理和依赖管理过程。Maven通过使用一个项目对象模型（Project Object Model，POM），XML格式的配置文件，定义了...
Maven学习笔记
06-27
** Maven学习笔记 ** Maven是一个强大的项目管理工具，它主要应用于Java开发环境，由Apache软件基金会开发。Maven简化了构建过程，通过一个统一的配置文件（pom.xml）来管理项目的构建、报告和依赖关系，使得项目的...
Maven的三种项目打包方式——pom，jar，war的区别
weixin_41262132的博客
07-06 2592
是怎么发现，因为我是从父模块打包的，但是发现我这个子模块找不到，我发现父子模块依赖关系也没错啊，我就单独打包这个子模块，结果没有错误，但是没生成target文件，也就是没编译出来，后来一查，原来pom是聚会模块的作用，子模块应该是jar或者war。记录一次项目启动失败，发现Could not resolve dependencies for project的错误，原因是我的子模块的打包方式是pom。1、pom：用在父级工程或聚合工程中，用来做jar包的版本控制，必须指明这个聚合工程的打包方式为pom。
springboot---Jar包War包--Pom包
weixin_61241721的博客
11-07 408
springboot---Jar包War包--Pom包
maven项目pom文件以war包方式导入依赖，修改依赖中某个子依赖版本失败
HPF_99的博客
09-21 402
pom文件导入依赖中升级某个组件或是jar包版本
Maven中Jar包、War包、和Pom工程有何区别？
PIKapikaaaa的博客
07-07 370
Maven中Jar包、War包、和Pom工程有何区别？？
创建 Maven 版的 Web 工程,打包war包
weixin_61635597的博客
05-24 485
Maven 版的 Web 工程，打包为 war包
SpringBoot2.5 maven打 war 包 最佳配置
u014212540的博客
09-30 1198
【代码】SpringBoot2.5 maven打 war 包 最佳配置。
Maven的packaging打包方式 pom，jar，war的区别
进击的豌豆的博客
12-30 2899
Maven的packaging打包方式 pom，jar，war的区别
JUnit4 / JUnit 5 全面详解【单元测试、Maven】
青年有志
04-08 3484
JUnit4 / JUnit 5 全面详解【单元测试、Maven】
idea把maven项目打成war包
06-28
### 回答1： 要将Maven项目打成WAR包，可以按照以下步骤进行操作： 1. 在Maven项目的pom.xml文件中，添加以下配置： ``` <packaging>war</packaging> ``` 2. 在Maven项目的根目录下，执行以下命令： ``` mvn clean package ``` 3. 执行完上述命令后，会在target目录下生成一个WAR包文件，可以将该文件部署到Web容器中。 希望这些步骤能够帮助您将Maven项目打成WAR包。 ### 回答2： Maven是一款Java项目管理工具，可以用来自动化构建、依赖管理和项目部署等任务。而WAR（Web Application Resource）则是一种Java Web应用程序的打包格式，可以将Java Web应用程序的所有相关文件打包成一个单独的文件。 在使用Maven构建Java Web项目时，我们可以将项目打成WAR包方便部署和发布。以下是使用Maven将Java Web项目打成WAR包的具体步骤： 1. 在pom.xml文件中声明项目类型为WAR包类型： ``` <packaging>war</packaging> ``` 2. 配置Maven插件：maven-war-plugin ``` <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <version>3.3.2</version> <configuration> <webXml>src/main/webapp/WEB-INF/web.xml</webXml> </configuration> <executions> <execution> <phase>package</phase> <goals> <goal>war</goal> </goals> </execution> </executions> </plugin> </plugins> </build> ``` 3. 执行Maven打包命令 在项目根目录中执行以下命令： ``` mvn clean package ``` 执行完上述步骤后，Maven会将Java Web项目打成WAR包，生成在target目录下。可以部署WAR包到Tomcat等Web容器中。 总之，使用Maven将Java Web项目打成WAR包可以方便项目部署和发布，具体实现可通过在pom.xml文件中声明WAR包类型，配置Maven插件，执行Maven打包命令实现。 ### 回答3： Maven是一种流行的项目构建工具，可以帮助开发人员自动化构建和管理Java项目。而WAR包是一种用于部署Java Web应用程序的标准文件格式。通过将Maven项目打包成WAR包，可以将项目部署到各种Web容器中，如Tomcat、Jetty和WebSphere等。 下面是如何将Maven项目打包成WAR包的简单步骤： 1. 配置Maven插件 Maven有一个称为Maven WAR插件的插件，用于打包WAR文件。要在项目中使用此插件，请在项目的pom.xml文件中添加以下配置： <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <version>3.2.3</version> <configuration> <warSourceDirectory>src/main/webapp</warSourceDirectory> </configuration> </plugin> </plugins> </build> 2. 构建项目 现在可以运行Maven命令来构建项目。在项目目录中打开命令行窗口，然后键入以下命令： mvn clean package 这将使用Maven构建项目并在目标目录中生成WAR文件。 3. 部署WAR包 生成的WAR文件现在可以在任何支持Java Web程序部署的Web容器中部署。 将WAR文件复制到Web容器的webapps目录下，然后启动Web容器。 WAR文件将自动展开并成为Web应用程序。 以上就是将Maven项目打包成WAR包的简单步骤。这使得开发人员更容易将项目部署到Web容器中。Maven的模块和依赖项管理功能也可以更好地帮助开发人员管理复杂的Java项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值