精华内容
下载资源
问答
  • maven打包分离 resource、lib包

    千次阅读 2019-04-24 20:32:54
    在工作中一般创建的工程都是maven工程,用spring boot进行项目开发,maven插件就是自动集成的 <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-...

    在工作中一般创建的工程都是maven工程,用spring boot进行项目开发,maven插件就是自动集成的
    <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin>
    当我们开发完成之后进行测试部署或者正式上线后,要进行迭代的时候发现需要上传的包比较大,包含了很多没有改动的资源(依赖包lib、resources),如果可以把这些包和工程jar包(只有class文件)进行分离,那么每次进行迭代的时候只需要上传修改的文件或者工程jar包,就会节省很多时间。
    下面就针对实际应用中的实践做一个配的简单说明:

    maven打包的方式有很多下面就先讲解我用的一种
    使用maven-assembly-plugin插件进行资源分离。
    官方文档

    http://maven.apache.org/plugins/maven-assembly-plugin/
    

    第一步:修改pom.xml文件

    <!--多环境支持-->
        <profiles>
            <profile>
                <id>prod</id>
                <build>
                    <!--包名-->
                    <finalName>authoritymanagement</finalName>
                    <resources>
                        <resource>
                            <directory>src/main/java</directory>
                            <filtering>false</filtering>
                            <excludes>
                                <exclude>**/*.java</exclude>
                            </excludes>
                        </resource>
                    </resources>
                    <plugins>
    
                        <!--maven-jar-plugin 负责将应用程序打包成可执行的jar文件-->
                        <!-- 打包成jar文件,并指定lib文件夹以及resources资源文件夹 -->
                        <plugin>
                            <groupId>org.apache.maven.plugins</groupId>
                            <artifactId>maven-jar-plugin</artifactId>
                            <version>2.4</version>
                            <configuration>
                                <archive>
                                    <manifest>
                                        <mainClass>com.ganinfo.MainApplication</mainClass>
                                        <classpathPrefix>lib/</classpathPrefix>
                                        <addClasspath>true</addClasspath>
                                    </manifest>
                                    <manifestEntries>
                                        <Class-Path>resources/</Class-Path>
                                    </manifestEntries>
                                </archive>
                            </configuration>
                        </plugin>
    
                        <!--配置编码-->
                        <plugin>
                            <artifactId>maven-compiler-plugin</artifactId>
                            <configuration>
                                <source>1.8</source>
                                <target>1.8</target>
                                <encoding>UTF-8</encoding>
                            </configuration>
                        </plugin>
    
                        <!--打包跳过测试类-->
                        <plugin>
                            <groupId>org.apache.maven.plugins</groupId>
                            <artifactId>maven-surefire-plugin</artifactId>
                            <configuration>
                                <testFailureIgnore>true</testFailureIgnore>
                                <skip>true</skip>
                            </configuration>
                        </plugin>
    
                        <!--maven-assembly-plugin,负责将整个项目按照自定义的目录结构打成最终的压缩包,方便实际部署 -->
                        <plugin>
                            <!--使用插件-->
                            <artifactId>maven-assembly-plugin</artifactId>
                            <configuration>
                                <!--自定义的configuration配置后,将会生成一个demo-demo.jar 文件在目录 output 下,其中前一个demo
                                来自finalName,后一个demo来自assembly descriptor中的id,其中的内容和默认的打包出来的jar类似,
                                如果只想有finalName,则增加配置:<appendAssemblyId/>-->
                                <appendAssemblyId>false</appendAssemblyId>
                                <!--输出路径-->
                                <outputDirectory>${project.build.directory}/dist/</outputDirectory>
                                <!--描述文件位置-->
                                <descriptors>
                                    <descriptor>assembly.xml</descriptor>
                                </descriptors>
                            </configuration>
                            <!--配置执行器-->
                            <executions>
                                <execution>
                                    <id>make-assembly</id>
                                    <!--绑定到package生命周期阶段上-->
                                    <phase>package</phase>
                                    <goals>
                                        <!--只运行一次-->
                                        <goal>single</goal>
                                    </goals>
                                </execution>
                            </executions>
                        </plugin>
                    </plugins>
                </build>
            </profile>
            <profile>
                <id>dev</id>
                <build>
                    <finalName>生成的包名</finalName>
                    <plugins>
                        <plugin>
                            <groupId>org.springframework.boot</groupId>
                            <artifactId>spring-boot-maven-plugin</artifactId>
                            <executions>
                                <execution>
                                    <goals>
                                        <goal>build-info</goal>
                                    </goals>
                                </execution>
                            </executions>
                        </plugin>
                    </plugins>
                </build>
            </profile>
        </profiles>
    

    添加文件 assembly.xml

    <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">
    
        <!--标识符,添加到生成文件名称的后缀符。如果指定 id 的话,目标文件则是 ${artifactId}-${id}.tar.gz-->
        <id>distribution</id>
        <formats>
            <!--指定打包类型: zip、tar、tar.gz(or tgz)、tar.bz2 (or tbz2)、tar.snappy 、tar.xz (or txz)、jar、dir、war-->
            <format>dir</format>
        </formats>
    
        <!--是否包含根目录-->
        <!--指定是否包含打包层目录(比如finalName是output,当值为true,所有文件被放在output目录下,否则直接放在包的根目录下)-->
        <includeBaseDirectory>false</includeBaseDirectory>
        <!--根目录名称-->
        <!--<baseDirectory>${project.build.finalName}</baseDirectory>-->
    
        <fileSets><!--指定要包含的文件集,可以定义多个fileSet;-->
            <fileSet>
                <!--指定要包含的目录-->
                <directory>src/main/resources/</directory>
                <!--指定当前要包含的目录的目的地-->
                <outputDirectory>/resources</outputDirectory>
            </fileSet>
            <fileSet>
                <directory>bin/</directory>
                <outputDirectory>/</outputDirectory>
            </fileSet>
            <fileSet>
                <directory>sh/</directory>
                <outputDirectory></outputDirectory>
            </fileSet>
        </fileSets>
    
        <!--用来定制工程依赖 jar 包的打包方式-->
        <dependencySets>
            <dependencySet>
                <!--设置相对于程序集根目录根目录的输出目录-->
                <outputDirectory>/lib</outputDirectory>
                <!--默认级别-->
                <scope>runtime</scope>
                <excludes>
                    <exclude>${project.groupId}:${project.artifactId}</exclude>
                </excludes>
            </dependencySet>
            <dependencySet>
                <outputDirectory>/</outputDirectory>
                <includes>
                    <include>${project.groupId}:${project.artifactId}</include>
                </includes>
            </dependencySet>
        </dependencySets>
    </assembly>
    

    在该工程目录下执行命令mvn clean package -Pprod 其中 prod 指的是pom.xml文件中配置的环境
    在这里插入图片描述

    执行完打包命令之后生成目录

    引荐几篇文章关于配置maven的

    讲解 maven-assembly-plugin
    https://blog.csdn.net/chendeyou5/article/details/79448952
    讲解 maven assembly实现不同环境的打包
    https://blog.csdn.net/qiaoge134/article/details/62223029
    讲解 多环境打包
    https://blog.csdn.net/zhouyan8603/article/details/78668297
    讲解 maven插件
    https://segmentfault.com/a/1190000016237395
    
    

    如果是maven配置的是私服的可能会出现下载不到资源的问题,
    首先确认maven配置的是私服地址
    1、

    <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>*</mirrorOf>//表示优先请求一下的地址
        <name>Nexus aliyun</name>
        <url>私服地址</url>
    </mirror>
    

    2、在pom.xml中添加引用私服地址配置

    <project>
    <repositories>
        <repository>
            <id>central</id>
            <name>central</name>
            <!-- 配置仓库的地址 -->
            <url>http://localhost:8081/nexus/content/groups/</url>
        </repository>
    </repositories>
    </project>
    

    继续更新中。。。。

    展开全文
  • 方法一:使用maven-jar-plugin和maven-dependency-plugin 方法二:使用maven-assembly-plugin (推荐) 方法三:使用maven-shade-plugin 方法四:使用onejar-maven-plugin 方法五:使用spring-boot-maven-plugin ...

    目录

    打包方法

    方法一:使用maven-jar-plugin和maven-dependency-plugin

    方法二:使用maven-assembly-plugin (推荐)

    方法三:使用maven-shade-plugin

    方法四:使用onejar-maven-plugin

    方法五:使用spring-boot-maven-plugin

    方法六:使用tomcat7-maven-plugin

    参考


     

    打包方法

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

    首先,maven-jar-plugin的作用是配置mainClass和指定classpath。

     

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
            <archive>
                <manifest>
                    <addClasspath>true</addClasspath>
                    <classpathPrefix>libs/</classpathPrefix>
                    <mainClass>
                        org.baeldung.executable.ExecutableMavenJar
                    </mainClass>
                </manifest>
            </archive>
        </configuration>
    </plugin>
    

    addClasspath: 是否在manifest文件中添加classpath。默认为false。如果为true,则会在manifest文件中添加classpath,这样在启动的时候就不用再手动指定classpath了。如下所示,文件中增加了Class-Path一行

     

    Manifest-Version: 1.0                                                                                                                                         
    Archiver-Version: Plexus Archiver
    Built-By: michealyang
    Class-Path: libs/jetty-server-9.4.7.v20170914.jar lib/javax.servlet-api
     -3.1.0.jar libs/jetty-http-9.4.7.v20170914.jar 
    Created-By: Apache Maven 3.3.9
    Build-Jdk: 1.8.0_162-ea
    Main-Class: com.michealyang.jetty.embeded.EmbeddedJettyServer
    

    classpathPrefix: classpath的前缀。如上面的manifest文件中,Class-Path的值中,每个jar包的前缀都是libs/。本质上,这个配置的值是所依赖jar包所在的文件夹。配置正确了才能找到依赖
    mainClass: 指定启动时的Main Class

    其次,maven-dependency-plugin会把所依赖的jar包copy到指定目录

     

    <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}/libs
                    </outputDirectory>
                </configuration>
            </execution>
        </executions>
    </plugin>
    

    executions中的配置都很重要,按照上面的配置来就行了。outputDirectory指定了要将所依赖的jar包copy到哪个目录。要与maven-jar-plugin中的classpathPrefix一致。

    执行如下命令,即可打包:

    mvn package

    打包结果是,自己写的Class在jar包中,所依赖的jar包在libs目录中:

    ├── embedded-jetty-1.0.0-SNAPSHOT.jar
    ├── lib
    │ ├── jetty-server-9.4.7.v20170914.jar
    │ ├── jetty-http-9.4.7.v20170914.jar

    执行如下命令即可启动jar包:

    java -jar embedded-jetty-1.0.0-SNAPSHOT.jar

    优点
    有诸多配置项,很自由,每个步骤都可控

    缺点
    打成的最终jar包中没有所依赖的jar包。依赖跟自己的代码不在一个jar包中。部署或者移动的时候,要考虑到多个文件,比较麻烦

    方法二:使用maven-assembly-plugin (推荐)

    maven-assembly-plugin可以将所有的东西都打包到一个jar包中。

     

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>single</goal>
                </goals>
                <configuration>
                    <archive>
                    <manifest>
                        <mainClass>
                            com.michealyang.jetty.embeded.EmbeddedJettyServer
                        </mainClass>
                    </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </execution>
        </executions>
    </plugin>
    

    执行mvn package后,会在target文件夹下生成两个jar包,一个是不带依赖的jar包,一个是后缀有-dependencies带有依赖的jar包,如:

    May 31 16:42 embedded-jetty-1.0.0-SNAPSHOT-jar-with-dependencies.jar
    May 31 16:42 embedded-jetty-1.0.0-SNAPSHOT.jar

    启动时,直接执行即可:

    java -jar embedded-jetty-1.0.0-SNAPSHOT-jar-with-dependencies.jar

    优点
    所有的东西都打到一个jar包中,很方便
    缺点
    配置项少,不自由。

    方法三:使用maven-shade-plugin

    maven-assembly-plugin类似,都可以将所有的东西都打包到一个jar包中。

     

    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <executions>
            <execution>
                <goals>
                    <goal>shade</goal>
                </goals>
                <configuration>
                    <shadedArtifactAttached>true</shadedArtifactAttached>
                    <transformers>
                        <transformer implementation=
                          "org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                            <mainClass>com.michealyang.jetty.embeded.EmbeddedJettyServer</mainClass>
                    </transformer>
                </transformers>
            </configuration>
            </execution>
        </executions>
    </plugin>
    

    执行mvn package后,会在target文件夹下生成两个jar包,一个是不带依赖的jar包,一个是后缀有-shaded带有依赖的jar包,如:

    May 31 16:53 embedded-jetty-1.0.0-SNAPSHOT-shaded.jar
    May 31 16:53 embedded-jetty-1.0.0-SNAPSHOT.jar

    启动时,直接执行即可:

    java -jar embedded-jetty-1.0.0-SNAPSHOT-jar-with-shaded.jar

    优点
    功能同maven-assembly-plugin,但比前者强大
    缺点
    配置起来太麻烦。当你需要高级功能的时候,更是麻烦的不要不要的。

    方法四:使用onejar-maven-plugin

    This provides custom classloader that knows how to load classes and resources from jars inside an archive, instead of from jars in the filesystem.

     

    <plugin>
        <groupId>com.jolira</groupId>
        <artifactId>onejar-maven-plugin</artifactId>
        <executions>
            <execution>
                <configuration>
                    <mainClass>org.baeldung.executable.
                      ExecutableMavenJar</mainClass>
                    <attachToBuild>true</attachToBuild>
                    <filename>
                      ${project.build.finalName}.${project.packaging}
                    </filename>
                </configuration>
                <goals>
                    <goal>one-jar</goal>
                </goals>
            </execution>
        </executions>
    </plugin>
    

    优点
    clean delegation model, allows classes to be at the top-level of the One Jar, supports external jars and can support Native libraries
    缺点
    not actively supported since 2012

    方法五:使用spring-boot-maven-plugin

    能同时打可执行jar包和war包
    This allows to package executable jar or war archives and run an application “in-place”.

    需要maven版本不低于3.2

     

    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <executions>
            <execution>
                <goals>
                    <goal>repackage</goal>
                </goals>
                <configuration>
                    <classifier>spring-boot</classifier>
                    <mainClass>
                      org.baeldung.executable.ExecutableMavenJar
                    </mainClass>
                </configuration>
            </execution>
        </executions>
    </plugin>
    

    两个重点:

    • goal要写成repackage
    • classifier要写成spring-boot

    优点
    dependencies inside a jar file, you can run it in every accessible location, advanced control of packaging your artifact, with excluding dependencies from the jar file etc., packaging of war files as well

    缺点
    添加了一些不必要的Spring和Spring Boot依赖

    方法六:使用tomcat7-maven-plugin

    可打包成一个web工程类型的jar包。其实是内嵌了一个tomcat在里面。

     

    <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.0</version>
        <executions>
            <execution>
                <id>tomcat-run</id>
                <goals>
                    <goal>exec-war-only</goal>
                </goals>
                <phase>package</phase>
                <configuration>
                    <path>/</path>
                    <enableNaming>false</enableNaming>
                    <finalName>webapp.jar</finalName>
                    <charset>utf-8</charset>
                </configuration>
            </execution>
        </executions>
    </plugin>
    

    The goal is set as exec-war-only, path to your server is specified inside configuration tag, with additional properties, like finalName, charset etc. To build a jar, run man package, which will result in creating webapp.jar in your target directory. To run

    To run the application, just write this in your console: java -jar target/webapp.jar and try to test it by specifying the localhost:8080/ in a browser.

    优点
    只有一个jar包
    缺点
    打包出的文件很大。因为里面内嵌了一个tomcat

    参考

    How to Create an Executable JAR with Maven

    展开全文
  • Maven打包时添加外部jar包

    万次阅读 2018-04-23 18:40:51
    打包时添加外部jar同maven中的jar包一起添加到编译后的文件当中 1.在项目根目录创建libs文件夹将使用的jar包放入其中 2.jar包以scope为system的方式导入pom文件 com.aliyun alipay-sdk-java-3.0.0 3.0.0...

    方法1:

    1.安装本地jar包到本地仓库

    mvn install:install-file 

        -Dfile=alipay-sdk-java-3.0.0.jar  

        -DgroupId=com.aliyun 

        -DartifactId=alipay-sdk-java-3.0.0 

        -Dversion=3.0.0 

        -Dpackaging=jar

    2.普通方式导入jar包

    <dependency>
       <groupId>com.aliyun</groupId>
       <artifactId>alipay-sdk-java-3.0.0</artifactId>
       <version>3.0.0</version>
    </dependency>

    方法2:

    打包时添加外部jar同maven中的jar包一起添加到编译后的文件当中

    1.在项目根目录创建libs文件夹将使用的jar包放入其中

    2.jar包以scope为system的方式导入pom文件

    <dependency>
       <groupId>com.aliyun</groupId>
       <artifactId>alipay-sdk-java-3.0.0</artifactId>
       <version>3.0.0</version>
       <scope>system</scope>
       <systemPath>${project.basedir}/libs/alipay-sdk-java-3.0.0.jar</systemPath>
    </dependency>

    3.添加maven-war-plugin插件

    <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-war-plugin</artifactId>
       <configuration>
          <webResources>
             <resource>
                <directory>${project.basedir}/libs</directory>
                <targetPath>WEB-INF/lib</targetPath>
                <includes>
                   <include>**/*.jar</include>
                </includes>
             </resource>
          </webResources>
       </configuration>
    </plugin>


    展开全文
  • Apache Maven是一个软件项目管理和理解工具。基于项目对象模型(POM)的概念,Maven可以从一个中心信息管理项目的构建,报告和文档。 虽然近年来Gradle作为后起之秀借着Android的东风大肆扩张,Maven作为主流构建...

    前言

    Apache Maven是一个软件项目管理和构建工具。基于项目对象模型(POM)的概念,Maven可以从一个核心配置文件管理项目的构建,报告和文档。

    虽然近年来Gradle作为后起之秀借着Android的东风大肆扩张,Maven作为主流构建工具的地位还是不可动摇的。我们可以看到很多明星项目都是基于Maven构建的,如Spring Boot

    Maven的适用范围非常广,可以用来编译、构建、管理依赖、打包、运行测试用例形成测试报告、甚至借助插件直接发布到远程Tomcat等。阅读本文需要你对Maven已经有了大体的了解,本文将从Maven的常见使用场景切入,介绍笔者使用过程中的经验和总结,最终提出最佳实践。

    第一个Maven项目

    脚手架

    安装并配置好Maven后,我们可以用Maven的脚手架命令工具来生成第一个Maven项目。

    mvn -B archetype:generate \
      -DarchetypeGroupId=org.apache.Maven.archetypes \
      -DgroupId=com.mycompany.app \
      -DartifactId=my-app
    

    上面的archetype是Maven仓库中内置的脚手架工具,所谓脚手架就是执行这个预置命令就会初始化好一个项目框架,生成一个项目部模板的工具。在模板中可以定义pom.xml预制的依赖项、构建选项等,你也可以自己创建一个Maven项目脚手架发布到Maven仓库中供他人使用。

    当然大多数情况下我们用的是IDE的Maven插件来创建的。在Eclipse中我们创建Maven工程时也可以选择预置的脚手架,这通常需要联网下载,由于某些原因国内访问Maven中央仓库非常慢,因此强烈建议配置为阿里云的Maven镜像。

    image

    最佳实践

    笔者在创建项目时一般会在上图勾选create simple project,跳过一些花里胡哨的脚手架模板,自己一步步配置的pom才会真正了如指掌。

    在接下来的界面上,Eclipse会提供三个选项:

    • pom,Maven父工程项目,可以向其中添加Module。
    • jar,Java的控制台项目。
    • war,Java的Web项目。

    选择你需要的项目类型就可以了。

    image

    Maven依赖管理

    Maven依赖管理可能是最常用的功能之一了,在pom.xml中,通过Maven坐标来引用依赖的jar包,这个坐标的groupId、artifactId和version可唯一确定一个jar包,然后Maven会从配置好的远程仓库中进行下载构建。

    <dependencies>
    		<dependency>
    			<groupId>org.quartz-scheduler</groupId>
    			<artifactId>quartz</artifactId>
    			<version>2.3.0</version>
    			<scope>compile</scope>
    		</dependency>
    </dependencies>
    

    依赖的作用域

    上面代码段中的<scope>选项标识该依赖的作用域,默认scope是compile,scope提供以下选项:

    1. compile (编译范围)

    compile是默认的范围;如果没有提供一个范围,那该依赖的范围就是编译范围。编译范围依赖在所有的classpath 中可用,同时它们也会被打包。

    1. provided (已提供范围)

    provided 依赖只有在当JDK 或者一个容器已提供该依赖之后才使用。例如, 如果你开发了一个web 应用,你可能在编译 classpath 中需要可用的Servlet API 来编译一个servlet,但是你不会想要在打包好的WAR 中包含这个Servlet API;这个Servlet API jar 由你的应用服务器或者servlet 容器提供。已提供范围的依赖在编译classpath (不是运行时)可用。它们不是传递性的,也不会被打包。

    1. runtime (运行时范围)

    runtime 依赖在运行和测试系统的时候需要,但在编译的时候不需要。比如,你可能在编译的时候只需要JDBC API jar,而只有在运行的时候才需要JDBC驱动实现。

    1. test (测试范围)

    test范围依赖 在一般的编译和运行时都不需要,它们只有在测试编译和测试运行阶段可用。

    1. system (系统范围)划重点,后面踩过坑

    system范围依赖与provided 类似,但是你必须显式的提供一个对于本地系统中jar 文件的路径。这么做是为了允许基于本地对象编译,而这些对象是系统类库的一部分。这样的构件应该是一直可用的,Maven 也不会在仓库中去寻找它。如果你将一个依赖范围设置成系统范围,你必须同时提供一个 systemPath 元素。注意该范围是不推荐使用的(你应该一直尽量去从公共或定制的 Maven 仓库中引用依赖)

    1. import

    此范围仅支持<dependencyManagement>中的pom类型。它表示要使用指定POM的<dependencyManagement>中的有效依赖项列表替换的依赖项,即预先定义以依赖列表,按需引用,需要Maven2.9版本以上支持。
    示例:

    打包构建

    开发阶段我们一般都是在IDE里面直接运行Java代码,在项目发布部署时如何导出jar包或war包呢?

    非Maven项目

    以Eclipse为例,右击项目名,选择Export选择JAR file、Runnable JAR file或WAR file即可

    image

    Maven项目

    Maven的打包策略有很多,在此一打可执行jar包为例进行探讨。首要步骤是需要在pom的<build>节点下添加Maven的打包插件,常见的打包插件有:

    1. 核心插件Maven-compiler-plugin,用于指定编译级别,默认使用jdk1.5编译
    2. 打包可执行jar的Maven-jar-plugin,用于指定本项目生成的jar包中的MANIFEST.MF文件中的配置,如Class-Path和Main-Class
    3. Maven-assembly-plugin,支持定制化打包方式,负责将整个项目按照自定义的目录结构打成最终的压缩包,方便实际部署,可在此处设置打包拷贝路径,配置,以及打包好的jar文件等。
    4. Maven-shade-plugin,用来打可执行包,包含依赖,以及对依赖进行取舍过滤,当你只想将项目打成一个可执行包时,Maven-shade-plugin非常适合。

    打包策略选择:

    1. 直接打包,不打包依赖包,仅打包出项目中的代码到jar包中。在POM中添加Maven-compiler-plugin即可,随后执行Maven package。直接打包意义不大,首先Pass。
    2. 将项目和依赖打包成一整个可执行jar包,用到的就是Maven-shade-plugin了。这是常规的做法,由于包含了所有依赖jar包,封装了内部细节,包容一且。
    3. 将依赖jar包输出到lib目录方式,Tomcat就是采用的这种打包策略。这种方案属于将项目结构重新组装,因此要用到的核心打包插件是Maven-assembly-plugin。通过配置,将依赖jar输出到lib目录,与构建后的主项目包分离,若程序需要升级仅需替换主程序jar即可,不必连同lib目录一起替换,大大提高了网络传输效率;结构分离整体上也够直观。

    在提出最佳实践之前我们先来了解一下打包策略2需要的配置:

    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.Maven.plugins</groupId>  
                <artifactId>Maven-shade-plugin</artifactId>  
                <version>1.4</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>com.cat.Application</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>  
    
    

    shade插件绑定的是package生命周期目标,并设置com.cat.Application为Main-Class,以及将META-INF/spring.*文件合并(追加而非覆盖),并过滤掉所有依赖的META/INF中SF,DSA,RSA后缀文件。这里涉及到filter配置和transformer配置。

    最佳实践

    综上所述,我们选择策略3作为最佳实践(向Tomcat看齐),首先看一下打包后的项目结构:

    D:\BANKSERVER //根目录
    │  bankServer.jar //主程序包
    │  README.md      //说明文档
    │  startup.bat    //启动脚本
    │  
    ├─conf //配置文件目录
    │      config.properties //配置文件
    │      database.properties //数据库配置文件
    │        
    ├─lib //依赖目录
    │      aopalliance-1.0.jar
    │      bankServer-0.0.1-SNAPSHOT.jar
    │      c3p0-0.9.5.2.jar
    │      my-Entry-1.0.jar
    │      commons-lang3-3.8.1.jar
    │      druid-1.1.8.jar
    

    这里用到了三个插件,Maven-compiler-plugin指定编译级别;Maven-jar-plugin主要就是配置了MANIFEST.MF这个文件而已,就是让可执行文件知道自己怎么执行,加载哪些文件执行的描述,剩下的工作交由Maven-assembly-plugin来处理。

    贴上来pom.xml的配置:

    <build>
    		<finalName>bankServer</finalName>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.Maven.plugins</groupId>
    				<artifactId>Maven-compiler-plugin</artifactId>
    				<version>3.7.0</version>
    				<configuration>
    					<source>1.7</source>
    					<target>1.7</target>
    					<encoding>utf-8</encoding>
    				</configuration>
    			</plugin>
    
    			<plugin>
    				<groupId>org.apache.Maven.plugins</groupId>
    				<artifactId>Maven-jar-plugin</artifactId>
    				<configuration>
    					<archive>
    						<addMavenDescriptor>false</addMavenDescriptor>
    						<!-- 指定main信息 -->
    						<manifest>
    						    <!--指定添加项目中使用的外部jar的classpath项-->
    							<addClasspath>true</addClasspath>
    							<classpathPrefix>lib/</classpathPrefix>
    							<!-- 此处指定main方法入口的class -->
    							<mainClass>com.cat.bank.main.Luncher</mainClass>
    						</manifest>
    					</archive>
    				</configuration>
    			</plugin>
    			<plugin>
    				<artifactId>Maven-assembly-plugin</artifactId>
    				<configuration>
    					<appendAssemblyId>false</appendAssemblyId>
    					<descriptors>
    					    <!--指定详细的外部配置,读取这个文件,防止pom.xml过于臃肿-->
    						<descriptor>packconf/package.xml</descriptor>
    					</descriptors>
    
    				</configuration>
    				<!--下面是为了使用 mvn package命令,如果不加则使用mvn assembly -->
    				<executions>
    					<execution>
    						<id>make-assembly</id>
    						<phase>package</phase>
    						<goals>
    							<goal>assembly</goal>
    						</goals>
    					</execution>
    				</executions>
    			</plugin>
    
    		</plugins>
    	</build>
    

    Maven-assembly-plugin引用的package.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <assembly>
    	<id>bin</id>
    	<!-- 最终打包成一个用于发布的zip文件 -->
    	<formats>
    		<format>zip</format>
    	</formats>
    	<!-- Adds dependencies to zip package under lib directory -->
    	<dependencySets>
    		<dependencySet>
    			<!-- 不使用项目的artifact,第三方jar不要解压,打包进zip文件的lib目录 -->
    			<useProjectArtifact>true</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文件的conf目录 -->
    		<fileSet>
    			<directory>${project.basedir}/conf</directory>
    			<outputDirectory>conf</outputDirectory>
    			<includes>
    				<include>*</include>
    			</includes>
    		</fileSet>
    
    		<!-- 把项目的脚本文件目录( src/main/scripts )中的启动脚本文件,打包进zip文件的跟目录 -->
    		<fileSet>
    			<directory>${project.build.scriptSourceDirectory}</directory>
    			<outputDirectory></outputDirectory>
    			<includes>
    				<include>startup.*</include>
    			</includes>
    		</fileSet>
    
    		<!-- 把项目自己编译出来的jar文件,打包进zip文件的根目录 -->
    		<fileSet>
    			<directory>${project.build.directory}</directory>
    			<outputDirectory></outputDirectory>
    			<includes>
    				<include>*.jar</include>
    			</includes>
    		</fileSet>
    	</fileSets>
    </assembly>
    

    问题记录:

    1. Java代码读取不到jar包外部配置文件

    项目发布的时候通常会修改配置文件,这种情况下就需要把配置文件放到jar外部读取而不能直接打到jar包内。默认的config.properties文件是放在src/main/resources路径,即classpath下的,采用如下代码读取,构建后config.properties文件被打到了conf下,尝试多种方案,即使将"config.properties"加上相对路径也读取不到,若用System.getProperty("user.dir")这种方法在IDE下就不能运行了,因此亟需找到一个两全其美的办法同时支持在IDE下读取和构建后的外部目录读取。

    原读取方法:

    InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("conf/config.properties");   
    Properties p = new Properties();   
    try {   
       p.load(inputStream);   
    } catch (IOException e1) {   
       e1.printStackTrace();   
    }  
    

    解决方案:

    1). 将config.properties和database.properties从src/main/resources移到项目根目录的普通文件夹conf

    2). 修改读取方式为文件流

    try {
    	Properties properties = new Properties();
    	// 1.加载properties文件
    	InputStream is =new FileInputStream("conf/config.properties");
    	// 2.加载输入流
    	properties.load(is);
    } catch (Exception e) {
    	logger.error("读取配置文件config.properties错误");
    }
    
    1. 本地jar包打包后Maven无法加载

    项目中需要引入一个my-Entry.jar的加密jar包,这个包Maven仓库中是没有的。回忆一下前面提到的依赖的system作用域,因此采用如下方式导入了该jar包,但是打包后调用该包内方法时提示Class Not Found。

    <dependency>
    	<groupId>com.cat</groupId>
    	<artifactId>my-Entry</artifactId>
    	<!--注意这个版本号,下面会用到-->
    	<version>1.0</version>
    	<scope>system</scope>
    	<systemPath>${project.basedir}/libs/my-Entry.jar</systemPath>
    </dependency>
    

    这是因为scope为system作用域时不参与运行时,解决这个问题有两种方案:

    解决方案:

    1)将该jar安装到本地仓库

    执行以下命令,发布到本地仓库,然后修改pom.xml将scope标签去掉即可。

    mvn install:install-file -Dfile=D:\my-Entry.jar -DgroupId=com.cat -DartifactId=ccb-Entry -Dversion=1.0 -Dpackaging=jar
    

    2)将外部包加入主jar包META-INF下的MANIFEST.MF文件

    这个MANIFEST.MF里指定了外部依赖的jar包查找路径,需要在在Maven-jar-plugin 里配置Class-Path。

    <plugin>
    	<groupId>org.apache.Maven.plugins</groupId>
    	<artifactId>Maven-jar-plugin</artifactId>
    	<configuration>
    		<archive>
    			<addMavenDescriptor>false</addMavenDescriptor>
    			<!-- Manifest specific configuration -->
    			<manifest>
    				<addClasspath>true</addClasspath>
    				<classpathPrefix>lib/</classpathPrefix>
    				<!-- 此处指定main方法入口的class -->
    				<mainClass>com.cat.bank.main.Luncher</mainClass>
    			</manifest>
    			<manifestEntries>
    			    <!--注意这里要加上-1.0版本号,就是你引入本地依赖时指定的那个version-->
                    <Class-Path>lib/my-Entry-1.0.jar</Class-Path>
                </manifestEntries>
    		</archive>
    	</configuration>
    </plugin>
    

    现在用解压软件打开bankServer.jar主jar文件会发现MANIFEST.MF文件中已经加上了my-Entry.jar。但是这时这个my-Entry.jar并没有发布到lib文件夹下,我们需要再配置Maven-assembly-plugin将scope为system的依赖也发布到lib目录,或者可以直接拷贝过去。

    在package.xml中追加一行配置,这样就可以正常打包运行啦~

    	<dependencySets>
    		<dependencySet>
    			<!-- 不使用项目的artifact,第三方jar不要解压,打包进zip文件的lib目录 -->
    			<useProjectArtifact>true</useProjectArtifact>
    			<outputDirectory>lib</outputDirectory>
    			<unpack>false</unpack>
    		</dependencySet>
    		<!--将<scope>system</scope>也发布到lib-->
    		<dependencySet>
    			<useProjectArtifact>true</useProjectArtifact>
    			<outputDirectory>lib</outputDirectory>
    			<unpack>false</unpack>
    			<scope>system</scope>
    		</dependencySet>
    	</dependencySets>
    
    展开全文
  • Springboot项目中大部分需要的jar都可以通过maven中央仓库或公司内部自己搭的maven库获得,但有些情况下确实需要集成仓库上没有的jar。 用下面的方式引入外部jar, <dependency> <groupId>...
  • 方式2:编译阶段指定外部lib <plugin> <artifactId>maven-compiler-pluginartifactId> <version>2.3.2version> <configuration> <source>1.8source> <target>1.8target> <encoding>UTF-8encoding> ...
  • 我的项目下在src下创建了lib文件夹存放了一个jar包,用maven打包时,提示找不到 编译jar包解决方法 <build> <plugins> <plugin> <artifactId>maven-compiler-plugin</...
  • maven打包时,lib文件夹下的jar无法加载(程序包不存在) 程序能正常run、debug,但是使用maven进行 package打包时,却出现" java: 程序包xxxx不存在"的问题。解决办法如下: 在pom.xml中加入如下代码: <plugin...
  • Maven打包(瘦身打包部署),不包含第三方依赖jar包
  • maven打包记录 包含本地jar包 全局只修改pom.xml即可 添加依赖 1、groupId随便填 2、artifactId随便填 3、version随便填 4、scope填system 5、systemPath填jar包路径,${project.basedir}为当前项目路径 <...
  • 学习并使用maven有一段时间了,就想把一路上关于maven的问题总结一下。 首先一定要配置好maven的环境变量,cmd打开输入mvn -v确认一下,具体配置这里就不说了,这是基操。 1.jar包下载慢和plugins下载错误,依赖不...
  • 常用MAVEN打包方式总结

    万次阅读 2017-05-09 18:26:02
    几种常用的maven打包插件总结: 一、自带插件: maven自带的核心插件为Build plugins和Reporting plugins。 mvn compile编译源码实际上就利用到了maven-compiler-plugin,其他phase也类似用到了相应的插件 关于...
  • 一、前言: 最近需要把项目打成jar,并部署在windows环境,记录下部署过程。 二:首先项目结构: 其中libs文件夹是需要手动导入的jar,无法从maven远程仓库中下载的。由于在执行 maven ...所以在用maven打包...
  • 然后使用maven命令进行打包即可: install -Dmaven.test.skip=true 第二种方式 在pom.xml中通过以下方式引入lib中的每个依赖 <groupId>com.xxx.www</groupId> <artifactId>out-jar-1 <version>...
  • maven打包找不到本地jar包的解决方法

    万次阅读 2018-03-14 10:37:16
    有时候我们在项目中会引入一些本地jar包,在maven打包时会找不到这些jar,我们需要在pom.xml中的 &lt;pluginManagement&gt; &lt;plugins&gt; &lt;/plugins&gt; &lt;/...
  • 修改pom文件中的bootclasspth路径为${java.home}/lib/rt.jar;${java.home}/lib/jce.jar windows为分号 linux为冒号 转载于:https://www.cnblogs.com/rookie404/p/5858946.html
  • maven打包问题

    2019-10-03 20:18:46
    Maven项目中如何同时Install成JAR和WAR包 - ITQingChun - CSDN博客 ...maven打包web项目时同时打包为war和jar文件的方法_java_脚本之家 maven deploy -e -U -B 等集成命令 - healer的博客 - CSDN博客 总结 pom.xm...
  • 2.依赖的所有maven jar包 3.可运行的工程jar文件的存放路径 (打开后是.class文件) 4.源代码的jar包(打开后是.java源文件)---四部分的jar全部放到lib目录中 二 启动命令位置 把放在根目录(不一定是根目录)...
  • <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> ...
  • maven打包本地jar包的正确方法

    千次阅读 2018-09-04 10:15:26
    pom文件添加如下两个配置: &amp;lt;plugin&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&...spring-boot-maven-plugin&amp;lt;/artifactId&amp;gt; &amp;lt;con
  • ant集成maven打包

    2018-06-28 18:38:00
    -- maven libs download --> <target name="mvn-download-libs"> <artifact:dependencies filesetId="dependency.fileset" usescope="compile" pomrefid="maven.project"/>  ${mvn.lib.dir}">   ...
  • Maven 打包 上传 运行

    2017-12-27 15:10:55
    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.x
  • 使用springCloud的过程中,发布到生产环境的网速受限,如果每次将60,70M甚至更大的jar包...配置文件也是一样,每次修改了才需要修改服务器文件,如果只是单纯的代码更新,我们直接打包上传源码jar包就可以了。直接上...
  • maven将lib打包进jar

    千次阅读 2021-03-12 16:14:06
    maven build插件设置 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <configuration> <descriptorRefs> ...
  • idea springboot maven 打包jar 包含本地jar

    千次阅读 2018-06-26 18:39:05
    如果需要在打包的时候依赖本地jar,需要修改增加如下配置:&lt;plugin&gt; &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt; &lt;artifactId&gt;maven-compiler-plugin&...
  • 如果整体打包,我们每次修改代码后都要整体上传,非充耗费时间 因此我们希望将依赖的三方jar包与我们自己开发写的代码分开打包, 这样我们修改了代码,只需要上传自己写的很小的包这样会快很多.... 2.具体步骤 修改...
  • <p>IDEA中用maven的工具未项目打包时,找不到部分jar包,我提前已经clear了,当时maven的compile、packge、install都不好使。显示程序包不存在,其中(这些包不在pom依赖中的,...
  • 只需要在 maven 文件里加上这个配置就可以了  &lt;!-- geelynote maven的核心插件之-complier插件默认只支持编译Java 1.4,因此需要加上支持高版本jre的配置,在pom.xml里面加上 增加编译插件 --&gt; &...
  • maven打包配置

    千次阅读 2019-07-02 17:53:48
    对于第三方引入的jar包,如果通过 ${project.basedir}加载项目中的第三方jar包,可以编译运行,但是第三方jar包打不进去,具体可以看下一篇 ...project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:x...
  • 现如今,使用spring-boot和maven开发项目已经越来越普遍了,同时大多时候我们也是通过maven以及公共的repo和私服repo来管理自己的jar包依赖,但难免会碰到有些jar包需要放在本地,通过本地jar包的形式加载到自己的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,670
精华内容 2,668
关键字:

libsmaven打包

友情链接: OCAD2011.rar