maven打jar包三种方式

maven打jar包的三种方式

千次阅读 2018-08-29 19:40:12

Maven打包的三种方式 Maven可以使用mvn package指令对项目进行打包，如果使用Java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置Main-Class）、...

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插件打包 
在pom.xml中配置： 
  
[html] view plain copy 
<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文件的部分内容，<mainClass>com.xxg.Main</mainClass>指定MANIFEST.MF中的Main-Class，<addClasspath>true</addClasspath>会在MANIFEST.MF加上Class-Path项并配置依赖包，<classpathPrefix>lib/</classpathPrefix>指定依赖包所在目录。 
例如下面是一个通过maven-jar-plugin插件生成的MANIFEST.MF文件片段： 
  
[plain] view plain copy 
Class-Path: lib/commons-logging-1.2.jar lib/commons-io-2.4.jar  
Main-Class: com.xxg.Main  
  
  
只是生成MANIFEST.MF文件还不够，maven-dependency-plugin插件用于将依赖包拷贝到<outputDirectory>${project.build.directory}/lib</outputDirectory>指定的位置，即lib目录下。 
配置完成后，通过mvn package指令打包，会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下，目录结构如下： 
 
指定了Main-Class，有了依赖包，那么就可以直接通过java -jar xxx.jar运行jar包。 
这种方式生成jar包有个缺点，就是生成的jar包太多不便于管理，下面两种方式只生成一个jar文件，包含项目本身的代码、资源以及所有的依赖包。 
方法二：使用maven-assembly-plugin插件打包 
在pom.xml中配置： 
  
[html] view plain copy 
<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>  
  
打包方式： 
  
[plain] view plain copy 
mvn package assembly:single  
  
打包后会在target目录下生成一个xxx-jar-with-dependencies.jar文件，这个文件不但包含了自己项目中的代码和资源，还包含了所有依赖包的内容。所以可以直接通过java -jar来运行。 
此外还可以直接通过mvn package来打包，无需assembly:single，不过需要加上一些配置： 
  
[html] view plain copy 
<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>  
            <executions>  
                <execution>  
                    <id>make-assembly</id>  
                    <phase>package</phase>  
                    <goals>  
                        <goal>single</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>  
  
    </plugins>  
</build>  

 其中<phase>package</phase>、<goal>single</goal>即表示在执行package打包时，执行assembly:single，所以可以直接使用mvn package打包。 
  
不过，如果项目中用到spring Framework，用这种方式打出来的包运行时会出错，使用下面的方法三可以处理。 
方法三：使用maven-shade-plugin插件打包 
在pom.xml中配置： 
  
[html] view plain copy 
<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文件包含了所有依赖，所以可以直接运行。 
  
如果项目中用到了Spring Framework，将依赖打到一个jar包中，运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，可以使用AppendingTransformer来对文件内容追加合并： 
  
[html] view plain copy 
<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>  
                            <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>

收起

展开全文

IDEA+Maven 打jar包

万次阅读 多人点赞 2018-04-13 10:08:28

IDEA+Maven 打jar包 （包涵依赖jar）写在前面：这两天一直在整（gu）理（dao）IDEA 用Maven打jar包，网上的教程是各式各样，但是都不能满足我的需求（或者还没有找个正确的），因此综合网上的内容自己整理...

IDEA+Maven 打jar包 （包涵依赖jar） 
最新修改
 以前写的打包方式可能看起来有些繁琐，这里给出进一步简洁的解决方案简单粗暴 
写在前面： 
 这两天一直在整（gu）理（dao）IDEA 用Maven打jar包，网上的教程是各式各样，但是都不能满足我的需求（或者 还没有找个正确的），因此 综合网上的内容 自己整理了一下（以下内容是在mac系统下 win 可能有一些地方不一样）。 
软件环境： 
 IDEA：2017.1.5 
 Maven：3.3.9 
打jar包： 
 IDEA 自带的打包工具使用 
   打无依赖jar包 
    如果工程目录中有以下文件夹 删掉
 
  
  点击工程上方【File】菜单选择【Project Structure】
 
点击【+】 选择【JAR】，【From modules with dependencies】点击【ok】
 
