精华内容
下载资源
问答
  • maven打包 maven打jar包详细步骤
  • org.apache.maven.plugins maven-jar-plugin true lib/ xx.xx.xx.xx <!-- 分离配置文件 *.** */*.xml
  • 本篇文章主要介绍了maven打包web项目时同时打包为war和jar文件的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了maven打包成第三方jar包且把pom依赖包打入进来的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • maven打包后,读取类路径下的配置文件,pom.xml配置,利用该配置可以成功读取类路径下相应的文件
  • 当前案例中包含一整套的代码和word文档,非常适合新手... 主要是通过maven打包加载不同环境的properties文件 然后将对于的属性绑定到指定的实体对象中;然后通过调用接口可以看到加载不同环境控制台打印的内容是不一样的
  • 当前案例中包含一整套的代码和word文档,非常适合新手代码简单易懂; 主要是通过maven打包配合springboot application.properties文件配置实现通过打包来完成加载不同环境的配置内容;
  • maven打包为zip,tar.gz

    2018-07-24 11:38:01
    非常实用的工具,将maven类java工程打包为zip格式、tar.gz格式,并且实现jar包 配置文件分离,方便部署。
  • 这是一个springboot+maven写的demo,主要演示springboot项目通过maven插件,将依赖与配置文件打包到jar包外部,实现灵活的项目管理.仅供参考学习
  • idea新建maven web项目.zip Jetbrains IntelliJ IDEA创建基于maven打包工具的WEB网站项目 本项目使用的是SSM框架spring mvc,spring, mybatis.用maven打包成jar
  • 自己整理的maven打包出现错误的解决办法、含有截图等 附带maven搭建私服等资料
  • allatori第二代Java代码混淆器Maven打包配置,依赖库,以及配置文件。示例运行,可行。
  • maven打包dubbo服务接口(maven-assembly-plugin)
  • maven打包使用yui压缩css和js文件
  • Maven打包,指定classes路径打包到WebContent/WEB-INF中
  • maven打包时打包指定的lib文件夹

    千次阅读 2019-10-31 19:15:29
    今天在打包自己的spring boot项目时遇到了问题, 报找不到类和符号。 因为我有些依赖是放在项目lib文件夹中,那么打包的时候要连把它一起打包。 修改pom.xml, 添加一下内容: <build> <plugins>...

    今天在打包自己的spring boot项目时遇到了问题, 报找不到类和符号。

    因为我有些依赖是放在项目lib文件夹中,那么打包的时候要连把它一起打包。

     

    修改pom.xml, 添加一下内容:

    <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <compilerArguments>
                            <extdirs>lib</extdirs>
                        </compilerArguments>
                    </configuration>
                </plugin>
            </plugins>
    
            <resources>
                <resource>
                    <directory>lib</directory>
                    <targetPath>BOOT-INF/lib/</targetPath>
                    <includes>
                        <include>**/*.jar</include>
                    </includes>
                </resource>
            </resources>
        </build>

     

    然后cmd切换到项目根路径执行打包命令:mvn clean package -Dmaven.test.skip=true

    打包后的jar包结构可以看到lib文件夹被整个打包进去了。

     

     

     

     

    展开全文
  • 关于maven打包时, 资源文件没有被打包进来的问题

    千次阅读 多人点赞 2021-03-23 13:05:45
    如果不加配置,用maven进行打包时,默认不会将src/main/java目录下的XML文件打包进去。因为src/main/java被设定为了源码目录,默认只会将其中的Java文件进行编译打包。 即,默认打包得到的结果如下 可以看到...

    问题起因

    在之前的一篇文章mybatis看这一篇就够了当中,提到过,在使用mybatis时,有时候需要把编写了SQL语句的XML文件,和Java文件放在同一个目录下,如

    如果不加配置,用maven进行打包时,默认不会将src/main/java目录下的XML文件打包进去。因为src/main/java被设定为了源码目录,默认只会将其中的Java文件进行编译打包。

    即,默认打包得到的结果如下

    可以看到com.example.mp.mappers包下没有XML文件

    我们可以配置pom.xml中的resources标签,指定打包时,加入src/main/java下面的XML文件,pom.xml如下

    <build>
        <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.xml</include>
                 </includes>
             </resource>
        </resources>
    </build>
    

    这样配置后,再次打包,src/main/java目录下的XML文件就会被打包进来了

    问题出现

    然而,今天在一个SpringBoot项目中测试mybatis-plus的demo时,发现,若pom.xml中增加了这一个自定义的resources标签配置,会覆盖掉默认的resources打包配置,使得src/main/resources目录下的文件无法打包进来,从而运行时因为缺少application.yml等资源文件而报错。

    假设我们有一个SpringBoot的项目,目录结构如下

    我们的pom.xml按照上面所说,配置了扫描src/main/java下面的XML文件。我们执行mvn clean package -DskipTests=true进行打包。

    根据maven的执行日志,看到maven的resources插件只打包了一个资源文件

    我们查看打包后的target目录

    可以看到,src/main/java下的XML文件被成功打包了进来。

    src/main/resources下的资源文件全都没有被打包进来

    此时运行该SpringBoot项目,因为缺失application.yml,找不到配置的数据源,而报错

    而如果我们在pom.xml中去掉resources标签的配置,即删掉

    <build>
        <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.xml</include>
                 </includes>
             </resource>
        </resources>
    </build>
    

    其他部分不变,再次打包

    maven执行的日志显示,maven资源插件打包了3个资源文件

    查看打包后的target目录

    src/main/resources目录下的资源文件被成功打包进来了。而由于没有配置,src/main/java下的XML文件就没有被打包。

    由此可知,默认情况下,maven打包会将资源目录(一般是src/main/resources)中的资源文件打包进去。

    如何查看项目的资源目录呢?

    IDEA左上角 File — Project Structure — Modules — 选中你的项目

    可以看到,蓝色的文件夹就是源代码目录,右下角带着像金币一样图标的文件夹,就是资源目录,而绿色的是测试代码目录。

    若要将某个目录设为资源目录,鼠标选中那个目录,在上方的Mark as那一行,点击Resources 即可。

    初步结论

    上面说到,maven默认会将资源目录下的资源文件进行打包,而如果在pom.xml中配置了resources标签,则默认的资源打包策略就被覆盖掉了,只会打包resources标签中配置的资源文件,所以,如果pom.xml中配置了

    <build>
        <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.xml</include>
                 </includes>
             </resource>
        </resources>
    </build>
    

    则只会打包该配置指定的目录,不会打包src/main/resources目录,即使它是项目的资源目录。

    这一点需要特别注意!!!需要特别注意!!!特别注意!!!

    解决方案呢?当然有,手动将src/main/resources也添加到配置就可以了。按如下的pom.xml配置,maven打包时,既能包含src/main/java下的XML文件,也能包含资源目录src/main/resources)下面的资源文件

    <build>
        <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                </resource>
    
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*</include>
                    </includes>
                </resource>
            </resources>
    </build>
    

    或者,把全部的资源文件,统一放在src/main/resources目录下,这样无需额外配置pom.xml

    问题回溯

    然而,在一年前的这篇文章 -> mybatis看这一篇就够了 当中,提到过当把XML文件和java类放在一起时,可以通过增加pom.xml的配置解决XML文件没有被打包的问题,当时增加了pom.xml中的resources配置,仅配置了扫描src/main/java目录,但是src/main/resources下的文件也被打包了进来。好像并没有出现这次遇到的这种问题。
    我起初怀疑跟SpringBoot有关,但是,经过反复的测试,发现maven项目都会出现这种问题,并且我把mybatis看这一篇就够了这篇文章中当时使用的demo代码找到了,重新用maven进行打包测试,发现问题仍然出现。这时我就很困惑了,当时为什么没有问题?当时为什么就把src/main/resources下的文件打包进来了?会不会和maven的版本,maven的插件版本等有关?



    …(A FEW YEARS LATER)…



    经过反反复复,反反复复的测试,我!终于复现了当时的情景!! 首先,运行mvn clean将maven构建的文件全部删除,然后在pom.xml中配置resources标签仅扫描src/main/java
    在这里插入图片描述

    随后,我们不运行maven命令进行打包,而直接选中一个测试类,直接点击运行一个测试用例

    在这里插入图片描述

    由于项目还未编译打包,此时会触发IDEA的自动构建

    在这里插入图片描述

    构建完毕后,我们查看target目录

    在这里插入图片描述
    发现src/main/java中的XML文件没有被打包进来,而src/main/resources下的资源文件倒是被打包了进来。根据我合理的猜测,IDEA的自动构建没有使用pom.xmlbuild标签下的配置,默认只是编译了源码目录下的java文件,并打包了资源目录下的资源文件。而此时我如果仅仅运行mvn package命令,而不是mvn clean package。由于没有运行mvn clean,所以先前已经构建好的文件不会被删掉。于是mvn package执行完毕后,src/main/java下的XML文件也被添加了进来。

    谜团解开

    至此,谜团解开。使用maven进行打包,若pom.xml中没有配置resources标签,则会采用默认策略,打包资源目录src/main/resources)下的资源文件。若pom.xml中配置了resources标签,则完全以配置的为准。即,如果pom.xml中的resources标签只配置了扫描src/main/java,则只会扫描src/main/java,不会扫描src/main/resources,即使后者已经被标记为项目的资源目录。

    先前的,仅仅配置pom.xml扫描src/main/java下的XML文件,而src/main/resources下的文件也打包了进来,这种情况,是因为一开始就进行过构建,src/main/resources目录下的文件已经被打包了进来,而后续的打包并没有执行mvn clean清除已有的文件。

    所以,在使用mybatis的时候,mapper.xml文件,最好就统一放在src/main/resources资源目录下,这样就无需额外配置pom.xml。(其他资源文件也一样)。若实在需要把XML文件放在src/main/java源码目录下,那么配置pom.xml中的resources标签时,一定要记得加上src/main/resources,如下

    <build>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                </resource>
    
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*</include>
                    </includes>
                </resource>
            </resources>
    </build>
    

    (完)

    都看到这了,一定是个小可爱,这么可爱的你,会给我一个赞的对吧?☺️

    展开全文
  • 1.maven打包java、scala混合项目 在使用 maven-shade-plugin 插件打包java、scala混合项目的过程中,发现执行mvn package命令打包的jar包中没有scala类, 经发现maven的默认compile不会编译scala类。 1.1 经搜索...

    1.maven打包java、scala混合项目

    在使用 maven-shade-plugin 插件打包java、scala混合项目的过程中,发现执行mvn package命令打包的jar包中没有scala类,

    经发现maven的默认compile不会编译scala类。

    1.1

    经搜索可以添加下面两个插件:

    <plugin>
    	<!-- 这是个编译java代码的 -->
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-compiler-plugin</artifactId>
    	<version>3.2</version>
    	<configuration>
    		<source>1.8</source>
    		<target>1.8</target>
    		<encoding>UTF-8</encoding>
    	</configuration>
    	<executions>
    		<execution>
    			<phase>compile</phase>
    			<goals>
    				<goal>compile</goal>
    			</goals>
    		</execution>
    	</executions>
    </plugin>
    <plugin>
    	<!-- 这是个编译scala代码的 -->
    	<groupId>net.alchim31.maven</groupId>
    	<artifactId>scala-maven-plugin</artifactId>
    	<version>3.2.1</version>
    	<executions>
    		<execution>
    			<id>scala-compile-first</id>
    			<phase>process-resources</phase>
    			<goals>
    				<goal>add-source</goal>
    				<goal>compile</goal>
    			</goals>
    		</execution>
    	</executions>
    </plugin>

    1.2

    还可以使用idea的手动编译项目:

    Build => Build Project,然后执行maven package命令。

     

    2.maven打包指定主类

    <plugin>
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-shade-plugin</artifactId>
    	<version>2.4.3</version>
    	<executions>
    		<execution>
    			<phase>package</phase>
    			<goals>
    				<goal>shade</goal>
    			</goals>
    			<configuration>
    				<filters>
    					<filter>
    						<artifact>*:*</artifact>
    						<excludes>
    							<exclude>META-INF/*.SF</exclude>
    							<exclude>META-INF/*.DSA</exclude>
    							<exclude>META-INF/*.RSA</exclude>
    						</excludes>
    					</filter>
    				</filters>
    				<!-- 指定主类 -->
    				<transformers>
    					<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
    						<mainClass>test.Test</mainClass>
    					</transformer>
    				</transformers>
    			</configuration>
    		</execution>
    	</executions>
    </plugin>

    transformers配置中指定主类。

    之后执行mvn package命令可以生成两个jar包:

    包含依赖的jar包类主类已指定,使用压缩软件打开jar包查看META-INF/MANIFEST.MF文件

     

     

    展开全文
  • SpringBoot-Maven打包压缩瘦身

    千次阅读 2020-02-24 21:40:12
    SpringBoot-Maven打包压缩瘦身一、Spring Boot 可执行 jar 分析1.1 打包1.2 两种 jar 的比较1.3 一次打包两个 jar二、SpringBoot迭代发布JAR瘦身配置三、引入内部编译的依赖四、Spring Boot Thin Launcher五、 maven...



    相关内容原文地址:

    腾讯云:江南一点雨:Spring Boot2 系列教程(四十)Spring Boot 可执行 jar 分析
    脚本之家:田心双木:详解SpringBoot迭代发布JAR瘦身配置
    CSDN:希尔伯特:SpringBoot瘦身打包部署
    简书:思_路:Springboot 打包瘦身
    张扎瓦的博客:springboot将项目与依赖分开打包
    柒’s Blog:SpringBoot 2.0 开发案例之百倍级减肥瘦身之旅
    周钦雄:Spring cloud的Maven插件(一):repackage目标
    博客园:niceyoo:Spring Boot 项目瘦身指南,瘦到不可思议!129M->1.3M



    一、Spring Boot 可执行 jar 分析

    Spring Boot 中默认打包成的 jar 叫做 可执行 jar,这种 jar 不同于普通的 jar,普通的 jar 不可以通过 java -jar xxx.jar 命令执行,普通的 jar 主要是被其他应用依赖,Spring Boot 打成的 jar 可以执行,但是不可以被其他的应用所依赖,即使强制依赖,也无法获取里边的类。但是可执行 jar 并不是 Spring Boot 独有的,Java 工程本身就可以打包成可执行 jar 。

    Spring Boot 项目中一个默认的插件配置 spring-boot-maven-plugin ,这个打包插件存在 5 个方面的功能,从插件命令就可以看出:
    在这里插入图片描述
    五个功能分别是:

    1. build-info:生成项目的构建信息文件 build-info.properties
    2. repackage:这个是默认 goal,在 mvn package 执行之后,这个命令再次打包生成可执行的 jar,同时将 mvn package 生成的 jar 重命名为 *.origin
    3. run:这个可以用来运行 Spring Boot 应用
    4. start:这个在 mvn integration-test 阶段,进行 Spring Boot 应用生命周期的管理
    5. stop:这个在 mvn integration-test 阶段,进行 Spring Boot 应用生命周期的管理

    这里功能,默认情况下使用就是 repackage 功能,其他功能要使用,则需要开发者显式配置。

    1.1 打包

    repackage 功能的 作用,就是在打包的时候,多做一点额外的事情:

    1. 首先 mvn package 命令 对项目进行打包,打成一个 jar,这个 jar 就是一个普通的 jar,可以被其他项目依赖,但是不可以被执行。
    2. repackage 命令,对第一步 打包成的 jar 进行再次打包,将之打成一个 可执行 jar ,通过将第一步打成的 jar 重命名为 *.original 文件

    举个例子:

    对任意一个 Spring Boot 项目进行打包,可以执行 mvn package 命令,也可以直接在 IDEA 中点击 package ,如下 :
    在这里插入图片描述
    打包成功之后, target 中的文件如下:
    在这里插入图片描述
    这里有两个文件,第一个 restful-0.0.1-SNAPSHOT.jar 表示打包成的可执行 jar ,第二个 restful-0.0.1-SNAPSHOT.jar.original 则是在打包过程中 ,被重命名的 jar,这是一个不可执行 jar,但是可以被其他项目依赖的 jar。

    1.2 两种 jar 的比较

    可执行 jar 解压之后,目录如下:
    在这里插入图片描述
    可执行 jar 中,我们自己的代码是存在 于 BOOT-INF/classes/ 目录下,另外,还有一个 META-INF 的目录,该目录下有一个 MANIFEST.MF 文件,打开该文件,内容如下:

    Manifest-Version: 1.0
    Implementation-Title: restful
    Implementation-Version: 0.0.1-SNAPSHOT
    Start-Class: org.javaboy.restful.RestfulApplication
    Spring-Boot-Classes: BOOT-INF/classes/
    Spring-Boot-Lib: BOOT-INF/lib/
    Build-Jdk-Spec: 1.8
    Spring-Boot-Version: 2.1.6.RELEASE
    Created-By: Maven Archiver 3.4.0
    Main-Class: org.springframework.boot.loader.JarLauncher
    

    可以看到,这里定义了一个 Start-Class,这就是可执行 jar 的入口类,Spring-Boot-Classes 表示我们自己代码编译后的位置,Spring-Boot-Lib 则表示项目依赖的 jar 的位置。

    换句话说,如果自己要打一个可执行 jar 包的话,除了添加相关依赖之外,还需要配置 META-INF/MANIFEST.MF 文件。

    这是可执行 jar 的结构,那么不可执行 jar 的结构呢?

    首先将默认的后缀 .original 除去,然后给文件重命名,重命名完成,进行解压:
    在这里插入图片描述
    解压后可以看到,不可执行 jar 根目录就相当于我们的 classpath,解压之后,直接就能看到我们的代码,它也有 META-INF/MANIFEST.MF 文件,但是文件中没有定义启动类等。

    Manifest-Version: 1.0
    Implementation-Title: restful
    Implementation-Version: 0.0.1-SNAPSHOT
    Build-Jdk-Spec: 1.8
    Created-By: Maven Archiver 3.4.0
    

    注意

    不可以执行 jar 也没有将项目的依赖打包进来。

    从这里我们就可以看出,两个 jar ,虽然都是 jar 包,但是内部结构是完全不同的,因此一个可以直接执行,另一个则可以被其他项目依赖。

    1.3 一次打包两个 jar

    一般来说,Spring Boot 直接打包成可执行 jar 就可以了,不建议将 Spring Boot 作为普通的 jar 被其他的项目所依赖。如果有这种需求,建议将被依赖的部分,单独抽出来做一个普通的 Maven 项目,然后在 Spring Boot 中引用这个 Maven 项目。

    如果非要将 Spring Boot 打包成一个普通 jar 被其他项目依赖,技术上来说,也是可以的,给 spring-boot-maven-plugin 插件添加如下配置:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
    

    配置的 classifier 表示可执行 jar 的名字,配置了这个之后,在插件执行 repackage 命令时,就不会给 mvn package 所打成的 jar 重命名了,所以,打包后的 jar 如下:
    在这里插入图片描述
    第一个 jar 表示可以被其他项目依赖的 jar ,第二个 jar 则表示一个可执行 jar。

    二、SpringBoot迭代发布JAR瘦身配置

    默认情况下,插件 spring-boot-maven-plugin 会把整个项目打包成一个可运行的Jar包(即所谓的Flat Jar),导致了这个Jar包很大(通常有几十M+)。

    把第三方的JAR与项目代码分离,第三方的JAR把移除到lib文件夹中,即可实现为我们的可执行JAR瘦身,配置如下:

    <plugins>
      <!-- spring boot thin jar configuration -->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <!-- main 入口 -->
          <mainClass>com.bdfint.logistics.app.driver.LogisticsAppDriverApplication</mainClass>
          <!-- 设置为ZIP,此模式下spring-boot-maven-plugin会将Manifest.MF文件中的Main-Class设置为org.springframework.boot.loader.PropertiesLauncher -->
          <layout>ZIP</layout>
          <!-- 需要包含的jar包 -->
          <includes>
            <!-- 不包含任何jar包 -->
            <!--<include>-->
              <!--<groupId>nothing</groupId>-->
              <!--<artifactId>nothing</artifactId>-->
            <!--</include>-->
            <include>
              <groupId>com.bdfint.logistics</groupId>
              <artifactId>logistics-api</artifactId>
            </include>
            <include>
              <groupId>com.bdfint.logistics</groupId>
              <artifactId>logistics-common</artifactId>
            </include>
          </includes>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <!-- third-party jar into lib directory -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <outputDirectory>${project.build.directory}/lib</outputDirectory>
              <!-- 需要排除的jar的 groupId -->
              <excludeGroupIds>
                com.bdfint.logistics
              </excludeGroupIds>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
    

    接下来,执行打包命令:mvn clean package -Dmaven.test.skip=true,打包后在target目录下就包含我们的JAR和lib目录,如下图:
    在这里插入图片描述
    CMD定位到target目录下,执行命令:java -Dloader.path=./lib -jar logistics-app-driver-2.9.1.1.jar,即可把项目JAR跑起来!

    三、引入内部编译的依赖

    如果想引入内部编译的依赖包可以通过includes属性进行添加,利用引用了内部的dubbo可以通过如下配置:
    在这里插入图片描述
    配置完成后,再次执行编译:mvn clean package。

    如果引入内部包过多,也可以通过excludeGroupIds属性去掉不变的依赖包。

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                  <layout>ZIP</layout>
                        <!--去除在生产环境中不变的依赖-->
                        <excludeGroupIds>
                             org.springframework.boot,
                             org.springframework,
                             org.springframework.data,
                             org.apache.tomcat.embed
                       </excludeGroupIds>
                 </configuration>     
            </plugin>
        </plugins>
    </build>   
    

    注:layout 必须是 ZIP 、 excludeGroupIds 中时忽略也是就需要打在外部的 jar。

    3.1 剔除不需要的依赖

    3.1.1 方式一:排除一个具体的maven 模块,通过唯一的groupId和artifactId组合来实现。(如果有必要,可以加入classifier来唯一确认。)

     1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludes>
    13             <exclude>
    14               <groupId>com.foo</groupId>
    15               <artifactId>bar</artifactId>
    16             </exclude>
    17           </excludes>
    18         </configuration>
    19         ...
    20       </plugin>
    21       ...
    22     </plugins>
    23     ...
    24   </build>
    25   ...
    26 </project>
    

    3.1.2 方式二:排除和“指定的artifactId”相符的所有maven模块

     1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludeArtifactIds>my-lib,another-lib</excludeArtifactIds>
    13         </configuration>
    14         ...
    15       </plugin>
    16       ...
    17     </plugins>
    18     ...
    19   </build>
    20   ...
    21 </project>
    

    3.1.3 方式三:排除属于“指定的groupId”的所有maven模块

     1 <project>
     2   ...
     3   <build>
     4     ...
     5     <plugins>
     6       ...
     7       <plugin>
     8         <groupId>org.springframework.boot</groupId>
     9         <artifactId>spring-boot-maven-plugin</artifactId>
    10         <version>1.5.6.RELEASE</version>
    11         <configuration>
    12           <excludeGroupIds>com.foo</excludeGroupIds>
    13         </configuration>
    14         ...
    15       </plugin>
    16       ...
    17     </plugins>
    18     ...
    19   </build>
    20   ...
    21 </project>
    

    四、Spring Boot Thin Launcher

    使用插件以后,原来打包45M的jar包,现在体积只有 40K,瘦身效果非常明显,并且也不改变原有的打包方式和部署方法。打包以后的jar也是可执行的。

    第一次执行时,会自动下载所有的依赖包,并且缓存到本地,默认的缓存路径是${user.home}/.m2/,你也可以使用如下命令在启动时修改依赖的路径

    java -Dthin.root=.  -jar  app-0.0.1-SNAPSHOT.jar
    

    在pom.xml添加以下插件代码,然后正常地打包即可:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.boot.experimental</groupId>
                        <artifactId>spring-boot-thin-layout</artifactId>
                        <version>1.0.3.RELEASE</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <executable>true</executable>
                </configuration>
            </plugin>
        </plugins>
    </build>
    

    五、 maven的assembly打包插件

    assembly配置:
    在项目中创建一个文件,放在src/main/assembly/assembly.xml中。
    在这里插入图片描述
    assembly中的具体配置:

    <assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
    
        <!--
            必须写,否则打包时会有 assembly ID must be present and non-empty 错误
            这个名字最终会追加到打包的名字的末尾,如项目的名字为 speed-api-0.0.1-SNAPSHOT,
            则最终生成的包名为 speed-api-0.0.1-SNAPSHOT-bin.zip
         -->
        <id>bin</id>
    
        <!-- 打包后的文件格式,可以是zip,tar,tar.gz,tar.bz2,jar,war,dir -->
        <formats>
            <format>zip</format>
        </formats>
    
        <!-- 压缩包下是否生成和项目名相同的根目录 -->
        <includeBaseDirectory>false</includeBaseDirectory>
    
        <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>
                <includes>
                    <include>README*</include>
                    <include>LICENSE*</include>
                    <include>NOTICE*</include>
                </includes>
            </fileSet>
    
            <!-- 把项目的配置文件,打包进zip文件的config目录 -->
            <fileSet>
                <directory>${project.basedir}/src/main/resources</directory>
                <outputDirectory>config</outputDirectory>
            </fileSet>
    
            <!-- 把项目的脚本文件,打包进zip文件的bin目录 -->
            <fileSet>
                <directory>${project.basedir}/src/main/bin</directory>
                <outputDirectory>bin</outputDirectory>
            </fileSet>
    
            <!-- 把项目自己编译出来的jar文件,打包进zip文件的根目录 -->
            <fileSet>
                <directory>${project.build.directory}</directory>
                <outputDirectory></outputDirectory>
                <includes>
                    <include>*.jar</include>
                </includes>
            </fileSet>
        </fileSets>
    </assembly>
    

    maven中的配置:

    <build>
        <plugins>
            <!-- 指定启动类,将依赖打成外部jar包 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <!-- 生成的jar中,不要包含pom.xml和pom.properties这两个文件 -->
                        <addMavenDescriptor>false</addMavenDescriptor>
                        <manifest>
                            <!-- 是否要把第三方jar放到manifest的classpath中 -->
                            <addClasspath>true</addClasspath>
                            <!-- 外部依赖jar包的最终位置 -->
                            <classpathPrefix>lib/</classpathPrefix>
                            <!-- 项目启动类 -->
                            <mainClass>com.zbrx.speed.App</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
    
            <!-- 使用assembly打包 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptors>
                        <!-- assembly配置文件位置 -->
                        <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>
    
    
            <!-- 打包发布时,跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
    

    最终打包后的效果:
    在这里插入图片描述
    压缩包里的文件内容:
    在这里插入图片描述
    config配置文件:
    在这里插入图片描述

    六、SpringBoot剔除静态文件

    静态文件排除到项目外面,pom.xml 继续引入:

    <resources>
         <resource>
           <filtering>true</filtering>
           <directory>src/main/resources</directory>
           <excludes>
             <exclude>static/**</exclude>
           </excludes>
         </resource>
    </resources>
    

    配置nginx,访问静态资源文件:

    server {
            listen       80;
            server_name  www.cloudbed.vip;
            location / {
                proxy_pass http://127.0.0.1:8080;
            }
            #静态文件交给nginx处理
            location ~ .*\.(gif|jpg|jpeg|png|bmp|swf|ioc|rar|
                zip|txt|flv|mid|doc|ppt|pdf|xls|mp3|wma)$
            {
                root /cloudbed/static;
                expires 30d;
            }
            location ~ .*\.(js|css)?$
            {
                root /cloudbed/static;
                expires 1h;
            }
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
    }
    

    6.1 打包时排除resources下的资源文件

     1 <build>
     2   ...
     3     <resources>
     4         <resource>
     5             <directory>src/main/resources</directory>
     6             <excludes>
     7                 <exclude>**/*.properties</exclude>
     8                 <exclude>**/*.xml</exclude>
     9                 <exclude>**/*.yml</exclude>
    10             </excludes>
    11         </resource>
    12     </resources>
    13     <plugins>
    14       ...
    15         <plugin>
    16             <groupId>org.springframework.boot</groupId>
    17             <artifactId>spring-boot-maven-plugin</artifactId>
    18             <executions>
    19                 <execution>
    20                     <goals>
    21                         <goal>repackage</goal>
    22                     </goals>
    23                 </execution>
    24             </executions>
    25         </plugin>
    26       ...
    27     </plugins>
    28   ...
    29 </build>
    
    展开全文
  • Maven 打包跳过Test目录

    千次阅读 2020-04-16 11:44:58
    Maven执行package打包时,测试失败会影响打包结果。 解决方法: 方法一:修改pom.xml文件如下,把skipTests属性改为true <project> <build> <plugins> <plugin> <groupId>...
  • Maven打包带源码

    千次阅读 2020-10-15 19:23:26
    org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <configuration> <forkMode>once</forkMode> <argLine>-Dfil
  • maven打包可执行的jar包-包含依赖jar

    千次阅读 2020-12-30 15:54:20
    maven打包可执行的jar包:1. 首先确保编辑器里maven环境正常2. 运行打包的jar文件3. 测试添加依赖后打包。4. 注意cmd命令传入中文参数乱码 1. 首先确保编辑器里maven环境正常 我这里已经有现成的maven环境和工具类了...
  • 方法一:使用maven-jar-plugin和maven-dependency-plugin 方法二:使用maven-assembly-plugin (推荐) 方法三:使用maven-shade-plugin 方法四:使用onejar-maven-plugin 方法五:使用spring-boot-maven-plugin ...
  • Apache Maven是一个软件项目管理和理解工具。基于项目对象模型(POM)的概念,Maven可以从一个中心信息管理项目的构建,报告和文档。 虽然近年来Gradle作为后起之秀借着Android的东风大肆扩张,Maven作为主流构建...
  • Maven打包太慢??

    千次阅读 2020-07-22 16:13:34
    Maven打包太慢??构建项目太慢
  • maven打包将依赖jar也打包的方法

    万次阅读 2019-04-29 20:33:46
    maven是目前很常用的管理jar的工具,使用maven可以直接将java项目打包成一个可运行的jar,但是有时候有些依赖的jar没有包含在里面,这时候就需要早pom文件中build里面添加下面的配置 <plugins> <...
  • maven打包文件过大优化

    千次阅读 2020-06-10 11:14:54
    很多公司在使用maven私服的时候为了优化磁盘空间,去除不必要的文件。如果是单pom项目中在配置中引入 <properties> <maven.deploy.skip>true</maven.deploy.skip> <maven.install.skip&...
  • Maven 打包踩坑之ClassNotFoundException 与 NoClassDefFoundError 问题: spark streaming程序在本地运行正常,上传至服务器运行时出现如下错误: Caused by: java.lang.ClassNotFoundException: AAA Caused...
  • Maven 打包忽略依赖<scope></scope>

    千次阅读 2020-09-16 20:03:45
    实际maven打包,如果在pom文件中配置了打包插件,就会打出2个jar包,一个是包含依赖的jar包,一个是不包含依赖的jar包。 不包含依赖的jar包,体积会小很多,只包含编写的逻辑代码,但要求这个jar包运行环境中必须有...
  • maven打包常用命令总结

    万次阅读 2019-10-24 23:15:38
    maven打包常用命令总结基本命令介绍1、mvn clean2、mvn compile3、mvn package4、mvn install5、mvn deploy生产环境打包举例1、生产环境根据源码构建项目:2、可用用到的其他mvn参数介绍: 开发过程中常见以下几个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,328
精华内容 60,531
关键字:

maven打包