maven项目常用的打包方式

最新推荐文章于 2025-07-05 13:30:49 发布
最新推荐文章于 2025-07-05 13:30:49 发布
阅读量4.3w 收藏 66
点赞数 13
文章标签： maven jar
本文详细介绍如何使用Maven进行不同场景的项目打包，包括无依赖、包含依赖的单一jar包及适用于内部使用的zip包等，提供了丰富的配置示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、无依赖其他任何jar

<build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <version>2.4</version>  
                <configuration>  
                    <archive>  
                        <manifest>  
                            <addClasspath>true</addClasspath>  
                            <classpathPrefix>lib/</classpathPrefix>  
                            <mainClass>com.think.TestMain</mainClass>  
                        </manifest>  
                    </archive>  
                </configuration>  
            </plugin>  
        </plugins>  
    </build>

运行：mvn clean package，在target中找到打包出来的，命令后运行java -jar xxx.jar即可，但是如果程序有依赖其他包，比如程序依赖jdbc去查询db，这时候再执行就会出现找不到jdbc依赖，因为我们并没有将依赖包打进去

二、解决依赖其他包时，可执行jar的打包

1、

<build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-assembly-plugin</artifactId>  
                <version>2.3</version>  
                <configuration>  
                    <appendAssemblyId>false</appendAssemblyId>  
                    <descriptorRefs>  
                        <descriptorRef>jar-with-dependencies</descriptorRef>  
                    </descriptorRefs>  
                    <archive>  
                        <manifest>  
                            <mainClass>com.think.TestMain</mainClass>  
                        </manifest>  
                    </archive>  
                </configuration>  
                <executions>  
                    <execution>  
                        <id>make-assembly</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>assembly</goal>  
                        </goals>  
                    </execution>  
                </executions>  
            </plugin>  
        </plugins>  
    </build>

但以上方式用的比较少，因为我们依赖的jar，也会打进到我们最终生成的jar，这样不太好，假如你生成的jar要给别人使用，最好给一个纯净的。
一般用assembly会再用他另外一个功能，将我们的jar归档，打包成一个zip

2、打成一个zip包，发布项目的时候，将zip包copy到服务器上，直接unzip xxx.zip，里面包含要运行到jar以及依赖的lib，还有配置的config文件，即可直接启动服务