点击【1】选择你要打包的Module，点击【2】选择你的主类（也就是你的程序的入口）然后点击【ok】
点击【ok】
 
【1】是要打的jar包的名字，【2】是jar包的输出路径，【3】是程序所需要的jar依赖，【4】是程序主类的名称。因为这里是打没有依赖的jar包，所以将【3】里面不需要的jar包删掉就行。最后点击【ok】
然后就会生成一个META-INF的文件夹，里面就是一些配置属性 
  打包涵依赖jar包
 对以上的方式中的步骤6中 不做任何修改，然后执行步骤7
  
 
Maven 打包 
   打无依赖jar包 
     在pom.xml 文件里加入
  <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>2.4</version>
      <configuration>
        <archive>
              生成的jar中，不要包含pom.xml和pom.properties这两个文件
          <addMavenDescriptor>false</addMavenDescriptor>
          <manifest>
                是否要把第三方jar放到manifest的classpath中
            <addClasspath>true</addClasspath>
               生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/
            <classpathPrefix>lib/</classpathPrefix>
                应用的main class
            <mainClass>com.yourClass</mainClass>
          </manifest>
        </archive>
            过滤掉不希望包含在jar中的文件
        <excludes>
          <exclude>${project.basedir}/xml/*</exclude>
        </excludes>
     </configuration>
 </plugin> 
 
 点开Maven管理工具
 
 
 点击【package】
 
 
 等运行完以后就会生成jar包了
 
 
 
 
 打包涵依赖jar包
 第一种方法
 1. 在pom.xml文件中写入
   <build>
     <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
      </plugin>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.test.app</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
        <!--下面是为了使用 mvn package命令，如果不加则使用mvn assembly-->
        <executions>
          <execution>
            <id>make-assemble</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
     </plugins>
  </build>
 
    然后执行上面【Maven 打无依赖包】步骤2到步骤4
 第二种方法 
    在pom.xml文件中写入<plugin>
 <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <version>2.4</version>
  <configuration>
    <archive>
         <!-- 生成的jar中，不要包含pom.xml和pom.properties这两个文件-->
      <addMavenDescriptor>false</addMavenDescriptor>
      <manifest>
            <!--是否要把第三方jar放到manifest的classpath中-->
        <addClasspath>true</addClasspath>
           <!--生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，所以classpath的前缀是lib/-->
        <classpathPrefix>lib/</classpathPrefix>
           <!-- 应用的main class-->
        <mainClass>com.yourClass</mainClass>
      </manifest>
    </archive>
      <!--  过滤掉不希望包含在jar中的文件-->
    <excludes>
      <exclude>${project.basedir}/xml/*</exclude>
    </excludes>
 </configuration>
</plugin>

<plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-assembly-plugin</artifactId>
      <version>2.4</version>
      <configuration>
        <descriptors>
          <descriptor>src/main/assembly/package.xml</descriptor>
        </descriptors>
      </configuration>
      <executions>
        <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
 
创建【src/main/assembly】目录
创建package.xml文件<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>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/config</directory>
          <outputDirectory>config</outputDirectory>
          <includes>
              <include>*.xml</include>
              <include>*.properties</include>
          </includes>
      </fileSet>

      <!-- 把项目的脚本文件目录（ src/main/scripts ）中的启动脚本文件，打包进zip文件的跟目录 -->
      <fileSet>
          <directory>${project.build.scriptSourceDirectory}</directory>
          <outputDirectory></outputDirectory>
          <includes>
              <include>startup.*</include>
          </includes>
      </fileSet>

      <!-- 把项目的脚本文件（除了启动脚本文件），打包进zip文件的script目录 -->
      <fileSet>
          <directory>${project.build.scriptSourceDirectory}</directory>
          <outputDirectory></outputDirectory>

          <excludes>
              <exclude>startup.*</exclude>
          </excludes>
      </fileSet>

      <!-- 把项目自己编译出来的jar文件，打包进zip文件的根目录 -->
      <fileSet>
          <directory>${project.build.directory}</directory>
          <outputDirectory></outputDirectory>
          <includes>
              <include>*.jar</include>
          </includes>
      </fileSet>
  </fileSets>
</assembly>
 
将【package.xml】文件放入【assembly】文件夹中
 
然后执行上面【Maven 打无依赖包】步骤2到步骤4
 
  
如果要打包scala代码需要添加插件：
 方案一： 
 <plugin>
     <groupId>net.alchim31.maven</groupId>
     <artifactId>scala-maven-plugin</artifactId>
     <version>3.4.0</version>
     <executions>
         <execution>
             <goals>
                 <goal>compile</goal>
                 <goal>testCompile</goal>
             </goals>
         </execution>
     </executions>
 </plugin>
 
方案二： 
	<plugin>
		<groupId>org.scala-tools</groupId>
		<artifactId>maven-scala-plugin</artifactId>
 		<version>2.15.2</version>
 		<executions>
         	<execution>
            	 <goals>
                 	<goal>compile</goal>
                 	<goal>testCompile</goal>
            	 </goals>
         	</execution>
     	</executions>
	</plugin>
 
推荐方案一，方案二中的插件最新更新日期是2011年 
简单粗暴
 将下面的任意一种方案放到pom文件中，并修改成自己项目中的MainClass即可 
</plugins>
    </build>
     方案一 or 方案二
     <build>
<plugins>
 
方案一： 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.test.MainClass</mainClass>   <!--带有包路径的MainClass -->
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>
 
方案二： 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.test.MainClass</mainClass>   <!--带有包路径的MainClass -->
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>

    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>
 
注： 
本文属于作者原创，如需转载，请注明。 
内部如果引用的文字，连接，图片等资源存在侵犯原作者的情况，请联系本人，立即删除。

收起

展开全文

IDEA

maven工程打成jar包的三种方式

千次阅读 2019-07-12 09:20:31

第一种方法，把所有的jar包都打进一个jar包里面第二种方法，把jar包和所依赖的jar包分开打包第三种方法，把所依赖的jar包独立生成到target目录下，运行时手动指定target目录 1.把所有的jar包都打进一个jar包...

参考链接：https://www.cnblogs.com/GarfieldEr007/p/6995525.html 
打包一共有三种方式 
第一种方法，把所有的jar包都打进一个jar包里面 
第二种方法，把jar包和所依赖的jar包分开打包 
第三种方法，把所依赖的jar包独立生成到target目录下，运行时手动指定target目录 
1.把所有的jar包都打进一个jar包里面 
用maven创建一个新工程 
主类 
package com.ai.oidd;

import org.apache.commons.lang3.ClassUtils;

public class test {
    public static void main(String[] args) {
        System.out.println(ClassUtils.isPrimitiveOrWrapper(Integer.class)); //true
    }
} 
Pom配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ctc</groupId>
    <artifactId>mavenTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.ai.oidd.test</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project> 
接下来使用mvn package进行打包，用java -jar mavenTest-1.0-SNAPSHOT.jar进行运行 
2.分开打包 
把所有外部依赖的包都打一个包 
用maven创建一个新工程 
工程名为JarWithDependency 
（1）创建一个main类 
package com.ai.oidd;

import org.apache.commons.lang3.ClassUtils;

public class Test {
    public static void main(String[] args) {
        System.out.println(ClassUtils.isPrimitiveOrWrapper(Integer.class)); //true
        System.out.println("hello");
    }
} 
（2）pom配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com</groupId>
    <artifactId>JarWithDependency</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
                 <configuration>
                     <archive>
                         <manifest>
                             <mainClass>com.ai.oidd.Test</mainClass>
                         </manifest>
                     </archive>
                 </configuration>
        </plugin>

            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>attached</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project> 
（3）打包，会有两个jar包 
cd进入target目录 
java -cp JarWithDependency-1.0-SNAPSHOT-jar-with-dependencies.jar com.ai.oidd.Test 
第一个为所依赖的jar包打成的一个jar包，第二个为主类地址 
输出结果 
 
3.把引用的jar包引入到classpath里面，以java -cp的方式允许 
（1）先创建一个main类 
package com.ai.oidd;

import org.apache.commons.lang3.ClassUtils;

public class Test {
    public static void main(String[] args) {
        System.out.println(ClassUtils.isPrimitiveOrWrapper(Integer.class)); //true
        System.out.println("hello");
    }
} 
（2）pom文件 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com</groupId>
    <artifactId>JarWithDependency</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>src/main/java</sourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.ai.oidd.Test</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>
                                ${project.build.directory}
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project> 
外部依赖的包分开来，不会一起打成jar包 
 
cd到指定目录 
java -cp JarWithDependency-1.0-SNAPSHOT.jar:commons-lang3-3.9.jar com.ai.oidd.Test

收起

展开全文

打包

maven打jar包插件

千次阅读 2018-03-02 11:59:34

1. maven-assembly-plugin第一种方式 org.apache.maven.plugins maven-assembly-plugin 2.5.5 com.test.execute.Test

1. maven-assembly-plugin第一种方式 

      <!-- maven-assembly-plugin -->
      <!-- 打包方式：mvn package assembly:single  -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.5.5</version>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.test.execute.Test</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
D:\Tools\idea\oa\test\target>java -jar test-jar-with-dependencies.jar
Hello World!

 

 

 
2. maven-assembly-plugin第二种方式
 

      <!-- maven-assembly-plugin -->
      <!-- 打包方式：mvn package -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.5.5</version>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.test.execute.Test</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
D:\Tools\idea\oa\test\target>java -jar test-jar-with-dependencies.jar
Hello World!
 

  

  
3. maven-shade-plugin 

      <!-- maven-shade-plugin -->
      <!-- 打包方式：mvn package -->
      <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.test.execute.Test</mainClass>
                </transformer>
              </transformers>
            </configuration>
          </execution>
        </executions>
      </plugin>
D:\Tools\idea\oa\test\target>java -jar test.jar
Hello World!
D:\Tools\idea\oa\test\target>java -jar test-1.0-SNAPSHOT-shaded.jar
Hello World!

收起

展开全文

插件

Maven打jar包的三种方式
万次阅读 2020-05-20 19:23:25
目录不包含依赖jar包将依赖jar包输出到指定目录将项目依赖和项目打成一个jar包 不包含依赖jar包 该方法打包的jar，不包含依赖的jar包，也没有指定入口类。 <build> <plugins> <plugin> <!--...
收起
java
Maven打jar包包含源代码
千次阅读 2020-09-13 09:24:04
Maven打jar包包含源代码只需要在pom.xml 中配置如下插件即可 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <version...
收起
Maven打jar包,排除部分包
千次阅读 2018-07-18 20:51:42
用Maven打jar包时, 默认是src/main/java下的文件都会放到jar中。但我想有部分文件打包的时候不放到jar中。在ORM工具Bee框架中有一个例子（Bee是一个省时、易用、自动的ORM框架。... pom.xml具体设置如下： ...
收起
Bee ORM
springboot+maven 项目 打jar包之后部署并启动方式
千次阅读 2019-05-28 11:40:07
2、然后利用mvn package -DskipTests 打出jar包。 3、利用工具将jar包上传到linux服务器上面对应的位置。 4、之前如果部署过的话先用命令ps -ef | grep java 看下进程，然后再利用kill -9 把这个进程干掉。 5、...
收起
maven打jar包命令
千次阅读 2018-05-28 17:16:00
mvn -Dmaven.test.skip=true clean package 转载于:https://www.cnblogs.com/kdx-2/p/9101122.html
收起
maven打jar包并且包含部分依赖jar
千次阅读 2017-03-18 15:58:04
需求： maven 想做一个工具jar包，依赖公共jar 和自己的本地jar包，本地的jar包需要解压成class打到jar包内，而依赖的公共jar包则不需要踢出公共jar包 可以用的值的含义： compile，缺省值，适用于所有阶段，...
收起
Java
java打jar包的方式，jar命令，maven
千次阅读 2019-06-24 22:47:00
打jar包的几种方式 1.通过idea 的build artifacts 2. 通过maven插件打包 3. 通过jar命令打包 4. 把依赖打入jar包中 5. springboot项目打jar包 因为大部分时候是通过maven进行管理的，所以主要...
收起
打包 java
maven打jar包时配置文件打到包里并读取
千次阅读 2018-04-12 17:21:20
有需求需要用jar包运行程序,但是在正常时候配置文件还可以找到,在jar包中则不能找到后来发现原因,配置文件要放到resources下 ,这样maven打包时才会把jar包打进去目录结构:导入配置文件代码:...
收起
使用Maven 生成jar包的两种方式
千次阅读 2017-01-24 10:22:33
Maven可以使用mvn package指令对项目进行打包，如果使用java -jar xxx.jar执行运行jar文件，会出现"no main manifest attribute, in xxx.jar"（没有设置...要想jar包能直接通过java -jar xxx.jar运行，需要满足： 1
收起
Maven引入jar包的几种方式
千次阅读 2019-06-16 18:28:55
Maven 引入Jar...
收起
Maven项目打包为jar的几种方式
万次阅读 多人点赞 2017-10-28 23:15:48
这里收集整理下以往打包MAVEN项目为JAR包的各种方式直接打包，不打包依赖包直接打包，不打包依赖包，仅打包出项目中的代码到JAR包中。在POM中添加如下plugin即可，随后执行maven install &lt;...
收起
maven导入jar包冲突的三种解决方法
千次阅读 2019-02-15 08:57:15
maven导入jar包冲突的三种解决方法直接依赖：A项目中导入了B包，我们可以说A项目直接依赖于B 传递依赖：A项目中导入了B包，B包直接依赖于C包，最终A项目也可以使用C包，那么我们可以说A项目传递依赖于C 解决jar包...
收起
IntellijIDEA项目使用Maven打jar包
千次阅读 2017-08-05 11:16:14
尽管IntellijIDEA自己提供自带的打jar包方式，但我还是推荐使用Maven的方式进行打jar包，当然前提是你的项目得是Maven的。打开项目的Maven Projects面板，操作如下图：打包完成，jar包在你的项目的target目录下，如...
收起
maven打war包或打jar包忽略test的命令
万次阅读 2018-03-16 17:47:31
打war包命令输入-------> mvn install -DskipTests 或 mvn install -Dmaven.test.skip=true ...打jar包命令输入-------> mvn package -DskipTests或 mvnpackage-Dmaven.test.skip=true ...
收起
maven打jar包运行main方法
千次阅读 2019-05-14 10:57:28
pom文件添加上这段 <build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <configuration> ...
收起
将maven项目打成jar包
千次阅读 2019-02-20 17:55:29
jar包中带依赖在pom中添加 <build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <configuration&...
收起
怎么将第三方jar包转成maven的jar包
千次阅读 2018-08-07 09:54:01
要知道有些第三方提供的jar包文件是没有maven版本的，但是你这时候需要用到，那该怎么办呢？这时候我们需要用将这第三方的jar包转成maven版来使用。 1.首先你需要准备外部jar包 我的这个jar包现在以及下载解压到...
收起
IDEA中MAVEN项目打JAR包的简单方法
万次阅读 2019-02-28 18:06:44
　但是如果是为Maven项目打Jar包，其实是很简单的，因为maven本身就有打Jar包的命令。最简单的方法　首先是在maven项目的pom.xml中添加打包的插件，这里有很多种方式的。最最简单的就是只使用maven-compiler-...
收起
pom.xml mainClass
关于maven项目打jar包运行main方法
千次阅读 2019-04-19 14:01:17
然后打包成jar包，运行main方法。具体操作： main方法中读取spring文件： ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-mybatis.xml"); 要改成你自己的配置文件。 ...
收起
关于IDEA maven无法下载jar包问题
千次阅读 2019-09-04 09:26:52
关于IDEA maven无法下载jar包问题 1.第一步 2.第二步 3.第三步第三步详情 <mirror> <id>nexus</id> <name>internal nexus repository</name> <...
收起
IDEA MAVEN项目打包成jar包的两种简单方式
千次阅读 2020-07-15 13:19:29
IDEA MAVEN项目打包成jar包的多种方式准备了两个打包方法 1.IEDA自带打包方法 2.用Maven插件maven-shade-plugin打包 IDEA自带打包适用于任何打包，稍微麻烦一点。打开IDEA项目 file -> Project Structure ...
收起
Maven 生成打包可执行jar包
万次阅读 多人点赞 2018-09-28 14:49:23
文章目录1. 需求2. 开发环境3. Maven打包插件介绍4. Maven使用maven-jar-plugin打可执行jar包5. Maven使用maven-assembly-plugin装需要打包的文件打进zip包6....最近IDEA打可执行Jar包搞了三天，一直失败，好好学...
收起
打包
maven打jar，doc文档，source包
千次阅读 2018-08-22 13:25:37
打jar包本身是没有特殊要求的，看具体的使用场景，如果你是开源项目，你的jar包里呢还需要由注释，那么普通的jar就不行了，你需要打source包（也是一种jar包），如果你是私人项目注重项目隐私的话，那你就打普通的...
收起
eclipse下maven打jar包并引入依赖包
千次阅读 2017-11-09 18:29:43
1、项目结构如下： 2、主要配置pom.xml文件 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=... xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
收起
maven 打jar包保留注释
千次阅读 2019-07-16 16:19:45
mvn package 需要在pom中添加以下依赖，jar包中才会保留注释 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin&l...
收起

maven打jar包的三种方式

Maven打包的三种方式

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

方法二：使用maven-assembly-plugin插件打包

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

IDEA+Maven 打jar包

IDEA+Maven 打jar包（包涵依赖jar）

注：

maven工程打成jar包的三种方式

maven打jar包插件

Maven打jar包的三种方式

Maven打jar包包含源代码

Maven打jar包,排除部分包

springboot+maven 项目打jar包之后部署并启动方式

maven打jar包命令

maven打jar包并且包含部分依赖jar

java打jar包的方式，jar命令，maven

maven打jar包时配置文件打到包里并读取

使用Maven 生成jar包的两种方式

Maven引入jar包的几种方式

Maven项目打包为jar的几种方式

maven导入jar包冲突的三种解决方法

IntellijIDEA项目使用Maven打jar包

maven打war包或打jar包忽略test的命令

maven打jar包运行main方法

将maven项目打成jar包

怎么将第三方jar包转成maven的jar包

IDEA中MAVEN项目打JAR包的简单方法

关于maven项目打jar包运行main方法

关于IDEA maven无法下载jar包问题

IDEA MAVEN项目打包成jar包的两种简单方式

Maven 生成打包可执行jar包

maven打jar，doc文档，source包

eclipse下maven打jar包并引入依赖包

maven 打jar包保留注释

maven打jar包三种方式

maven打jar包的三种方式

Maven打包的三种方式

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

方法二：使用maven-assembly-plugin插件打包

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

IDEA+Maven 打jar包

IDEA+Maven 打jar包 （包涵依赖jar）

注：

maven工程打成jar包的三种方式

maven打jar包插件

Maven打jar包的三种方式

Maven打jar包包含源代码

Maven打jar包,排除部分包

springboot+maven 项目 打jar包之后部署并启动方式

maven打jar包命令

maven打jar包并且包含部分依赖jar

java打jar包的方式，jar命令，maven

maven打jar包时配置文件打到包里并读取

使用Maven 生成jar包的两种方式

Maven引入jar包的几种方式

Maven项目打包为jar的几种方式

maven导入jar包冲突的三种解决方法

IntellijIDEA项目使用Maven打jar包

maven打war包或打jar包忽略test的命令

maven打jar包运行main方法

将maven项目打成jar包

怎么将第三方jar包转成maven的jar包

IDEA中MAVEN项目打JAR包的简单方法

关于maven项目打jar包运行main方法

关于IDEA maven无法下载jar包问题

IDEA MAVEN项目打包成jar包的两种简单方式

Maven 生成打包可执行jar包

maven打jar，doc文档，source包

eclipse下maven打jar包并引入依赖包

maven 打jar包保留注释

maven打jar包三种方式

IDEA+Maven 打jar包（包涵依赖jar）

springboot+maven 项目打jar包之后部署并启动方式