精华内容
下载资源
问答
  • maven项目打包的方式
    千次阅读
    2018-03-14 15:31:43

    小功能,做个笔记。

    由于项目需要,把IDEA的maven项目转为普通的java项目,然后问题出来了,项目代码很好弄,直接重构就好,但是maven中的依赖怎么导出来呢。

    本来是打算在本地仓库中通过项目的libraries一个一个找的,后来想想工作量太大,还是算了。

    最后才发现maven有相关的命令。

    直接进入项目pom.xml所在的目录,输入命令:

    mvn dependency:copy-dependencies -DoutputDirectory=lib

    lib是依赖包输出的目录。

    完成。

    既然都说到maven了,就整理一下maven打包的方法。

    Maven可以使用mvn package指令对项目进行打包,如果使用Java -jar xxx.jar执行运行jar文件,会出现”no main manifest attribute, in xxx.jar”(没有设置Main-Class)、ClassNotFoundException(找不到依赖包)等错误。

    要想jar包能直接通过java -jar xxx.jar运行,需要满足:

    1. 在jar包中的META-INF/MANIFEST.MF中指定Main-Class,这样才能确定程序的入口在哪里
    2. Jar包中一起打入了依赖包。

    1. 使用maven-jar-plugin和maven-dependency-plugin插件打包

    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-jar-plugin</artifactId>  
                <version>2.6</version>  
                <configuration>  
                    <archive>  
                        <manifest>  
                            <addClasspath>true</addClasspath>  
                            <classpathPrefix>lib/</classpathPrefix>  
                            <mainClass>com.xxg.Main</mainClass>  
                        </manifest>  
                    </archive>  
                </configuration>  
            </plugin>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-dependency-plugin</artifactId>  
                <version>2.10</version>  
                <executions>  
                    <execution>  
                        <id>copy-dependencies</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>copy-dependencies</goal>  
                        </goals>  
                        <configuration>  
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>  
                        </configuration>  
                    </execution>  
                </executions>  
            </plugin>  
    
        </plugins>  
    </build>  

    maven-jar-plugin用于生成META-INF/MANIFEST.MF文件的部分内容,com.xxg.Main指定MANIFEST.MF中的Main-Class,true会在MANIFEST.MF加上Class-Path项并配置依赖包,lib/指定依赖包所在目录。

    只是生成MANIFEST.MF文件还不够,maven-dependency-plugin插件用于将依赖包拷贝到${project.build.directory}/lib指定的位置,即lib目录下。

    配置完成后,通过mvn package指令打包,会在target目录下生成jar包,并将依赖包拷贝到target/lib目录下,目录结构如下:

    指定了Main-Class,有了依赖包,那么就可以直接通过java -jar xxx.jar运行jar包。

    这种方式生成jar包有个缺点,就是生成的jar包太多不便于管理,下面两种方式只生成一个jar文件,包含项目本身的代码、资源以及所有的依赖包。

    2. 使用maven-assembly-plugin插件打包

    <build>  
        <plugins>  
    
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-assembly-plugin</artifactId>  
                <version>2.5.5</version>  
                <configuration>  
                    <archive>  
                        <manifest>  
                            <mainClass>com.xxg.Main</mainClass>  
                        </manifest>  
                    </archive>  
                    <descriptorRefs>  
                        <descriptorRef>jar-with-dependencies</descriptorRef>  
                    </descriptorRefs>  
                </configuration>  
            </plugin>  
    
        </plugins>  
    </build>  

    打包命令:

    mvn package assembly:single

    打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件,这个文件不但包含了自己项目中的代码和资源,还包含了所有依赖包的内容。所以可以直接通过java -jar来运行。

    3. 使用maven-shade-plugin插件打包

    <build>  
        <plugins>  
    
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-shade-plugin</artifactId>  
                <version>2.4.1</version>  
                <executions>  
                    <execution>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>shade</goal>  
                        </goals>  
                        <configuration>  
                            <transformers>  
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                                    <mainClass>com.xxg.Main</mainClass>  
                                </transformer>  
                            </transformers>  
                        </configuration>  
                    </execution>  
                </executions>  
            </plugin>  
    
        </plugins>  
    </build>  

    配置完成后,执行mvn package即可打包。在target目录下会生成两个jar包,注意不是original-xxx.jar文件,而是另外一个。和maven-assembly-plugin一样,生成的jar文件包含了所有依赖,所以可以直接运行。

    参考链接:
    http://blog.csdn.net/daiyutage/article/details/53739452

    更多相关内容
  • 方式一: 直接打包,不打包依赖包,仅打包出项目中的...一个是全包(将maven项目中的依赖包和项目打为一个包 。) 一般都会选择方式二进行打包,这样可以直接在其他应用中调用 maven——》Plugins——》assembly——

    方式一:

    • 直接打包,不打包依赖包,仅打包出项目中的代码到JAR包中,可称为架包。在其他应用中运行时,必须保证其上面有相应的依赖包,才能运行。
    • maven——》Lifecyle——》Clean——》Package

    在这里插入图片描述

    • 打包成功后就会出现target文件夹

    在这里插入图片描述
    在这里插入图片描述

    方式二:

    • 打包两个jar包:
    • 一个是架包(只包含程序包即方式一打的包
    • 一个是全包(将maven项目中的依赖包和项目打为一个包 。)
    • 一般都会选择方式二进行打包,这样可以直接在其他应用中调用
    • maven——》Plugins——》assembly——》assembly:assembly

    在这里插入图片描述

    • 打包成功后就会出现target文件夹:包括两个jar包
    • 较长的名字就是含有依赖包的jar包

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Maven打包方式

    万次阅读 2021-08-24 00:23:54
    一、前言 刚开始实习不到一个月的时候,从师兄手中接手了团队的项目,当时第一次听到了 “大包”、“小包” 的概念,只见师兄一顿操作,使用 ...下面将从这两类来讲解使用 Maven项目打包方式。 二、将项目打为小包

    一、前言

    刚开始实习不到一个月的时候,从师兄手中接手了团队的项目,当时第一次听到了 “大包”、“小包” 的概念,只见师兄一顿操作,使用 Maven 将项目进行了打包。当时不太理解,只是记得两点:

    1. 如果想让项目作为一个依赖提供给他人使用,则将项目打为 “小包”
    2. 如果希望项目打出来 Jar 包可以作为一个独立服务运行,则将项目打为 “大包”

    也就是说,可以将项目打包为两类:一类是作为依赖提供给他人使用,一类是作为独立服务使用。

    下面将从这两类来讲解使用 Maven 将项目打包的方式。

    二、将项目打为小包

    所谓打包为 “小包”,其实就是仅打包项目中的代码到 JAR 包中,不打包依赖包

    将项目打包为 “小包” 的做法很简单,就是在 pom.xml 文件中的 plugins 标签给注释掉即可,也就是不做任何打包插件的配置。如下图所示:

    <build>
        <!-- 项目最终打包成的名字 -->
        <finalName>community</finalName>
    </build>
    

    然后执行打包命令:

    # 先执行 clean,再执行 package,并且跳过测试用例的执行
    mvn clean package -Dmaven.test.skip=true
    

    最后,会在当前项目的 target 目录生成一个 “小包”:

    在这里插入图片描述

    使用反编译工具查看 Jar 包具体内容:

    在这里插入图片描述

    从 Jar 包内容可以看出来,项目的依赖都以 Maven 依赖的形式保存在了 pom.xml 文件中,源码的部分只有项目本身的代码。这种 Jar 包就是所谓的 “小包”。

    三、将项目打包为大包

    如果想要打包后的 Jar 包能够作为一个独立服务运行,必须满足以下两点:

    1. 在 Jar 包中的 META-INF/MANIFEST.MF 中指定 Main-Class,这样才能确定程序的入口在哪里;

    2. 要能加载到依赖包。

    所以我们将项目打包为大包的中心思想也就是实现上面两点。使用 Maven 将项目打包为大包的方式就比较多了。主要有以下三种方式:

    • 方法一:使用 maven-jar-pluginmaven-dependency-plugin 插件
    • 方法二:使用 maven-assembly-plugin 插件
    • 方法三:使用 maven-shade-plugin 插件

    注意:对于 SpringBoot 项目,在初始的 pom.xml 文件中就提供了 spring-boot-maven-plugin 插件用于将项目打包为可执行 Jar 包,不建议再使用其他任何插件(包括下面的三种插件)打包。

    方法一:使用 maven-jar-pluginmaven-dependency-plugin 插件

    此种打包方式有一个比较明显的缺点:打包后会在 target 目录下生成 lib 目录(存放依赖 Jar)和项目 Jar。也就是说由于依赖都存在于 lib 目录中,所以要想运行 Jar 包,必须将 Jar 包和 lib 目录放在同一个路径下。

    pom.xml 文件中关于打包的配置信息如下:

    <build>
        <!-- 项目最终打包成的名字 -->
        <finalName>community</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <!-- 会在 MANIFEST.MF 中生成 Class-Path 项 -->
                            <!-- 系统会根据 Class-Path 项配置的路径加载依赖 -->
                            <addClasspath>true</addClasspath>
                            <!-- 指定依赖包所在目录,相对于项目最终 Jar 包的路径 -->
                            <classpathPrefix>lib/</classpathPrefix>
                            <!-- 指定 MainClass -->
                            <mainClass>com.ronz.community.CommunityApplication</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
    
            <!-- 配置依赖包 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <!-- 相当于执行 mvn 命令,将依赖打包到指定目录 -->
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!--将依赖打包至 target 下的 lib 目录-->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    

    这个思想也比较简单。

    首先说 maven-jar-plugin 插件,它的思想就是:指定启动类、指定依赖包相对于项目最终 Jar 包所在的路径、给 MANIFEST.MF 文件添加 Class-Path 属性(运行项目 Jar 包时会根据 Class-Path 属性来找到具体依赖 Jar 包的路径)。

    接着是 maven-dependency-plugin 插件,它的主要思想就是:指定所有依赖被打包为 Jar 包后的存放路径。

    pom.xml 文件配置完毕之后,就可以运行打包命令了:

    # 跳过测试用例执行 package 命令
    mvn package -Dmaven.test.skip=true
    

    打包完成后,会在项目的 target 目录下生成 lib 文件夹(存放项目的所有依赖)和项目的 Jar 包:

    在这里插入图片描述

    为了增强对这种方法的认识,通过反编译工具查看编译后生成的 community.jar 包,其内容如下:

    在这里插入图片描述

    可以看到,在 MANIFEST.MF 文件中生成了 Class-Path 属性,该属性的值是当前项目的所有依赖 Jar 包的路径(即 lib 目录中的 Jar 包);当然还有 MainClass 属性,由于图片尺寸的原因,没有截到。

    这种方式打包出来的 Jar 包,在代码层面只包含了项目本身的代码。而项目的依赖都以 Jar 包的形式放在了项目 Jar 包同级别目录下的 lib 目录中,这些依赖 Jar 包的路径在 MANIFEST.MF 文件中都以路径的方式指明了。

    方法二:使用 maven-assembly-plugin 插件

    使用 maven-assembly-plugin 插件打出来的包只有一个 Jar 包,这个 Jar 包中包含了项目代码以及依赖的代码。也就意味着此种方式打出来的 Jar 包可以直接通过 java -jar xxx.jar 的命令来运行。

    pom.xml 文件中关于打包的配置信息如下:

        <build>
            <!-- 项目最终打包成的名字 -->
            <finalName>community</finalName>
    
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <configuration>
                        <archive>
                            <!-- 指定启动类 -->
                            <manifest>
                                <mainClass>com.ronz.community.CommunityApplication</mainClass>
                            </manifest>
                        </archive>
                        <!-- 指定启动类 -->
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
    
                    <!-- 相当于在执行 package 打包时,在后面加上 assembly:single  -->
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
            </plugins>
        </build>
    

    这个插件的使用思想也比较简单:首先还是指定启动类;然后配置描述符参数,这个是插件提供的预置参数,不用更改;接下来就是打包时追加的命令了。

    然后执行 Maven 打包命令:

    # 先后执行 clean、package,并跳过测试文件的执行
    mvn clean package -Dmaven.test.skip=true
    

    打包完成之后,会在 target 目录下生成一个 Jar 包:

    在这里插入图片描述

    使用反编译工具查看 Jar 包:

    在这里插入图片描述

    从上图中可以清楚的看到:项目的所有依赖都以源码文件的形式整合在了一起

    方法三:使用 maven-shade-plugin 插件(推荐使用)

    根据 Maven 的官方文档介绍,maven-shade-plugin 是一个强大的打包插件。它同样可以将项目的依赖以及项目的源码打包成一个可执行 Jar 包

    pom.xml 文件中关于打包的配置信息如下:

    <build>
        <!-- 项目最终打包成的名字 -->
        <finalName>community</finalName>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <!-- 指定启动类 -->
                                <transformer
                       implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.ronz.community.CommunityApplication</mainClass>
                                </transformer>
                                
                                <!-- 下面的配置仅针对存在同名资源文件的情况,如没有则不用配置-->
                                <!-- 有些项目包可能会包含同文件名的资源文件(例如属性文件)-->
                                <!-- 为避免覆盖,可以将它们的内容合并到一个文件中 -->
                                <transformer
                       implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.handlers</resource>
                                </transformer>
                                <transformer
                       implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.schemas</resource>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    

    这个配置思想很简单:首先指定执行 package 命令时附加命令,这个是固定的,不需要改变;接下来就是指定项目的启动类;然后就是配置一个文件合并操作,主要是因为有的项目可能会有重名的资源文件,为了避免前面的资源文件被后面的覆盖掉,可以将重名的配置文件合并为一个文件,对于无重名资源文件的项目则无需配置。

    执行 Maven 打包命令:

    # 先后执行 clean、package,并跳过测试文件的执行
    mvn clean package -Dmaven.test.skip=true
    

    打包完成之后,会在 target 目录下生成一个 Jar 包,此 Jar 包中也是将项目依赖的源码包含进来了,可以通过 java -jar xxx.jar 命令直接运行 Jar 包。

    四、总结

    经过我的实际测试, 使用第二种方式的 assembly 打包出来的 Jar 包多多少少有些问题,但是使用第三种方式打包出来的 Jar 包一般都是可用的。所以在将项目打包为大包时,还是推荐使用第三种打包的方式

    参考

    展开全文
  • maven项目打包部署

    2022-03-27 18:27:06
    maven项目打包 1.pom文件配置将项目打包成jar包 2.打包时跳过测试,执行指令:mvn install -DskipTests 3.运行项目:java -jar guns.jar

    maven项目打包

    1.pom文件配置将项目打包成jar包
    在这里插入图片描述
    2.打包时跳过测试,执行指令:mvn install -DskipTests
    在这里插入图片描述
    3.运行项目:java -jar guns.jar
    在这里插入图片描述

    展开全文
  • MAVEN的三种打包方式

    千次阅读 2021-04-24 20:39:08
    MAVEN的三种打包方式 Maven可以使用mvn package指令对项目进行打包,如果使用Java -jar xxx.jar执行运行jar文件,会出现"no main manifest attribute, in xxx.jar"(没有设置Main-Class)、ClassNotFoundException...
  • Maven有三种打包方式,分别为: assembly:自定义的打包结构,也可以定制依赖项等; jar:默认的打包方式,用来打普通的project JAR包; shade:用来打可执行jar包,也就是所谓的fat JAR包。 下面来讲解下这三种的...
  • 1方式一:使用project structure---artifacts,但我的springboot使用...2方式二:使用maven命令:可以直接在idea的terminal出执行mvn clean package -DskipTests=true 或者在cmd到pom.xml的目录下执行mvn命令 jar所...
  • Maven项目的简单打包

    千次阅读 2022-04-21 10:33:20
    首先是在maven项目的pom.xml中添加打包的插件,这里有很多种方式的。最最简单的就是只使用maven-compiler-plugin、maven-jar-plugin插件,并且指定程序入口。相关代码如下: pom.xml文件: <?xml version="1.0" ...
  • maven项目打包成war包并部署到tomcat上

    千次阅读 2022-05-26 16:52:09
    maven项目打包成war包并完成部署
  • Eclipse Maven 项目打包(Win 10)

    千次阅读 2021-08-12 14:57:53
    我尝试手动打包项目,结果运行报错,然后我用插件FatJar打包项目,运行又出了其他错误。 后来,我百度找到了一个办法,一个简单的命令就解决了。 mvn clean install -Dmaven.test.skip 参考文章链接:...
  • Eclipse中对maven项目进行打包

    千次阅读 2022-06-02 14:17:46
    在Eclipse中对maven项目进行打包
  • maven项目如何打包

    千次阅读 2020-06-07 16:07:01
    (1)胖包:将maven项目中的依赖包和项目打为一个包 。 (2)瘦包:直接打包,不打包依赖包,仅打包出项目中的代码到JAR包中。 1.打瘦包 2.打胖包 第一种:只打胖包 快捷键:Alt+shirt+ctrl+s 定入口函数和胖包的...
  • IDEA MAVEN项目打包成jar包的多种方式 准备了两个打包方法 1.IEDA自带打包方法 2.用Maven插件maven-shade-plugin打包 IDEA自带打包 适用于任何打包,稍微麻烦一点。 打开IDEA项目 file -> Project Structure ...
  • Maven项目打包为jar的几种方式

    万次阅读 多人点赞 2017-10-28 23:15:48
    Maven项目打包为jar的几种方式 这里收集整理下以往打包MAVEN项目为JAR包的各种方式 直接打包,不打包依赖包 直接打包,不打包依赖包,仅打包出项目中的代码到JAR包中。在POM中添加如下plugin即可,随后执行...
  • 使用eclipse打包Maven项目

    千次阅读 2022-03-28 20:47:42
    Maven中最重要的是POM文件,其打包也是基于该文件的,在POM文件中配置插件,可以实现将Maven项目打包成可执行jar包 依赖如下: <build> <plugins> <!-- 将项目打包成可执行jar包 --> <...
  • Maven项目打包后使用cmd命令运行

    千次阅读 2021-08-12 14:31:27
    Maven项目打包我们使用的是在pom.xml中插件的配置,然后再Idea中打包成jar包 在Pom.xml中添加插件配置 项目打包插件 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins...
  • Maven项目命令行打包及运行

    千次阅读 2021-07-08 09:39:37
    Maven项目打成jar包 1、打开Windows命令窗口:Windows键+R 2、进入要打包项目的根目录 3、输入命令:mvn clean package 回车 4、打好的jar在项目下的 target文件下 5、运行jar包
  • idea打包非maven项目打包war包

    千次阅读 2019-04-19 22:47:29
    选中项目结构,按F4 或者Ctrl+Shitf+Alt+S 接下来你会看到一个这个窗口点击Artifacts 然后点击头上的绿色加号 然后你会发现一个 没有命名的war格式,名字自己取吧(在Name那里改) 取好之后点击war格式选中 ...
  • 第一种 idea自身打包插件 这种方式输出目录在out目录下 第一步 如图所示 依次选择file-projecct structure-artifacts 选择 Artifacts 然后点击+ 选择jar 选择 from module with dependencies 第二步 红框部分可以...
  • maven项目打包部署到服务器上

    千次阅读 2020-09-03 15:49:13
    创建一个maven项目,在本地工程依赖jar包启动完成后,是不够的,还需将项目文件使用maven编译打包然后部署到服务器上 主流的springboot项目打包的时候需要在pom文件中指定主方法等配置 解决打包部署的时候报错no ...
  • SpringBoot - Maven方式打包

    千次阅读 2022-04-08 09:56:17
    我们现在可以直接将 SpringBoot 项目打包为一个内置 tomcat 的可运行 jar , 通过 java -jar xxx.jar 直接运行 (方便易用) 。 打包 SpringBoot 的方式有很多 使用 Maven打包 jar (主流) 使用各种开发工具打包Jar ....
  • Idea将maven项目打包成jar包

    千次阅读 2020-02-19 17:00:15
    第一步 pom.xml文件中设置如下 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-...
  • maven项目打包只有几K的原因

    千次阅读 2022-01-04 16:04:28
    maven项目package时, 右键项目maven build... 在goals中package, 然后选择Skip Tests打包, 结果查看jar包只有几K, 此原因是因为maven项目没有正确的build, 本地没有生成class文件。
  • maven命令行打包

    千次阅读 2021-12-10 15:03:41
    maven打包项目到远程仓库maven项目打包命令行maven打包本地资源文件夹使用命令行打包(maven)功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的...
  • 后端服务通过JAR方式运行 前端项目build的dist,部署到nginx 一、后台项目打jar包 切换配置为发布模式打包 修改pom.xml加上打包插件(如果有就不需要加) <build> <plugins> <plugin> &...
  • 问题如下:一、在进行Maven项目打包的时候,会发现有的项目会随机出现xml文件和配置文件没有打包进war。二、SpringBoot+Maven项目中,无法将自定义文件下jar包打包进项目。针对问题一如采用图中的目录结构如果java和...
  • 使用Maven打包项目到本地Maven仓库

    千次阅读 2022-05-09 11:57:00
    目录一、问题描述二、解决方法 一、问题描述 Maven 项目中引入了模块(Module)...使用以下命令将模块(Module)打包到本地 Maven 仓库,主项目打包时能自动找到对应的模块(Module)依赖包: mvn clean install ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,254
精华内容 55,301
关键字:

maven项目打包的方式