精华内容
下载资源
问答
  • 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

    1. <build>  
    2.     <plugins>  
    3.   
    4.         <plugin>  
    5.             <groupId>org.apache.maven.plugins</groupId>  
    6.             <artifactId>maven-jar-plugin</artifactId>  
    7.             <version>2.6</version>  
    8.             <configuration>  
    9.                 <archive>  
    10.                     <manifest>  
    11.                         <addClasspath>true</addClasspath>  
    12.                         <classpathPrefix>lib/</classpathPrefix>  
    13.                         <mainClass>com.xxg.Main</mainClass>  
    14.                     </manifest>  
    15.                 </archive>  
    16.             </configuration>  
    17.         </plugin>  
    18.         <plugin>  
    19.             <groupId>org.apache.maven.plugins</groupId>  
    20.             <artifactId>maven-dependency-plugin</artifactId>  
    21.             <version>2.10</version>  
    22.             <executions>  
    23.                 <execution>  
    24.                     <id>copy-dependencies</id>  
    25.                     <phase>package</phase>  
    26.                     <goals>  
    27.                         <goal>copy-dependencies</goal>  
    28.                     </goals>  
    29.                     <configuration>  
    30.                         <outputDirectory>${project.build.directory}/lib</outputDirectory>  
    31.                     </configuration>  
    32.                 </execution>  
    33.             </executions>  
    34.         </plugin>  
    35.   
    36.     </plugins>  
    37. </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

    1. Class-Path: lib/commons-logging-1.2.jar lib/commons-io-2.4.jar  
    2. 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

    1. <build>  
    2.     <plugins>  
    3.   
    4.         <plugin>  
    5.             <groupId>org.apache.maven.plugins</groupId>  
    6.             <artifactId>maven-assembly-plugin</artifactId>  
    7.             <version>2.5.5</version>  
    8.             <configuration>  
    9.                 <archive>  
    10.                     <manifest>  
    11.                         <mainClass>com.xxg.Main</mainClass>  
    12.                     </manifest>  
    13.                 </archive>  
    14.                 <descriptorRefs>  
    15.                     <descriptorRef>jar-with-dependencies</descriptorRef>  
    16.                 </descriptorRefs>  
    17.             </configuration>  
    18.         </plugin>  
    19.   
    20.     </plugins>  
    21. </build>  

     

    打包方式:

     

    [plain] view plain copy

    1. mvn package assembly:single  

     

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

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

     

    [html] view plain copy

    1. <build>  
    2.     <plugins>  
    3.   
    4.         <plugin>  
    5.             <groupId>org.apache.maven.plugins</groupId>  
    6.             <artifactId>maven-assembly-plugin</artifactId>  
    7.             <version>2.5.5</version>  
    8.             <configuration>  
    9.                 <archive>  
    10.                     <manifest>  
    11.                         <mainClass>com.xxg.Main</mainClass>  
    12.                     </manifest>  
    13.                 </archive>  
    14.                 <descriptorRefs>  
    15.                     <descriptorRef>jar-with-dependencies</descriptorRef>  
    16.                 </descriptorRefs>  
    17.             </configuration>  
    18.             <executions>  
    19.                 <execution>  
    20.                     <id>make-assembly</id>  
    21.                     <phase>package</phase>  
    22.                     <goals>  
    23.                         <goal>single</goal>  
    24.                     </goals>  
    25.                 </execution>  
    26.             </executions>  
    27.         </plugin>  
    28.   
    29.     </plugins>  
    30. </build>  


    其中<phase>package</phase>、<goal>single</goal>即表示在执行package打包时,执行assembly:single,所以可以直接使用mvn package打包。

     

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

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

    在pom.xml中配置:

     

    [html] view plain copy

    1. <build>  
    2.     <plugins>  
    3.   
    4.         <plugin>  
    5.             <groupId>org.apache.maven.plugins</groupId>  
    6.             <artifactId>maven-shade-plugin</artifactId>  
    7.             <version>2.4.1</version>  
    8.             <executions>  
    9.                 <execution>  
    10.                     <phase>package</phase>  
    11.                     <goals>  
    12.                         <goal>shade</goal>  
    13.                     </goals>  
    14.                     <configuration>  
    15.                         <transformers>  
    16.                             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
    17.                                 <mainClass>com.xxg.Main</mainClass>  
    18.                             </transformer>  
    19.                         </transformers>  
    20.                     </configuration>  
    21.                 </execution>  
    22.             </executions>  
    23.         </plugin>  
    24.   
    25.     </plugins>  
    26. </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

    1. <build>  
    2.     <plugins>  
    3.   
    4.         <plugin>  
    5.             <groupId>org.apache.maven.plugins</groupId>  
    6.             <artifactId>maven-shade-plugin</artifactId>  
    7.             <version>2.4.1</version>  
    8.             <executions>  
    9.                 <execution>  
    10.                     <phase>package</phase>  
    11.                     <goals>  
    12.                         <goal>shade</goal>  
    13.                     </goals>  
    14.                     <configuration>  
    15.                         <transformers>  
    16.                             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
    17.                                 <mainClass>com.xxg.Main</mainClass>  
    18.                             </transformer>  
    19.                             <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
    20.                                 <resource>META-INF/spring.handlers</resource>  
    21.                             </transformer>  
    22.                             <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
    23.                                 <resource>META-INF/spring.schemas</resource>  
    24.                             </transformer>  
    25.                         </transformers>  
    26.                     </configuration>  
    27.                 </execution>  
    28.             </executions>  
    29.         </plugin>  
    30.   
    31.     </plugins>  
    32. </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包

        1. 如果工程目录中有以下文件夹 删掉
          这里写图片描述
      1. 点击工程上方【File】菜单选择【Project Structure】
        这里写图片描述
      2. 点击【+】 选择【JAR】,【From modules with dependencies】点击【ok】
        这里写图片描述
      3. 点击【1】选择你要打包的Module,点击【2】选择你的主类(也就是你的程序的入口)然后点击【ok】这里写图片描述
      4. 点击【ok】
        这里写图片描述
      5. 【1】是要打的jar包的名字,【2】是jar包的输出路径,【3】是程序所需要的jar依赖,【4】是程序主类的名称。因为这里是打没有依赖的jar包,所以将【3】里面不需要的jar包删掉就行。最后点击【ok】这里写图片描述
      6. 然后就会生成一个META-INF的文件夹,里面就是一些配置属性
      • 打包涵依赖jar包
        对以上的方式中的步骤6中 不做任何修改,然后执行步骤7

    • Maven 打包
      • 打无依赖jar包

        1. 在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> 
          
        2. 点开Maven管理工具
          这里写图片描述

        3. 点击【package】
          这里写图片描述

        4. 等运行完以后就会生成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>
        
        1. 然后执行上面【Maven 打无依赖包】步骤2到步骤4

        第二种方法

        1. 在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>
          
        2. 创建【src/main/assembly】目录
        3. 创建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>
          
        4. 将【package.xml】文件放入【assembly】文件夹中
          这里写图片描述
        5. 然后执行上面【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>
    

    注:

    本文属于作者原创,如需转载,请注明。

    内部如果引用的文字,连接,图片等资源存在侵犯原作者的情况,请联系本人,立即删除。

    展开全文
  • 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> <!--...
  • 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具体设置如下: ...
  • 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包需要解压成classjar包内,而依赖的公共jar包则不需要 踢出公共jar包 可以用 的值的含义: compile,缺省值,适用于所有阶段,...
  • 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进行管理的,所以主要...
  • 有需求需要用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 &amp;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中添加 &lt;build&gt; &lt;plugins&gt; &lt;plugin&gt; &lt;artifactId&gt;maven-assembly-plugin&lt;/artifactId&gt; &lt;configuration&...
  • 怎么将第jar包转成mavenjar包

    千次阅读 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-...
  • 关于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包的多种方式 准备了两个打包方法 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...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 286,167
精华内容 114,466
关键字:

maven打jar包三种方式