精华内容
下载资源
问答
  • 使用idea中的maven打包jar包
    2020-11-11 14:54:06

    注意点:

    pom.xml中的内容

    1.maven打包插件

    2.文件中不能有“org.mybatis.generator”的插件

    3.如果有引用本地的jar包,需要在pom文件中添加 引用本地jar包的代码

    <build>
            <plugins>
                <!--maven打包使用-->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <!--自动生成pojo类、**Mapper、**Mapper.xml 插件-->
        <!--        <plugin>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-maven-plugin</artifactId>
                    <version>1.3.2</version>
                    <executions>
                        <execution>
                            <id>Generate MyBatis Artifacts</id>
                            <goals>
                                <goal>generate</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        &lt;!&ndash; generator 工具配置文件的位置 &ndash;&gt;
                        <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
                        <verbose>true</verbose>
                        <overwrite>true</overwrite>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>mysql</groupId>
                            <artifactId>mysql-connector-java</artifactId>
                            <version>5.1.34</version>
                        </dependency>
                        <dependency>
                            <groupId>org.mybatis.generator</groupId>
                            <artifactId>mybatis-generator-core</artifactId>
                            <version>1.3.2</version>
                        </dependency>
                    </dependencies>
                </plugin>-->
                <!--引用本地jar包-->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.6.0</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                        <!--根据你把lib放的位置,但需要注意的是,mac平台上,路径分隔符用的"/",windows下用的分隔符是"\"-->
                        <compilerArguments>
                            <extdirs>src\main\resources\lib</extdirs>
                        </compilerArguments>
                    </configuration>
                </plugin>
            </plugins>
        </build>

    4.需要跳过test,我使用的是第三种方式

    https://blog.csdn.net/qq_42222230/article/details/105685293?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param

    5.使用maven打包操作只能有一个主运行类

    上述注意点做好之后就可以开始打包操作了

    打包操作:

    1.使用idea右边框中的 Maven Projects -> 项目名 -> Lifecycle -> clean
    2.使用Maven Projects -> 项目名 -> Lifecycle -> install

    6.最后在jar包所在文件打开命令窗口,使用命令运行

    进入jar包所在文件夹

    cd /usr/local/xxx

    查询端口命令
    netstat -lnp|grep 8088
    运行命令
    nohup java -jar aifactory-0.0.1-SNAPSHOT.jar

    更多相关内容
  • 主要介绍了idea+mavenjar包的两种方式,本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 本篇文章主要介绍了详解IDEAMAVEN项目打JAR包的简单方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • idea新建maven web项目.zip Jetbrains IntelliJ IDEA创建基于maven打包工具的WEB网站项目 本项目使用的是SSM框架spring mvc,spring, mybatis.用maven打包jar
  • 主要介绍了Maven打包jar包没有主属性问题解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Idea+Mavenjar包的几种姿势

    千次阅读 2022-02-14 21:25:56
    我们本地的项目要通过打成Jar包进行发布或者供其他人使用。今天记录下利ideamaven完成项目的打包过程。

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    目标

    我们本地的项目要通过打成Jar包进行发布或者供其他人使用。今天记录下利idea和maven完成项目的打包过程。


    利用Idea+Maven我们可以打出以下三种不同的jar包:

    1. 不包含引入的依赖jar包
    2. 包含全部引入的依赖jar包
    3. 包含部分引入的依赖jar包

    以一个简单的项目为例:

    一、在本地创建一个Maven项目

    创建项目时,我们可以选择创建maven项目。

    标准的maven项目目录结构

    二、编辑pom.xml文件和逻辑代码

    1. 如果我们要打不包含依赖的jar包
      此时,我们的pom.xml文件不用作特殊处理,只需要引入项目所需的jar包即可。
    <?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.chen</groupId>
        <artifactId>PinYinHelper</artifactId>
        <version>1.0-SNAPSHOT</version>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>8</source>
                        <target>8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
        <!--引入项目依赖-->
        <dependencies>
            <dependency>
                <groupId>com.belerweb</groupId>
                <artifactId>pinyin4j</artifactId>
                <version>2.5.1</version>
            </dependency>
        </dependencies>
    </project>
    
    
    

    此时,我们直接使用右侧maven中的Lifecycle中的package指令打包即可,在package指令上双击:
    双击package指令
    此时经过maven的编译打包,即可在我们项目路径的target目录下生成不包含依赖的项目jar包。
    打包完毕
    此jar中不包含项目引入的依赖

    1. 如果我们要打包含依赖的jar包
      此时,我们的pom.xml文件中则要借助assembly插件完成
    <?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.chen</groupId>
        <artifactId>PinYinHelper</artifactId>
        <version>1.0-SNAPSHOT</version>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>8</source>
                        <target>8</target>
                    </configuration>
                </plugin>
                <!--借助assembly插件完成包含项目依赖的打包-->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <configuration>
                        <appendAssemblyId>false</appendAssemblyId>
                        <descriptorRefs>
                            <!--设置将所有的依赖打进jar包中-->
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <archive>
                            <manifest>
                                <!-- 此处指定main方法入口的class -->
                                <mainClass>com.chen.Application</mainClass>
                            </manifest>
                        </archive>
                        <!--指定打出的jar包输出目录-->
                        <outputDirectory>E:\IdeaWorkspace\PinYinHelper1\target</outputDirectory>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <!--将assembly插件绑定到package上,到时只需要双击package指令即可-->
                            <phase>package</phase>
                            <goals>
                                <goal>assembly</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
        <!--引入项目依赖-->
        <dependencies>
            <dependency>
                <groupId>com.belerweb</groupId>
                <artifactId>pinyin4j</artifactId>
                <version>2.5.1</version>
            </dependency>
        </dependencies>
    </project>
    

    此时,我们同样双击右侧maven中的Lifecycle中的package指令,经过插件的编译打包,在我们设定的jar包输出目录中生成包含项目所有依赖的jar包。
    包含项目依赖的打包
    在这里插入图片描述

    1. 如果我们要打包含部分依赖的jar包
      比如说,想做一个工具jar包,依赖公共jar和自己本地jar包,本地jar包需要解压成class打到jar包内,而依赖的公共jar包则不需要。
      剔除公共jar包 可以用
      的值的含义:
      compile,缺省值,适用于所有阶段,会随着项目一起发布。
      provided,类似compile,期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
      runtime,只在运行时使用,如JDBC驱动,适用运行和测试阶段。
      test,只在测试时使用,用于编译和运行测试代码。不会随项目发布。
      system,类似provided,需要显式提供包含依赖的jar,Maven不会在Repository中查找它。

    例如:我们在项目依赖中增加junit的依赖,并在scope属性中设置为compile,然后将依赖打进项目包中:
    重点看scope属性
    在这里插入图片描述
    可见,此时junit是被打进了jar包中的。

    若我们将scope属性设置为test,在打包试试:
    在这里插入图片描述

    在这里插入图片描述
    可见,此时junit是没有被打进jar包中的。

    可执行jar包

    如果我们在使用assembly插件打包时指定了程序的主入口类,则此时打出的jar包为可执行jar包,可以通过cmd命令行去执行我们的Jar包。命令为:Java -jar xxxx.jar.

    在这里插入图片描述

    展开全文
  • IDEAMAVEN项目如何打包JAR包

    千次阅读 2022-02-26 08:38:23
    这篇文章主要为大家展示了“IDEAMAVEN项目如何打包JAR包”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“IDEAMAVEN项目如何打包JAR包”这篇文章吧。 Idea中为...

    这篇文章主要为大家展示了“IDEA中MAVEN项目如何打包JAR包”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“IDEA中MAVEN项目如何打包JAR包”这篇文章吧。

    Idea中为一般的非Web项目打Jar包是有自己的方法的,网上一搜就能查到很多。

    但是如果是为Maven项目打Jar包,其实是很简单的,因为maven本身就有打Jar包的命令。

    最简单的方法

    首先是在maven项目的pom.xml中添加打包的插件,这里有很多种方式的。最最简单的就是只使用maven-compiler-plugin、maven-jar-plugin插件,并且指定程序入口<mainClass>。相关代码如下:

    pom.xml文件为:

    <?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>cn.mymaven</groupId>
      <artifactId>test</artifactId>
      <version>1.0-SNAPSHOT</version>
    
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <source>1.8</source>
              <target>1.8</target>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
              <archive>
                <manifest>
                  <addClasspath>true</addClasspath>
                  <useUniqueVersions>false</useUniqueVersions>
                  <classpathPrefix>lib/</classpathPrefix>
                  <mainClass>cn.mymaven.test.TestMain</mainClass>
                </manifest>
              </archive>
            </configuration>
          </plugin>
        </plugins>
      </build>
      
    </project>

    入口类TestMain.java为:

    package cn.mymaven.test;
    
    public class TestMain {
      public static void main(String[] args){
        System.out.println("Hello World");
      }
    }

    然后开始打包,在Idea中把Maven项目的命令都做成了可视化的操作界面,只需要如下操作就好: 

    在Maven Project目录下,点击package  

     

    此时在target目录下,就会生成这个项目的Jar包

    使用java -jar 命令运行这个Jar包,会输出“Hello World”

    需要注意的地方

    需要说明的是,如果一个maven项目中有多个子目录,每一个子目录中的pom.xml对应一个项目,它的作用范围只有这一个子目录下的。比如扫描配置文件,如果要让一个子目录下的pom.xml扫描另一个子目录下的配置文件,那是做不到的。在打jar包的时候,只运行当前的pom.xml文件。

    当然也有其他的打包方法,比如使用spring-boot-maven-plugin插件在打Jar包时,会引入依赖包。

    它的pom.xml文件配置为:

    <build>
      <plugins>
        <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-jar-plugin</artifactId>
          <configuration>
            <archive>
              <manifest>
                <addClasspath>true</addClasspath>
                <useUniqueVersions>false</useUniqueVersions>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>cn.mymaven.test.TestMain</mainClass>
              </manifest>
              <manifestEntries>
                <version>${project.version}</version>
              </manifestEntries>
            </archive>
          </configuration>
        </plugin>
      </plugins>
    </build>

    以上是“IDEA中MAVEN项目如何打包JAR包”这篇文章的所有内容,感谢各位的阅读!

    转自:

    IDEA中MAVEN项目如何打包JAR包 - 编程语言 - 亿速云这篇文章主要为大家展示了“IDEA中MAVEN项目如何打包JAR包”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“IDEA...https://www.yisu.com/zixun/211302.html#:~:text=Idea%E4%B8%AD%E4%B8%BA%E4%B8%80%E8%88%AC%E7%9A%84%E9%9D%9EWeb%E9%A1%B9%E7%9B%AE%E6%89%93Jar%E5%8C%85%E6%98%AF%E6%9C%89%E8%87%AA%E5%B7%B1%E7%9A%84%E6%96%B9%E6%B3%95%E7%9A%84%EF%BC%8C%E7%BD%91%E4%B8%8A%E4%B8%80%E6%90%9C%E5%B0%B1%E8%83%BD%E6%9F%A5%E5%88%B0%E5%BE%88%E5%A4%9A%E3%80%82%20%E4%BD%86%E6%98%AF%E5%A6%82%E6%9E%9C%E6%98%AF%E4%B8%BAMaven%E9%A1%B9%E7%9B%AE%E6%89%93Jar%E5%8C%85%EF%BC%8C%E5%85%B6%E5%AE%9E%E6%98%AF%E5%BE%88%E7%AE%80%E5%8D%95%E7%9A%84%EF%BC%8C%E5%9B%A0%E4%B8%BAmaven%E6%9C%AC%E8%BA%AB%E5%B0%B1%E6%9C%89%E6%89%93Jar%E5%8C%85%E7%9A%84%E5%91%BD%E4%BB%A4%E3%80%82,%E9%A6%96%E5%85%88%E6%98%AF%E5%9C%A8maven%E9%A1%B9%E7%9B%AE%E7%9A%84pom.xml%E4%B8%AD%E6%B7%BB%E5%8A%A0%E6%89%93%E5%8C%85%E7%9A%84%E6%8F%92%E4%BB%B6%EF%BC%8C%E8%BF%99%E9%87%8C%E6%9C%89%E5%BE%88%E5%A4%9A%E7%A7%8D%E6%96%B9%E5%BC%8F%E7%9A%84%E3%80%82%20%E6%9C%80%E6%9C%80%E7%AE%80%E5%8D%95%E7%9A%84%E5%B0%B1%E6%98%AF%E5%8F%AA%E4%BD%BF%E7%94%A8maven-compiler-plugin%E3%80%81maven-jar-plugin%E6%8F%92%E4%BB%B6%EF%BC%8C%E5%B9%B6%E4%B8%94%E6%8C%87%E5%AE%9A%E7%A8%8B%E5%BA%8F%E5%85%A5%E5%8F%A3%3CmainClass%3E%E3%80%82

    展开全文
  • IDEA+Mavenjar包

    2021-04-04 15:18:22
    IDEA 自带的打包工具使用 打无依赖jar包 如果工程目录中有以下文件夹 删掉 点击工程上方【File】菜单选择【Project Structure】 点击【+】 选择【JAR】,【From modules with dependencies】点击【ok】 ...

    软件环境:

    ​ IDEA:2017.1.5

    ​ Maven:3.3.9

    打jar包:

    IDEA 自带的打包工具使用

    打无依赖jar包

    1. 如果工程目录中有以下文件夹 删掉

    è¿éåå¾çæè¿°

    2. 点击工程上方【File】菜单选择【Project Structure】

    è¿éåå¾çæè¿°

    3. 点击【+】 选择【JAR】,【From modules with dependencies】点击【ok】

    è¿éåå¾çæè¿°

    4. 点击【1】选择你要打包的Module,点击【2】选择你的主类(也就是你的程序的入口)然后点击【ok】

    è¿éåå¾çæè¿°
    5. 点击【ok】

    è¿éåå¾çæè¿°

    6. 【1】是要打的jar包的名字,【2】是jar包的输出路径,【3】是程序所需要的jar依赖,【4】是程序主类的名称。因为这里是打没有依赖的jar包,所以将【3】里面不需要的jar包删掉就行。最后点击【ok】

    è¿éåå¾çæè¿°

    7. 然后就会生成一个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.neo.App</mainClass>
                  </manifest>
                </archive>
                <!--过滤掉不希望包含在jar中的文件-->
                <excludes>
                  <exclude>${project.basedir}/xml/*</exclude>
                </excludes>
              </configuration>
            </plugin>


    点开Maven管理工具

    è¿éåå¾çæè¿°
    点击【package】

    è¿éåå¾çæè¿°
    等运行完以后就会生成jar包了

    è¿éåå¾çæè¿°

    至此依赖打包工具打包完成

    打完包后,用 java -jar xxx.jar 执行验证下,如果执行正确,则nice

     


    打包涵依赖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>


    2. 然后执行上面【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】目录
    1. 创建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>


    2. 将【package.xml】文件放入【assembly】文件夹中

    3. 然后执行上面【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>

     

    打完包后,用 java -jar xxx.jar 执行验证下,如果执行正确,则打包完成


    原文链接:https://blog.csdn.net/branwel/article/details/79918018

    --- end ---

    展开全文
  • Mac IDEA使用Maven打包jar文件

    千次阅读 2020-06-05 15:02:30
    打开 IDEAMaven 窗口。 选中 package 并点击运行按钮 此时正在执行打包功能 找到左侧 target 文件夹,并右键选择 reveal in Finder 这个时候看到我们已经打包完成了。
  • 主要介绍了解决idea导入maven项目缺少jar包的问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java+IDEA+maven混淆打包

    2019-03-15 15:25:16
    IDEA使用mavenjar包,然后使用工具混淆代码,亲测有效
  • idea maven插件打包jar包

    2021-05-24 23:42:49
    1、引入插件 <plugins> <plugin> <groupId>org.springframework.boot</groupId> <...spring-boot-maven-plugin</artifactId> </plugin> <plugin>
  • 本篇文章总结出用IDEA打包jar包的多种方式。项目打包Jar包可以参考如下形式:用IDEA自带的打包形式;用Maven插件maven-shade-plugin打包;用Maven插件maven-assembly-plugin打包。下面跟着小编一起来看下吧
  • 一、使用本地mvn 环境编译本地jar包 mvn install:install-file -Dfile=E:\Bank\lib\Envelope.jarjar包的全称,还可以使用全路径这样可以直接使用命令不用进入文件目录中运行命令了) -DgroupId=...
  • 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&...
  • IDEA中,使用MAVENJAR包
  • idea中通过mavenjar包

    2022-03-07 17:06:49
    4、在需要发布的项目中的target文件夹中就打好了需要的jar包; 因为需要在生产环境频繁验证一个问题,不好意思一直麻烦旁边的同事(他是专门负责打包的,但是还有别的开发任务),就请教了他怎么打包,估计人家在...
  • IDEA设置maven打包jar包名称

    千次阅读 2021-12-02 10:48:04
    Idea设置maven打包jar包名称
  • 主要介绍了idea打包java程序(包含依赖的所有jar包),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了maven打包成第三方jar包且把pom依赖打入进来的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 使用maven打包工具在IDEA中打jar包的完整步骤添加spring-boot-maven-plugin插件依赖添加maven helper工具clean install 添加spring-boot-maven-plugin插件依赖 首先要在pom.xml中添加spring-boot-maven-plugin插件,...
  • ***idea打包可执行jar包 在pom添加如下 ~~<build> <plugins>~~删除线格式~~ <plugin> <groupId>org.springframework.~~ boot</groupId> <artifactId>spring-boot-maven-...
  • 本篇文章主要介绍了maven打包web项目时同时打包为war和jar文件的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 首先,去你的pom文件中加入,位置的话就放在</project>中 <build> <plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> &...
  • 先打个jar包1.ideajar包(这种方式本人不是很熟,尝试过,打出来的比较多,虽然能,但总感觉多少有点问题,最后放弃了)2.mavenjar包maven项目最嗨)二.链接服务器工具——XShell工具三.Linux命令的操作 ...
  • 主要介绍了详解IDEA使用Maven项目不能加入本地Jar包的解决方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java+IDEA+Maven混淆打包

    2019-07-15 15:33:10
    IDEA使用mavenjar包,然后使用工具混淆代码,亲测有效
  • 主要介绍了解决idea使用maven编译正常但是运行项目时却提示很多jar包找不到的问题,本文分多种情形给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,362
精华内容 12,944
关键字:

idea用maven打包jar包