项目打包

目录

  • 单模块 maven 项目打包
  • 多模块 maven 项目打包
  • fatjar 打包（全部打包到一个jar里）

单模块 maven 项目打包

在单一模块的maven项目开发中，我们通常在 src/main/resources 编写我们的配置文件，因此，在 maven 构建的时候，我们需要添加如下配置：

  1. <resources>
  2.     <resource>
  3.         <directory>src/main/resources</directory>
  4.         <includes>
  5.             <include>**/*.*</include>
  6.         </includes>
  7.         <filtering>false</filtering>
  8.     </resource>
  9. </resources>

把 src/main/resources 目录下的文件拷贝到 classpath 目录去。

同时，在 jboot 开发的应用中，建议把 html、css、js等资源文件存放在 src/main/webapp 目录下。

以上配置完毕之后，我们需要再配置 maven-assembly-plugin 插件，配置内容如下。

  1. <plugin>
  2.     <groupId>org.apache.maven.plugins</groupId>
  3.     <artifactId>maven-assembly-plugin</artifactId>
  4.     <version>3.1.0</version>
  5.     <executions>
  6.         <execution>
  7.             <id>make-assembly</id>
  8.             <phase>package</phase>
  9.             <goals>
  10.                 <goal>single</goal>
  11.             </goals>
  12.             <configuration>
  13.                 <recompressZippedFiles>false</recompressZippedFiles>
  14.                 <appendAssemblyId>false</appendAssemblyId>
  15.                 <descriptors>
  16.                     <descriptor>package.xml</descriptor>
  17.                 </descriptors>
  18.                 <outputDirectory>${project.build.directory}/</outputDirectory>
  19.             </configuration>
  20.         </execution>
  21.     </executions>
  22. </plugin>

package.xml

  1. <assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0"
  2.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.           xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
  5.     <id>release</id>
  7.     <formats>
  8.         <format>dir</format>
  9.         <format>zip</format>
  10.         <!-- <format>tar.gz</format> -->
  11.     </formats>
  13.     <!-- 打 zip 设置为 true 时，会在 zip 包中生成一个根目录，打 dir 时设置为 false 少层目录 -->
  14.     <includeBaseDirectory>false</includeBaseDirectory>
  16.     <fileSets>
  18.         <fileSet>
  19.             <directory>${basedir}/src/main/resources</directory>
  20.             <outputDirectory>config</outputDirectory>
  21.         </fileSet>
  23.         <fileSet>
  24.             <directory>${basedir}/target/classes/webapp</directory>
  25.             <outputDirectory>webapp</outputDirectory>
  26.         </fileSet>
  28.         <!-- 项目根下面的脚本文件 copy 到根目录下 -->
  29.         <fileSet>
  30.             <directory>${basedir}</directory>
  31.             <outputDirectory></outputDirectory>
  32.             <!-- 脚本文件在 linux 下的权限设为 755，无需 chmod 可直接运行 -->
  33.             <fileMode>755</fileMode>
  34.             <includes>
  35.                 <include>*.sh</include>
  36.                 <include>*.bat</include>
  37.             </includes>
  38.         </fileSet>
  39.     </fileSets>
  41.     <!-- 依赖的 jar 包 copy 到 lib 目录下 -->
  42.     <dependencySets>
  43.         <dependencySet>
  44.             <outputDirectory>lib</outputDirectory>
  45.         </dependencySet>
  46.     </dependencySets>
  48. </assembly>

在 项目的根目录下，创建 jboot.sh 文件，内容如下：

  1. #!/bin/bash
  2. # ----------------------------------------------------------------------
  3. # name:         jboot.sh
  4. # version:      1.0
  5. # author:       yangfuhai
  6. # email:        fuhai999@gmail.com
  7. # use : ./jboot.sh {start, stop, restart}
  8. # ----------------------------------------------------------------------
  10. # 启动入口类，该脚本文件用于别的项目时要改这里
  11. MAIN_CLASS=io.jboot.app.JbootApplication
  12. COMMAND="$1"
  14. if [[ "$COMMAND" != "start" ]] && [[ "$COMMAND" != "stop" ]] && [[ "$COMMAND" != "restart" ]]; then
  15.     echo "./jboot.sh {start, stop, restart}"
  16.     exit 0
  17. fi
  21. # Java 命令行参数，根据需要开启下面的配置，改成自己需要的，注意等号前后不能有空格
  22. # JAVA_OPTS="-Xms256m -Xmx1024m -Dundertow.port=80 -Dundertow.host=0.0.0.0"
  23. # JAVA_OPTS="-Dundertow.port=80 -Dundertow.host=0.0.0.0"
  25. # 生成 class path 值
  26. APP_BASE_PATH=$(cd `dirname $0`; pwd)
  27. CP=${APP_BASE_PATH}/config:${APP_BASE_PATH}/lib/*
  29. function start()
  30. {
  31.     # 运行为后台进程，并在控制台输出信息
  32.     java -Xverify:none ${JAVA_OPTS} -cp ${CP} ${MAIN_CLASS} &
  34.     # 运行为后台进程，并且不在控制台输出信息
  35.     # nohup java -Xverify:none ${JAVA_OPTS} -cp ${CP} ${MAIN_CLASS} >/dev/null 2>&1 &
  37.     # 运行为后台进程，并且将信息输出到 output.log 文件
  38.     # nohup java -Xverify:none ${JAVA_OPTS} -cp ${CP} ${MAIN_CLASS} > output.log &
  40.     # 运行为非后台进程，多用于开发阶段，快捷键 ctrl + c 可停止服务
  41.     # java -Xverify:none ${JAVA_OPTS} -cp ${CP} ${MAIN_CLASS}
  42. }
  44. function stop()
  45. {
  46.     kill `pgrep -f ${MAIN_CLASS}` 2>/dev/null
  48.     # 以下代码与上述代码等价
  49.     # kill $(pgrep -f ${MAIN_CLASS}) 2>/dev/null
  51. }
  53. if [[ "$COMMAND" == "start" ]]; then
  54.     start
  55. elif [[ "$COMMAND" == "stop" ]]; then
  56.     stop
  57. else
  58.     stop
  59.     start
  60. fi

以上内容配置完毕之后，支持 maven 命令 mvn clean install ，待命令执行完毕之后，会在 target 目录下生成一个文件名为： 项目-版本 的文件夹。

复制该文件夹到服务器，然后执行里面的 jboot.sh start 命令即可上线。

多模块 maven 项目打包

多模块项目在以上配置的基础上，添加 maven-resources-plugin maven 插件，用于拷贝其他maven模块的资源文件和html等内容到此运行模块。

maven 配置如下：

  1. <plugin>
  2.     <artifactId>maven-resources-plugin</artifactId>
  3.     <executions>
  4.         <execution>
  5.             <id>copy-resources</id>
  6.             <phase>validate</phase>
  7.             <goals>
  8.                 <goal>copy-resources</goal>
  9.             </goals>
  10.             <configuration>
  11.                 <outputDirectory>${basedir}/target/classes/webapp</outputDirectory>
  12.                 <resources>
  13.                     <resource>
  14.                         <directory>${basedir}/../otherModule1/src/main/webapp</directory>
  15.                     </resource>
  16.                     <resource>
  17.                         <directory>${basedir}/../otherModule2/src/main/webapp</directory>
  18.                     </resource>
  19.                     <resource>
  20.                         <directory>${basedir}/../otherModule3/src/main/webapp</directory>
  21.                     </resource>
  22.                 </resources>
  23.             </configuration>
  24.         </execution>
  25.     </executions>
  26. </plugin>

这部分可以参考 jpress 项目，网址：https://gitee.com/fuhai/jpress/blob/v2.0/starter/pom.xml

fatjar 打包（全部打包到一个jar里）

fatjar 打包指的是，把所有资源（html、css、js）以及项目依赖全部打包到一个 jar 包里，这样我们可以通过 命令 java -jar xxx.jar 启动，更加方便部署，特别是方便在微服务下的多模块部署。

fatjar 打包第一步，在 pom.xml 添加如下配置

  1. <build>
  2.     <resources>
  3.         <resource>
  4.             <directory>src/main/resources</directory>
  5.             <includes>
  6.                 <include>**/*.*</include>
  7.             </includes>
  8.             <filtering>false</filtering>
  9.         </resource>
  11.         <resource>
  12.             <directory>src/main/webapp</directory>
  13.             <includes>
  14.                 <include>**/*.*</include>
  15.             </includes>
  16.             <filtering>false</filtering>
  17.         </resource>
  18.     </resources>
  20.     <plugins>
  22.         <plugin>
  23.             <groupId>org.apache.maven.plugins</groupId>
  24.             <artifactId>maven-compiler-plugin</artifactId>
  25.             <configuration>
  26.                 <source>1.8</source>
  27.                 <target>1.8</target>
  28.                 <encoding>UTF-8</encoding>
  29.                 <compilerArgument>-parameters</compilerArgument>
  30.             </configuration>
  31.         </plugin>
  34.         <plugin>
  35.             <artifactId>maven-resources-plugin</artifactId>
  36.             <executions>
  37.                 <execution>
  38.                     <id>copy-resources</id>
  39.                     <phase>validate</phase>
  40.                     <goals>
  41.                         <goal>copy-resources</goal>
  42.                     </goals>
  43.                     <configuration>
  44.                         <outputDirectory>${basedir}/target/classes/webapp</outputDirectory>
  45.                         <resources>
  46.                             <resource>
  47.                                 <directory>${basedir}/src/main/webapp</directory>
  48.                             </resource>
  49.                         </resources>
  50.                     </configuration>
  51.                 </execution>
  52.             </executions>
  53.         </plugin>
  56.         <plugin>
  57.             <groupId>org.apache.maven.plugins</groupId>
  58.             <artifactId>maven-assembly-plugin</artifactId>
  59.             <version>3.1.0</version>
  60.             <executions>
  61.                 <execution>
  62.                     <id>make-assembly</id>
  63.                     <phase>package</phase>
  64.                     <goals>
  65.                         <goal>single</goal>
  66.                     </goals>
  67.                     <configuration>
  68.                         <archive>
  69.                             <manifest>
  70.                                 <mainClass>io.jboot.app.JbootApplication</mainClass>
  71. <!--                                如果该服务只提供 RPC 服务，不提供 WEB 服务，使用下方的配置启动速度更快，占用资源更少-->
  72. <!--                                <mainClass>io.jboot.app.JbootSimpleApplication</mainClass>-->
  73.                             </manifest>
  74.                         </archive>
  75.                         <descriptorRefs>
  76.                             <descriptorRef>jar-with-dependencies</descriptorRef>
  77.                         </descriptorRefs>
  78.                     </configuration>
  79.                 </execution>
  80.             </executions>
  81.         </plugin>
  82.     </plugins>
  83. </build>

第二步：通过 Maven 打包

执行命令 mvn clean package 进行打包，在 pom.xml 对应的模块下会生成一个 xxx-with-dependencies.jar 的 jar 包，复制该 jar 到服务器上，执行 java -jar xxx-with-dependencies.jar 即可启动项目。