精华内容
下载资源
问答
  • maven打包

    2020-12-22 16:10:27
    1. 背景工程中免不了要通过maven打包。2. maven三种打包插件pluginfunctionsitemaven-jar-pluginmaven 默认打包插件,用来创建 project jarmaven-shade-plugin用来打可执行包,executable(fat) jarhttp://maven....

    1. 背景

    工程中免不了要通过maven打包。

    2. maven三种打包插件

    plugin

    function

    site

    maven-jar-plugin

    maven 默认打包插件,用来创建 project jar

    maven-shade-plugin

    用来打可执行包,executable(fat) jar

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

    maven-assembly-plugin

    支持定制化打包方式,例如,apache 项目的打包方式

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

    我们主要打zip包,也就是使用maven-assembly-plugin。

    3. maven assembly plugin

    maven assembly plugin允许用户将依赖项、模块、文档和其他文件聚合到一个可发布的归档文件中。

    我们可以通过预制的描述文件打包文件,这些描述可以处理常见操作,比如打包工程包和文件到一个zip文件里面。

    其实我们也可以自定义描述文件对依赖包,模块,file-sets和单个文件更高级别的控制。

    当前支持如下格式的文件打包:

    zip

    tar

    tar.gz (or tgz)

    tar.bz2 (or tbz2)

    tar.snappy

    tar.xz (or txz)

    jar

    dir

    war

    and any other format that the ArchiveManager has been configured for

    假如你想把工程打包成一个uber-jar,可以参考Maven Shade Plugin,不在本文讨论范围。

    使用maven assembly plugin的步骤如下:

    在工程的pom.xml文件里面配置assembly plugin

    运行mvn assembly:single命令

    4. 实例

    首先给个官方的demo地址

    4.1 创建一个maven工程mvnassembly

    为了演示创建lib文件夹,放入随意两个jar包,创建资源目录src/main/resources,并随机放入一个文件。

    创建完之后目录结构如下:

    4.2 自定义assembly描述文件-assembly.xml

    assembly.xml文件与pom.xml同级,内容如下:

    描述文件格式请参考:http://maven.apache.org/components/plugins/maven-assembly-plugin/assembly.html

    myzip

    zip

    lib

    lib

    src/main/resources

    .

    lib

    false

    runtime

    4.3 在工程的pom.xml文件里面配置assembly plugin

    4.0.0

    com.lujiango

    mvnassembly

    0.0.1-SNAPSHOT

    jar

    mvnassembly

    http://maven.apache.org

    UTF-8

    junit

    junit

    3.8.1

    test

    org.apache.commons

    commons-collections4

    4.0

    org.apache.maven.plugins

    maven-assembly-plugin

    2.2

    assembly.xml

    make-assembly

    package

    single

    4.4 打包

    因为我使用的是eclipse,所以我直接通过右击工程->Run As-> Maven clean,然后在右击工程->Run As->Maven install,就可以打包了。

    4.5 检查zip包

    打出的包为mvnassembly-0.0.1-SNAPSHOT-myzip.zip,符合artifactId-version-id.zip命名格式。

    打开zip包,是一个文件夹:

    点击进入:

    进入lib目录:

    验证是OK。

    展开全文
  • Maven打包技巧

    千次阅读 2020-12-20 00:03:48
    打包“这个词听起来比较土,比较正式的说法应该是”构建项目软件包“,具体说就是将...作为一款”打包工具“,Maven自然有义务帮助用户创建各种各样的包,规范的JAR包和WAR包自然不再话下,略微复杂的自定义打包...

    “打包“这个词听起来比较土,比较正式的说法应该是”构建项目软件包“,具体说就是将项目中的各种文件,比如源代码、编译生成的字节码、配置文件、文档,按照规范的格式生成归档,最常见的当然就是JAR包和WAR包了,复杂点的例子是,它有自定义的格式,方便用户直接解压后就在命令行使用。作为一款”打包工具“,Maven自然有义务帮助用户创建各种各样的包,规范的JAR包和WAR包自然不再话下,略微复杂的自定义打包格式也必须支持,本文就介绍一些常用的打包案例以及相关的实现方式,除了前面提到的一些包以外,你还能看到如何生成源码包、Javadoc包、以及从命令行可直接运行的CLI包。

    Packaging的含义

    任何一个Maven项目都需要定义POM元素packaging(如果不写则默认值为jar)。顾名思义,该元素决定了项目的打包方式。实际的情形中,如果你不声明该元素,Maven会帮你生成一个JAR包;如果你定义该元素的值为war,那你会得到一个WAR包;如果定义其值为POM(比如是一个父模块),那什么包都不会生成。除此之外,Maven默认还支持一些其他的流行打包格式,例如ejb3和ear。你不需要了解具体的打包细节,你所需要做的就是告诉Maven,”我是个什么类型的项目“,这就是约定优于配置的力量。

    为了更好的理解Maven的默认打包方式,我们不妨来看看简单的声明背后发生了什么,对一个jar项目执行mvn package操作,会看到如下的输出:

    [INFO] --- maven-jar-plugin:2.3.1:jar (default-jar) @ git-demo ---

    [INFO] Building jar: /home/juven/git_juven/git-demo/target/git-demo-1.2-SNAPSHOT.jar

    相比之下,对一个war项目执行mvn package操作,输出是这样的:

    [INFO] --- maven-war-plugin:2.1:war (default-war) @ webapp-demo ---

    [INFO] Packaging webapp

    [INFO] Assembling webapp [webapp-demo] in [/home/juven/git_juven/webapp-demo/target/webapp-demo-1.0-SNAPSHOT]

    [INFO] Processing war project

    [INFO] Copying webapp resources [/home/juven/git_juven/webapp-demo/src/main/webapp]

    [INFO] Webapp assembled in [90 msecs]

    [INFO] Building war: /home/juven/git_juven/webapp-demo/target/webapp-demo-1.0-SNAPSHOT.war

    对应于同样的package生命周期阶段,Maven为jar项目调用了maven-jar-plugin,为war项目调用了maven-war-plugin,换言之,packaging直接影响Maven的构建生命周期。了解这一点非常重要,特别是当你需要自定义打包行为的时候,你就必须知道去配置哪个插件。一个常见的例子就是在打包war项目的时候排除某些web资源文件,这时就应该配置maven-war-plugin如下:

    org.apache.maven.plugins

    maven-war-plugin

    2.1.1

    src/main/webapp

    **/*.jpg

    源码包和Javadoc包

    本专栏的《坐标规划》一文中曾解释过,一个Maven项目只生成一个主构件,当需要生成其他附属构件的时候,就需要用上classifier。源码包和Javadoc包就是附属构件的极佳例子。它们有着广泛的用途,尤其是源码包,当你使用一个第三方依赖的时候,有时候会希望在IDE中直接进入该依赖的源码查看其实现的细节,如果该依赖将源码包发布到了Maven仓库,那么像Eclipse就能通过m2eclipse插件解析下载源码包并关联到你的项目中,十分方便。由于生成源码包是极其常见的需求,因此Maven官方提供了一个插件来帮助用户完成这个任务:

    org.apache.maven.plugins

    maven-source-plugin

    2.1.2

    attach-sources

    verify

    jar-no-fork

    类似的,生成Javadoc包只需要配置插件如下:

    org.apache.maven.plugins

    maven-javadoc-plugin

    2.7

    attach-javadocs

    jar

    为了帮助所有Maven用户更方便的使用Maven中央库中海量的资源,中央仓库的维护者强制要求开源项目提交构件的时候同时提供源码包和Javadoc包。这是个很好的实践,读者也可以尝试在自己所处的公司内部实行,以促进不同项目之间的交流。

    可执行CLI包

    除了前面提到了常规JAR包、WAR包,源码包和Javadoc包,另一种常被用到的包是在命令行可直接运行的CLI(Command Line)包。默认Maven生成的JAR包只包含了编译生成的.class文件和项目资源文件,而要得到一个可以直接在命令行通过java命令运行的JAR文件,还要满足两个条件:

    JAR包中的/META-INF/MANIFEST.MF元数据文件必须包含Main-Class信息。

    项目所有的依赖都必须在Classpath中。

    Maven有好几个插件能帮助用户完成上述任务,不过用起来最方便的还是maven-shade-plugin,它可以让用户配置Main-Class的值,然后在打包的时候将值填入/META-INF/MANIFEST.MF文件。关于项目的依赖,它很聪明地将依赖JAR文件全部解压后,再将得到的.class文件连同当前项目的.class文件一起合并到最终的CLI包中,这样,在执行CLI JAR文件的时候,所有需要的类就都在Classpath中了。下面是一个配置样例:

    org.apache.maven.plugins

    maven-shade-plugin

    1.4

    package

    shade

    com.juvenxu.mavenbook.HelloWorldCli

    上述例子中的,我的Main-Class是com.juvenxu.mavenbook.HelloWorldCli,构建完成后,对应于一个常规的hello-world-1.0.jar文件,我还得到了一个hello-world-1.0-cli.jar文件。细心的读者可能已经注意到了,这里用的是cli这个classifier。最后,我可以通过java -jar hello-world-1.0-cli.jar命令运行程序。

    自定义格式包

    实际的软件项目常常会有更复杂的打包需求,例如我们可能需要为客户提供一份产品的分发包,这个包不仅仅包含项目的字节码文件,还得包含依赖以及相关脚本文件以方便客户解压后就能运行,此外分发包还得包含一些必要的文档。这时项目的源码目录结构大致是这样的:

    pom.xml

    src/main/java/

    src/main/resources/

    src/test/java/

    src/test/resources/

    src/main/scripts/

    src/main/assembly/

    README.txt

    除了基本的pom.xml和一般Maven目录之外,这里还有一个src/main/scripts/目录,该目录会包含一些脚本文件如run.sh和run.bat,src/main/assembly/会包含一个assembly.xml,这是打包的描述文件,稍后介绍,最后的README.txt是份简单的文档。

    我们希望最终生成一个zip格式的分发包,它包含如下的一个结构:

    bin/

    lib/

    README.txt

    其中bin/目录包含了可执行脚本run.sh和run.bat,lib/目录包含了项目JAR包和所有依赖JAR,README.txt就是前面提到的文档。

    描述清楚需求后,我们就要搬出Maven最强大的打包插件:maven-assembly-plugin。它支持各种打包文件格式,包括zip、tar.gz、tar.bz2等等,通过一个打包描述文件(该例中是src/main/assembly.xml),它能够帮助用户选择具体打包哪些文件集合、依赖、模块、和甚至本地仓库文件,每个项的具体打包路径用户也能自由控制。如下就是对应上述需求的打包描述文件src/main/assembly.xml:

    bin

    zip

    true

    lib

    /

    README.txt

    src/main/scripts

    /bin

    run.sh

    run.bat

    首先这个assembly.xml文件的id对应了其最终生成文件的classifier。

    其次formats定义打包生成的文件格式,这里是zip。因此结合id我们会得到一个名为hello-world-1.0-bin.zip的文件。(假设artifactId为hello-world,version为1.0)

    dependencySets用来定义选择依赖并定义最终打包到什么目录,这里我们声明的一个depenencySet默认包含所有所有依赖,而useProjectArtifact表示将项目本身生成的构件也包含在内,最终打包至输出包内的lib路径下(由outputDirectory指定)。

    fileSets允许用户通过文件或目录的粒度来控制打包。这里的第一个fileSet打包README.txt文件至包的根目录下,第二个fileSet则将src/main/scripts下的run.sh和run.bat文件打包至输出包的bin目录下。

    打包描述文件所支持的配置远超出本文所能覆盖的范围,为了避免读者被过多细节扰乱思维,这里不再展开,读者若有需要可以去参考这份文档。

    最后,我们需要配置maven-assembly-plugin使用打包描述文件,并绑定生命周期阶段使其自动执行打包操作:

    org.apache.maven.plugins

    maven-assembly-plugin

    2.2.1

    src/main/assembly/assembly.xml

    make-assembly

    package

    single

    运行mvn clean package之后,我们就能在target/目录下得到名为hello-world-1.0-bin.zip的分发包了。

    小结

    打包是项目构建最重要的组成部分之一,本文介绍了主流Maven打包技巧,包括默认打包方式的原理、如何制作源码包和Javadoc包、如何制作命令行可运行的CLI包、以及进一步的,如何基于个性化需求自定义打包格式。这其中涉及了很多的Maven插件,当然最重要,也是最为复杂和强大的打包插件就是maven-assembly-plugin。事实上Maven本身的分发包就是通过maven-assembly-plugin制作的,感兴趣的读者可以直接查看源码一窥究竟。

    =====================================================================

    将一个带有main函数的example.java打包成JAR(java文件必须带有main函数,这样打包成的JAR才能双击直接运行)

    一、编译example.java,得到example.class文件

    二、准备一个清单文件manifest.mf,此文件和example.class在同一目录里

    可以先建一个mainfest.txt文件,然后再把扩展名改成.mf

    用记事本打开manifest.mf,在里面输入

    main-class: example

    (注意冒号后有一个空格,而且example后必须有一个换行)

    三、打开命令提示符(前提是系统的path路径和classpath路径都已经设置好了),在里面输入

    jar cvfm example.jar manifest.mf example.class

    (c:新建一个JAR文件

    v:输出打包结果

    f:JAR文件名

    m:清单文件名)

    四、如果example.java编译后得到多个class文件,例如:example1.class、example2.class

    则在CMD里输入

    jar cvfm example.jar manifest.mf example1.class example2.class

    五、若得到多个编译文件,也可以将这些class文件全部移入一个新的文件夹(例如classes文件夹,classes文件夹和manifest.mf文件在同一目录)

    然后在CMD里输入:

    jar cvfm example.jar manifest.mf -C classses/ .

    (/和.之间有一个空格)

    展开全文
  • maven 打包详解

    2021-06-09 13:27:33
    maven 打包详解 方法一:使用maven-jar-plugin和maven-dependency-plugin插件打包 方法二:使用maven-assembly-plugin插件打包 方法三:使用maven-shade-plugin插件打包

    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、要能加载到依赖包。

    使用Maven有以下几种方法可以生成能直接运行的jar包,可以根据需要选择一种合适的方法。

    方法一:使用maven-jar-plugin和maven-dependency-plugin插件打包

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

    <build>
            <plugins>
                <!--      配置打包,并配置MainClass, 但不将依赖包打包,会出现找不到依赖的异常    -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <configuration>
                        <archive>
                            <manifest>
                                <addClasspath>true</addClasspath>
                                <!--   MANIFEST.MF 中 Class-Path -->
                                <classpathPrefix>lib/</classpathPrefix>
                                <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
                <!--      配置依赖包      -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <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-assembly-plugin插件打包

    打包方式:

    mvn package assembly:single  
    

    配置方式:

    <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </plugin>
    

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

    此外还可以直接通过mvn package来打包,无需assembly:single,不过需要加上一些配置:

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <!-- 其中<phase>package</phase>、<goal>single</goal>即表示在执行package打包时,执行assembly:single -->
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    

    不过,如果项目中用到spring Framework,用这种方式打出来的包运行时会出错,使用下面的方法三可以处理。

    方法三:使用maven-shade-plugin插件打包

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <transformers>
                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <mainClass>cn.zoom.wqz.filter.Application</mainClass>
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
    

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

    如果项目中用到了Spring Framework,将依赖打到一个jar包中,运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas,如果生成一个jar包会互相覆盖。为了避免互相影响,可以使用AppendingTransformer来对文件内容追加合并:

    <plugin>
            <groupid>org.apache.maven.plugins</groupid>
            <artifactid>maven-shade-plugin</artifactid>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.manifestresourcetransformer">
                                <mainclass>cn.zoom.wqz.filter.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>
    

    如果不是springboot 但是想要运行指定的main方法入口的时候,需要在pom文件中指定,打包的时候才能写入。以上的方法有提到使用maven-assembly-plugin插件来打包的时候会生成两个jar,使用是后缀为xxxx-jar-with-dependencies.jar 这个包
    希望本篇文章能够对你有所帮助,我因为这个找不到main入口,花费了大量的时间。

    展开全文
  • maven 打包包含依赖

    千次阅读 2020-12-31 02:45:22
    Maven打包,包含第三方依赖失败目标 1. 将依赖第三方jar包都打进去2. 将工程java 目录下所有文件夹和配置文件,包括资源文件都打入jar包,根据目录来3. 打出jar文件可直接运行方法:采用 maven-assembly-plugin环境:...

    Maven打包,包含第三方依赖失败

    目标 1. 将依赖第三方jar包都打进去2. 将工程java 目录下所有文件夹和配置文件,包括资源文件都打入jar包,根据目录来3. 打出jar文件可直接运行方法:采用 maven-assembly-plugin环境:IDEA 14.1.5 JDK 1.8其中**/*写法,是为了保证各级子目录下的资源文件被打包,svn相关文件排除。

    pom.xml 写法src/main/java**/***/.svn/*falseorg.apache.maven.pluginsmaven-compiler-plugin2.3.21.8

    java maven 打包怎么只带部分依赖

    addClasspath>javamaven-war-pluginorg.apache;artifactId>goals>copy-dependenciesmainClass>com.xx;outputDirectory>/artifactId>encoding>build>maven打包的时候有些jar包是不在mavencenter的。

    需要在pom中引入相关的本地jar包;execution>copyexecution>maven-jar-plugin/source>1.5&lt.apache.maven.pluginsUTF-8&lt。

    当然也是可以打包其他的文件的,诸如xml,properties等的;systemPath>/artifactId>org;manifest>/configuration>configuration>true&lt,可以使用plugin,默认将lib下的所有jar文件打包到WEB-INF/lib下.ik-analyzerplugin>artifactId>dependency>configuration>phase>installsystemorg.apache;/plugin>maven-dependency-plugin1.5/goal>version>2.3/archive>configuration>/configuration>/addClasspath>${project;warName>lib/WEB-INF/lib**/*.jar;groupId>ik-analyzermaven-compiler-pluginsourceDirectory>src/main/outputDirectory>${project.build.directory}3;/scope>${project;artifactId>

    maven provided jar 包也会打进去怎么解决

    注意scope标签,compile和runtime两种依赖打包时会打进去,provided、system、test都不会打进去。

    如果不想打包时将依赖包含进去,可以按实际情况选择后面的方式。

    maven本身引用时,在没有打包前,这些jar都是存储在maven的repository里面给所有项目共享的,这也是maven的目标之一。

    如下图,请看jar包的路径。

    用maven打包jar项目其中很多模块引用了相同jar包,如何把它些jar公...

    注意scope标签,compile和runtime两种依赖打包时会打进去,provided、system、test都不会打进去。

    如果不想打包时将依赖包含进去,可以按实际情况选择后面的方式。

    maven本身引用时,在没有打包前,这些jar都是存储在maven的repository里面给所有项目共享的,这也是maven的目标之一。

    如下图,请看jar包的路径。

    Maven依赖管理的jar文件在打包后可部署文件中的位置?

    使用maven-assembly-plugin,配合assembly.xml:org.apache.maven.pluginsmaven-assembly-plugin2.4truefalsesrc/main/assembly/assembly.xmltruejp.co.nec.nhm.df.entrance.Entrancemake-assemblypackageassembly

    怎么使用maven package命令

    此命令包含一系列过程:validate-->compile-->test-->package;Maven根据pom文件里packaging的配置,决定是生成jar文件还是war文件,并放到target目录下。

    (注:此命令需要在项目的根目录(也就是pom.xml文件所在的目录)下运行,Maven才知道打包哪个项目。

    )如何用maven打包可执行的jar方法一:将项目及所依赖的所有jar包打包成一个jar。

    1、pom.xml添加assembly插件 2、执行mvn assembly:assembly3、生成如文件4、执行java -jar quickstart-1.0.0-jar-with-dependencies.jar 备注:第2步的命令也可以改成mvn package,但需要更改pom.xml:方法二:将项目依赖的jar复制到一个目录中并在MANIFEST文件中添加Class-Path和Main-Class。

    1、在pom.xml中添加jar和dependency插件 2、执行mvn package 3、生成文件4、执行java -jar quickstart-1.0.0.jar...

    maven activebydefault不生效怎么办

    1.Java-maven异常-cannot be cast to javax.servlet.Filter 报错tomcat 启动后先将tomcat/lib目录下的jar包全部读入内存,如果webapps目录里的应用程序中WEB-INF/lib目录下有相同的包,将无法加载,报错的Filter实现了javax.servlet.Filter接口,Filter是在servlet-api.jar里。

    解决这个问题的方法就是对于servlet-ap.jar 使用 标签,编译的时候用到servlet-api和jsp-api,但在打包的时候不用这两个依赖。

    javax.servletservlet-api2.5provided中,它主要管理依赖的部署。

    目前可以使用5个值:* compile,缺省值,适用于所有阶段,会随着项目一起发布。

    * provided,类似compile,期望JDK、容器或使用者会提供这个依赖。

    如servlet.jar。

    * runtime,只在运行时使用,如JDBC驱动,适用运行和测试阶段。

    * test,只在测试时使用,用于编译和运行测试代码。

    不会随项目发布。

    *system,类似provided,需要显式提供包含依赖的jar,Maven不会在Repository中查找它。

    解决SpringBoot 不继承父 parent 打包不包含依赖的问题

    创建两个项目1. cdai_codebase_parent:其他项目的Maven配置都继承这个项目中pom.xml的定义。

    2. cdai_codebase_ssh:一个SSH示例项目,继承parent项目中的配置。

    首先看cdai_codebase_parent中pom.xml的内容:通过将packaging属性定义为pom来说明当前pom.xml是用来被继承的。

    之后在parent的pom.xml中,我们可以定义一些统一的版本号(Spring等第三方包的),依赖项(所有项目都会用的JUnit),以及通用的打包配置等。

    现在,我们就可以在cdai_codebase_ssh中,通过项目的相对路径引用这个parent的pom.xml文件了。

    附:在父pom.xml中dependencyManagement中定义需要被继承的依赖,然后在子pom.xml中可以直接指定groupId和artifactId来引入,就不需要版本号了。

    展开全文
  • maven打包流程学习

    千次阅读 2020-12-22 16:10:34
    前言:最近工作中遇到了几次跟maven打包相关的问题,每个问题上网查资料解决都花了不少时间,很影响工作进度。既然遇到好几次,每次都能发现知识盲点,干脆总结整理一下,啃掉这个难啃的骨头。ps:最近看到了一个很...
  • 自定义Maven打包插件

    2020-12-21 23:28:00
    自定义Maven打包插件实战 打包业务描述:   打包时,根据需要打包的模块.json配置文件,动态打入自己需要的Controller,排除掉不需要的模块Controller类。 打包插件设计思路: 插件使用如下: 一 、先
  • maven 打包排除配置文件

    千次阅读 2020-12-20 06:30:10
    如果你想通过pom.xml文件的配置实现的话,你可以这样1、打jar包时过滤配置文件src/main/resources**/*true..............2、在plugins中添加插件org.apache.maven.pluginsmaven-resources-plugincopy-...
  • 1.概述  这篇IntelliJ IDEA自身以及maven项目打包方式(单模块)博文主要是描述项目下单个模块的...2.maven打包方式(多模块)  这里我们主要采用的是maven-assembly-plugins插件进行zip打包。以下面为例:    asse...
  • Maven打包速率优化

    2021-12-09 20:50:54
    单一服务如果包含的module太多,传统的单线程maven构建时候速度就会比较慢,可以使用本文中的...跳过测试代码,且使用多线程打包,多线程打包时保证单个CPU有一个线程 mvn clean install -T 1C -Dmaven.test.skip=...
  • Maven打包到指定位置

    2021-11-27 20:13:51
    方式一:通过maven-jar-plugin指定outputDirectory输出路径 方式二:通过maven-resources-plugin指定outputDirectory输出路径 方式三:通过maven-antrun-plugin复制jar包 方式四:通过maven-antrun-plugin嵌入...
  • maven打包包含注释

    2020-12-19 07:53:45
    maven打包之后为什么class文件中没有注释了目标 1. 将依赖第三方jar包都打进去2. 将工程java 目录下所有文件夹和配置文件,包括资源文件都打入jar包,根据目录来3. 打出jar文件可直接运行方法:采用 maven-assembly-...
  • Ubuntu Maven打包项目

    2021-02-01 20:20:09
    maven安装与配置 下载maven https://downloads.apache.org/maven/maven-3/3.6.3/binaries/ 下载zip包 安装unzip并解压 $ sudo apt-get install unzip $ unzip apache-maven-3.6.3-bin.zip 配置环境变量 $ sudo...
  • 详解Maven打包和运行

    2021-03-14 19:32:36
    将项目进行编译、测试之后,接下来就是打包(package),我们的pom.xml中没有指定打包类型,那么使用默认打包类型jar,简单的执行命令mvn clean package进行打包从输出内容可以看出,Maven打包之前进行了编译、测试...
  • maven打包项目配置

    2021-03-16 10:29:52
    关于maven打包项目 1、pom.xml中添加如下配置(其中build与dependencies平级) <build> <finalName>RobotData</finalName> <plugins> <plugin> <groupId>org.apache....
  • maven打包插件

    2021-04-04 22:00:10
    maven打包插件 nohup java -jar xxx.jar >log.txt & <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <...
  • 今天在使用maven打包时出现错误,因此记录一下。。 出现错误的原因是因为maven中的指定的java版本与项目使用的java版本不一致导致的。。 maven中的java版本为11 而项目使用版本为1.8 因此会出现如下错误 解决...
  • maven打包原理

    2021-04-26 15:06:38
    一、Maven中央存储库当你建立一个 Maven 的项目,Maven 会检查你的 pom.xml 文件,以确定哪些依赖下载。首先,Maven 将从本地资源库获得 Maven 的本地资源库依赖资源,如果没有找到,然后把它会从默认的 Maven 中央...
  • 使用maven打包普通的java项目这篇文章介绍如何使用quickstart maven模板创建maven项目。并且将这个项目打包成jar包。方便再其他机器上面运行。使用quickstart模板,创建maven项目具体步骤新建一个Module,然后按照下...
  • maven-assembly-plugin插件可用于为maven项目打包,可指定打包的类型,下面通过一个demo来说明使用方法。示例项目结构: pom配置:xmlns:xsi=...
  • Maven引入本地Jar包并打包进War包中1.概述在平时的开发中,有一些Jar包因为种种原因,在Maven的中央仓库中没有收录,所以就要使用本地引入的方式加入进来。2. 拷贝至项目根目录项目根目录即pom.xml文件所在的同级...
  • Maven打包 package出两个jar包,一个只包含自己写的代码,一个包含所有导入依赖的jar包,俗称胖jar包。 <!-- project下--> <build> <plugins> <!--scala编译插件--> <plugin> &...
  • <build> <finalName>${artifactId}</finalName> <plugins> <plugin> <groupId>org.springframework.boot<...spring-boot-maven-plugin</artifactId> ...
  • maven 打包时间戳问题

    2021-04-07 19:20:10
    maven 打包时,可以生成时间戳属性,利用该属性来组装包名。 <version>5.0.${build.time}B</version> <properties> <maven.build.timestamp.format>yyyyMMddHHmmss</maven.build....
  • maven打包,内存溢出

    2021-10-25 09:48:18
    配置环境变量:MAVEN_OPTS = -Xms512m -Xmx1024m 然后在 path中加入%MAVEN_OPTS% 重新打包解决! IDEA 打包出现 Java heap space 找到 FIile - Settings - Build,Execution,Deployment - Build Tools...
  • 在 pom.xml 配置文件中添加以下插件: <build> <...org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <version>2.4</vers
  • maven打包时缺少文件1、操作2、现象(错误信息)3、原因4、解决 1、操作 maven项目打包 2、现象(错误信息) maven项目打包时 ,src/main/java目录下的xml等资源文件打包不进去 3、原因 默认maven在src/main/java中...
  • maven打包配置较全

    2021-01-27 08:14:24
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">4.0.0...
  • 编写java后,一般都是通过打包生成jar、war包提供使用,一般在打包后都会在jar包中生成MANIFEST.MF文件 编写一个简单的java文件。 package cn.kanyun; public class Hello { public static void main(String[]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,266
精华内容 63,706
关键字:

mavan打包