<build>  
        <resources>  
            <!-- 控制资源文件的拷贝 -->  
            <resource>  
                <directory>src/main/resources</directory>  
                <targetPath>${project.build.directory}/classes</targetPath>  
            </resource>  
        </resources>  
        <plugins>  
            <!-- 设置源文件编码方式 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <configuration>  
                    <source>1.6</source>  
                    <target>1.6</target>  
                    <encoding>UTF-8</encoding>  
                </configuration>  
            </plugin>  
            <!-- The configuration of maven-jar-plugin -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <version>2.4</version>  
                <!-- The configuration of the plugin -->  
                <configuration>  
                    <!-- Configuration of the archiver -->  
                    <archive>  

                        <!-- 
                            生成的jar中，不要包含pom.xml和pom.properties这两个文件 
                        -->  
                        <addMavenDescriptor>false</addMavenDescriptor>  

                        <!-- Manifest specific configuration -->  
                        <manifest>  
                            <!-- 
                                是否要把第三方jar放到manifest的classpath中 
                            -->  
                            <addClasspath>true</addClasspath>  
                            <!-- 
                               生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/ 
                           -->  
                            <classpathPrefix>lib/</classpathPrefix>  
                            <!-- 
                                应用的main class 
                            -->  
                            <mainClass>com.think.TestMain</mainClass>  
                        </manifest>  
                    </archive>  
                    <!-- 
                        过滤掉不希望包含在jar中的文件 
                    -->  
                    <!--<excludes>-->  
                        <!--<exclude>${project.basedir}/xml/*</exclude>-->  
                    <!--</excludes>-->  
                </configuration>  
            </plugin>  

            <!-- The configuration of maven-assembly-plugin -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-assembly-plugin</artifactId>  
                <version>2.4</version>  
                <!-- The configuration of the plugin -->  
                <configuration>  
                    <!-- Specifies the configuration file of the assembly plugin -->  
                    <descriptors>  
                        <descriptor>src/main/assembly/assembly.xml</descriptor>  
                    </descriptors>  
                </configuration>  
                <executions>  
                    <execution>  
                        <id>make-assembly</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>single</goal>  
                        </goals>  
                    </execution>  
                </executions>  
            </plugin>  
        </plugins>  
    </build>

还有一个重要的文件，名字可以随便起，我上面用的是 src/main/assembly/assembly.xml

<assembly>  
    <id>bin</id>  
    <includeBaseDirectory>false</includeBaseDirectory>  
    <!-- 最终打包成一个用于发布的zip文件 -->  
    <formats>  
        <format>zip</format>  
    </formats>  

    <!-- Adds dependencies to zip package under lib directory -->  
    <dependencySets>  
        <dependencySet>  
            <!-- 
               不使用项目的artifact，第三方jar不要解压，打包进zip文件的lib目录 
           -->  
            <useProjectArtifact>false</useProjectArtifact>  
            <!--<outputDirectory>lib</outputDirectory>-->  
            <unpack>false</unpack>  
        </dependencySet>  
    </dependencySets>  

    <fileSets>  
        <!-- 把项目相关的说明文件，打包进zip文件的根目录 -->  
        <!--<fileSet>-->  
            <!--<directory>${project.basedir}</directory>-->  
            <!--<outputDirectory>/</outputDirectory>-->  
        <!--</fileSet>-->  

        <!-- 把项目的配置文件，打包进zip文件的config目录 -->  
        <fileSet>  
            <directory>${deploy.dir}/classes/</directory>  
            <outputDirectory>/conf</outputDirectory>  
            <includes>  
                <include>*.xml</include>  
                <include>*.properties</include>  
            </includes>  
        </fileSet>  
        <!-- 把项目自己编译出来的jar文件，打包进zip文件的根目录 -->  
        <fileSet>  
            <directory>${project.build.directory}</directory>  
            <outputDirectory></outputDirectory>  
            <includes>  
                <include>*.jar</include>  
            </includes>  
        </fileSet>  
    </fileSets>  
</assembly>

最终执行命令：mvn clean package，出来的是这样的
这里写图片描述
这里写图片描述
解压zip包，我们看到我们想要的，good

3、还有一种打包方式，上面相当于把我们想要的东西打成一个zip包，全部放到一起，看着整洁好看，但有点繁琐，我们其实可以用另外一个插件来完成，不打包，即看到上图解压后的文件

[html] view plain copy
<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.test</groupId>  
    <artifactId>myTestJar</artifactId>  
    <version>1.0-SNAPSHOT</version>  
    <packaging>jar</packaging>  

    <name>myTestJar</name>  
    <url>http://maven.apache.org</url>  

    <properties>  
        <deploy.dir>./target/</deploy.dir>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    </properties>  

    <dependencies>  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>3.8.1</version>  
            <scope>test</scope>  
        </dependency>  

        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>druid</artifactId>  
            <version>1.0.9</version>  
        </dependency>  

        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.32</version>  
        </dependency>  
    </dependencies>  

    <build>  
        <finalName>myTest</finalName>  
        <sourceDirectory>src/main/java</sourceDirectory>  
        <resources>  
            <!-- 控制资源文件的拷贝 -->  
            <resource>  
                <directory>src/main/resources</directory>  
                <targetPath>${project.build.directory}</targetPath>  
            </resource>  
        </resources>  
        <plugins>  
            <!-- 设置源文件编码方式 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <configuration>  
                    <defaultLibBundleDir>lib</defaultLibBundleDir>  
                    <source>1.6</source>  
                    <target>1.6</target>  
                    <encoding>UTF-8</encoding>  
                </configuration>  
            </plugin>  
            <!-- 打包jar文件时，配置manifest文件，加入lib包的jar依赖 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <configuration>  
                    <archive>  
                        <manifest>  
                            <addClasspath>true</addClasspath>  
                            <classpathPrefix>lib/</classpathPrefix>  
                            <mainClass>com.think.TestMain</mainClass>  
                        </manifest>  
                    </archive>  
                </configuration>  
            </plugin>  
            <!-- 拷贝依赖的jar包到lib目录 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-dependency-plugin</artifactId>  
                <executions>  
                    <execution>  
                        <id>copy</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>copy-dependencies</goal>  
                        </goals>  
                        <configuration>  
                            <!-- ${project.build.directory}是maven变量，内置的，表示target目录,如果不写，将在跟目录下创建/lib -->  
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>  
                            <!-- excludeTransitive:是否不包含间接依赖包，比如我们依赖A，但是A又依赖了B，我们是否也要把B打进去 默认不打-->  
                            <excludeTransitive>true</excludeTransitive>  
                            <!-- 复制的jar文件去掉版本信息 -->  
                            <stripVersion>true</stripVersion>  
                        </configuration>  
                    </execution>  
                </executions>  
            </plugin>  
            <!-- 解决资源文件的编码问题 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-resources-plugin</artifactId>  
                <version>2.3</version>  
                <configuration>  
                    <encoding>UTF-8</encoding>  
                </configuration>  
            </plugin>  
            <!-- 打包source文件为jar文件 -->  
            <plugin>  
                <artifactId>maven-source-plugin</artifactId>  
                <version>2.1</version>  
                <configuration>  
                    <attach>true</attach>  
                    <encoding>UTF-8</encoding>  
                </configuration>  
                <executions>  
                    <execution>  
                        <phase>compile</phase>  
                        <goals>  
                            <goal>jar</goal>  
                        </goals>  
                    </execution>  
                </executions>  
            </plugin>  
        </plugins>  
    </build>  

</project>

这里采用的是maven-dependency-plugin插件，进行资源的copy。
4、

<build>  
        <resources>  
            <resource>  
                <targetPath>${project.build.directory}/classes</targetPath>  
                <directory>src/main/resources</directory>  
                <filtering>true</filtering>  
                <includes>  
                    <include>**/*.xml</include>  
                </includes>  
            </resource>  
        </resources>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <version>3.0</version>  
                <configuration>  
                    <source>1.6</source>  
                    <target>1.6</target>  
                    <encoding>UTF-8</encoding>  
                </configuration>  
            </plugin>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-shade-plugin</artifactId>  
                <version>2.0</version>  
                <executions>  
                    <execution>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>shade</goal>  
                        </goals>  
                        <configuration>  
                            <transformers>  
                                <transformer  
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                    <mainClass>com.think.TestMain</mainClass>  
                                </transformer>  
                                <!--<transformer-->  
                                        <!--implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">-->  
                                    <!--<resource>applicationContext.xml</resource>-->  
                                <!--</transformer>-->  
                            </transformers>  
                            <shadedArtifactAttached>true</shadedArtifactAttached>  
                            <shadedClassifierName>executable</shadedClassifierName>  
                        </configuration>  
                    </execution>  
                </executions>  
            </plugin>  
        </plugins>  
    </build>

这种方式打出来是柔和到一起，成为一个jar，

这里写图片描述
可以直接java -jar xxx.jar运行。

我们可以根据不同需要来打包，如果暴露给外面，可以采用第4种，如果是自己公司项目打包，建议2，3种，因为有时候只是改了个配置文件，不需要打包，直接把配置文件复制进去即可

qq_16055765
关注
Maven 三种项目打包方式：POM、JAR 和 WAR 的区别详解
fudaihb的博客
10-09 2513
在 Java 项目开发中，Maven 是一个广泛使用的构建工具。它提供了标准的项目结构、依赖管理和打包机制，帮助开发者轻松管理复杂的 Java 项目。在 Maven 中，项目的打包方式有多种，常见的有 `pom`、`jar` 和 `war` 三种打包类型。每种打包类型都有其独特的用途和场景，理解它们的区别有助于我们选择最适合当前项目的打包方式。 本文将详细介绍 Maven 中这三种项目打包方式的区别及其应用场景，帮助你深入理解如何根据项目需求选择合适的打包方式。
Maven常用的编译、打包方式总结
石榴姐yyds
09-30 3830
在提交大数据作业到集群上运行时，通常需要先将项目打成 JAR 包。这里以 Maven 为例，常用打包方式如下： 不加任何插件，直接使用 mvn package 打包； 使用 maven-assembly-plugin 插件； 使用 maven-shade-plugin 插件； 使用 maven-jar-plugin 和 maven-dependency-plugin 插件； 以下分别进行详细的说明。
maven项目打包
06-20
java　maven项目打包
Maven-项目打包
qk
04-21 184
依赖关系对安装顺序的要求 A依赖B Maven要求先安装B，再安装A 继承关系对安装顺序的要求 A（子工程）继承B（父工程） Maven要求先安装B，再安装A 如果配置聚合，那么对聚合工程执行install，Maven就会按照正确的顺序安装各个模块工程 ...
Maven项目管理
2302_79585857的博客
07-05 743
对第三方依赖包的管理，可以连接互联网下载项目所需第三方jar包。对自己开发的模块的管理，可以像引用第三方依赖包一样引用自己项目的依赖包。项目构建：是一个从编写源代码到编译、测试、运行、打包、部署的过程。传统项目和maven项目构建的两种方式传统项目：打开Idea编写源代码和配置文件，对源代码进行编译，可以使用Junit进行单元测试，把项目打成war包，部署到Tomcat服务器中运行。maven项目：maven将项目构建过程进行标准化，每个阶段都可以使用一个命令来完成。
Maven 项目打包需要注意到的那点事儿
Just Do It!
05-27 1628
1. 关于 Maven 打 war 包 《使用 Eclipse 的 Maven 2 插件开发一个 JEE 项目》详细介绍了如何在 Eclipse 使用 Maven 新建一个 JEE 项目并对其进行断点跟踪调试，但是没有介绍如何对 JEE 项目打 war 包。其实很简单，你只需要把 pom.xml 中的 jar 换成 war 就可以使用 mvn package 命令对其打 war 包了，而
Maven 项目打包发布
热门推荐
彭香香的专栏
03-24 6万+
<br />今天同事教我如何打包发布由Maven管理的项目，在此简约记录，以免忘记，嘎嘎。<br /> <br />发布的第一件要做的事情是打包。<br /> 在Eclipse左侧右击项目，Debug As -> Debug Configurations -> 双击Maven Build 然后看弹出框的右侧<br /> 右侧的Name随便填写一个名字，<br /> Basedirectory 则选择项目路径<br /> Goals是Maven文档里会有说明的目标动作，一般填"clean instal
Maven项目打包
weixin_47120348的博客
05-15 1145
在做项目时，都会在做项目的打包操作的，不同的环境下有不同的打包方式，在maven项目中可以使用pom.xml配置文件中实现配置， 首先要创建一个web项目 先说一下打包成war包吧 - 创建好项目后，需要配置pom.xml配置文件来指定打包插件要打包的那些东西 如果不指定打包的配置文件位置的话，默认只会打包resources目录下的 需要注意是可以会有不同的配置文件指定不同的环境，开发配置文件设置开发环境，test环境有测试的配置文件，所有在打包时只选择一种坏境下的配置文件就可以了 先说一下指定打包命令.
maven打包的5种方式总有一款适合你【超赞】
健康平安的活着的专栏
08-07 5万+
1.用于生成META-INF/MANIFEST.MF文件的部分内容，com.xxg.Main指定MANIFEST.MF中的Main-Class，true会在MANIFEST.MF加上Class-Path项并配置依赖包，lib/指定依赖包所在目录。2.maven-dependency-plugin插件。
maven常用命令
11-09
Maven 提供了多种方式来创建项目，以下是其中的一些： 1. 创建 Maven 的普通 Java 项目：`mvn archetype:create -DgroupId=packageName -DartifactId=projectName` 2. 创建 Maven 的 Web 项目：`mvn archetype:...
springboot(web项目，非maven)
09-18
Spring Boot简化了Java Web应用的开发过程，提供了快速构建可运行的应用程序的方式，而Maven则是一个流行的项目管理和依赖管理工具。在这里，我们可能假设开发者选择了Gradle或者其他构建工具替代Maven。 Spring ...
maven项目手动打包方式
最新发布
07-18
<think>首先，用户的问题是：“Maven项目如何手动执行打包命令”。这是一个关于Maven项目的手动打包操作的问题。 我需要参考提供的引用内容来构建回答。引用包括： - [^1]: 介绍Maven命令的重要性，以及如何通过命令行操作。 - [^2]: 描述如何手动引入本地JAR包使用Maven命令。 - [^3]: 直接给出Maven打包命令，跳过测试。 - [^4]: 讨论Maven打包命令和pom.xml配置。 - [^5]: 展示创建Maven项目并打包的命令。 用户的问题核心是手动执行打包命令，所以我应该聚焦在如何通过命令行执行Maven打包。 关键步骤： 1. **确保Maven已安装并配置**：用户需要确认Maven已安装，并且环境变量已设置，以便在命令行中使用`mvn`命令。如果没有，用户需要进入Maven安装目录的bin文件夹执行命令。 2. **导航到项目目录**：用户需要打开命令行（如CMD或终端），并导航到Maven项目的根目录，即包含pom.xml文件的目录。 3. **执行打包命令**：基本的打包命令是`mvn package`。这会在target目录下生成JAR或WAR文件。 - 如果用户想跳过测试，可以使用`mvn package -Dmaven.skip.test=true`，如引用[^3]所示。 4. **其他选项**：用户可能想指定其他参数，如跳过测试、指定环境等。 回答结构应该清晰： - 介绍手动打包的必要性。 - 分步说明如何执行。 - 提供示例命令。 - 解释常见选项。 - 最后，生成相关问题。 使用中文回答，因为系统指令要求中文。 确保格式正确：行内数学表达式用$...$，独立公式用$$...$$，但这里可能不需要数学表达式，所以重点在文本和代码块。 在回答中引用相关段落末尾添加引用标识。 现在，构建回答： 1. **开头**：简要解释手动打包命令的作用。 2. **步骤**： - 检查Maven安装。 - 导航到项目目录。 - 执行打包命令。 - 处理常见问题，如跳过测试。 3. **代码示例**：使用代码块展示命令。 4. **结尾**：添加相关问题。 引用： - 当提到Maven命令的重要性时，引用[^1]。 - 当提到跳过测试的选项时，引用[^3]。 - 当提到pom.xml配置时，引用[^4]。 生成相关问题： 1. 如何跳过测试执行Maven打包？ 2. Maven打包命令的其他常用选项有哪些？ 3. 如何查看Maven打包的输出文件位置？ 确保回答真实可靠，基于引用内容。</think>### Maven项目手动执行打包命令 在Maven项目中，手动执行打包命令是通过命令行操作实现的，这允许您在不依赖IDE图形界面的情况下生成JAR或WAR文件。打包过程依赖于Maven的生命周期命令，核心是`mvn package`命令。以下我将逐步说明如何操作，确保您能顺利完成打包。操作前，请确保Maven已正确安装并配置环境变量（否则需要进入Maven的bin目录执行命令）[^1]。 #### 步骤1: 检查Maven安装和配置 - **验证Maven是否可用**：打开命令行终端（如CMD、PowerShell或终端），输入以下命令检查Maven版本： ```bash mvn -v ``` 如果看到类似“Apache Maven X.X.X”的输出，表示Maven已配置好环境变量，可直接使用`mvn`命令[^2]。如果报错“mvn不是内部或外部命令”，说明环境变量未设置，您需要： - 进入Maven安装目录的bin文件夹（例如`C:\Program Files\apache-maven-3.8.4\bin`）。 - 在该目录下执行命令（例如Windows：`.\mvn -v`）。 #### 步骤2: 导航到Maven项目目录 - 在命令行中，使用`cd`命令切换到您的Maven项目根目录。该目录必须包含`pom.xml`文件（项目配置文件）。例如： ```bash cd C:\Users\YourName\project-root ``` 这里的`project-root`是您的项目文件夹，确保`pom.xml`存在于此目录。 #### 步骤3: 执行打包命令 - **基本打包命令**：输入以下命令执行打包： ```bash mvn package ``` 此命令会： - 编译源代码。 - 运行测试（默认）。 - 在`target`目录下生成打包文件（如JAR文件）。 - **跳过测试的打包命令**：如果测试失败或想加速打包过程，可以跳过测试阶段。使用`-Dmaven.skip.test=true`参数： ```bash mvn package -Dmaven.skip.test=true ``` 这能避免因测试不通过而中断打包，适用于开发环境[^3]。 #### 步骤4: 检查打包结果 - 打包完成后，在项目的`target`目录下查找输出文件： - 标准Java项目：生成`your-project-name-version.jar`。 - Web项目：生成`your-project-name-version.war`。 - 您可以通过命令行列出文件验证： ```bash dir target # Windows ls target # Linux/macOS ``` #### 常见问题与优化 - **依赖问题**：如果打包失败，检查`pom.xml`是否配置了正确的依赖项。Maven会自动从远程仓库下载依赖，但手动引入本地JAR包时需使用`mvn install:install-file`命令[^2]。 - **性能优化**：添加`-T 1C`参数可启用多线程打包（例如`mvn package -T 1C`），提高大项目速度。 - **环境指定**：使用`-P`参数激活不同配置文件（如开发或生产环境），例如`mvn package -P prod`。 手动打包命令是Maven的核心功能，通过命令行操作能更灵活地控制构建过程[^4]。如果您在操作中遇到问题，可参考Maven官方文档或分享具体错误信息。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值