第 5-5 课：如何打包部署 Spring Boot 项⽬

末蓝、 2023-06-29 02:50 45阅读 0赞

Spring Boot  使⽤了内嵌容器，因此它的部署⽅式也变得⾮常简单灵活，⼀⽅⾯可以将  Spring Boot  项⽬打包

成独⽴的  Jar  或者  War  包来运⾏，也可以单独打包成  War  包部署到  Tomcat  容器中运⾏，如果涉及到⼤规模

的部署  Jinkins  就成为最佳选择之⼀。

Spring Boot  默认集成  Web  容器，启动⽅式和普通  Java  程序⼀样， main  函数⼊⼝启动，其内置  Tomcat  容

器或  Jetty  容器，具体由配置来决定（默认  Tomcat ）。

### 相关配置  ###

### 多环境配置 ###

在这⾥将介绍⼀下  Spring Boot  多环境配置⽂件，在我们开发过程中必定会⾯临多环境的问题，⽐如开发环

境、测试环境、⽣产环境，在不同的环境下会有不同的数据库连接池等配置信息。如果都写在⼀个配置⽂件

中，在不同的环境下启动需要⼿动修改对应的环境参数，这种⽅式容易出错且不够优雅。 Spring Boot  ⽀持多

配置⽂件的使⽤，只需要启动时指定对应的配置⽂件即可。

⾸先在  pom.xml  中添加相关配置：

<profiles>
     <profile>
     <id>dev</id>
     <properties>
     <env>dev</env>
     </properties>
     <activation>
     <activeByDefault>true</activeByDefault>
     </activation>
     </profile>
     <profile>
     <id>test</id>
     <properties>
     <env>test</env>
     </properties>
     </profile>
     <profile>
     <id>pro</id>
     <properties>
     <env>pro</env>
     </properties>
     </profile>
    GitChat
    </profiles>
    <build>
     <resources>
     <resource>
     <directory>src/main/resources</directory>
     <filtering>true</filtering>
     <excludes>
     <exclude>application-dev.properties</exclude>
     <exclude>application-pro.properties</exclude>
     <exclude>application-test.properties</exclude>
     </excludes>
     </resource>
     <resource>
     <directory>src/main/resources</directory>
     <filtering>true</filtering>
     <includes>
     <include>application-${env}.properties</include>
     </includes>
     </resource>
     </resources>
     <plugins>
     <plugin>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-maven-plugin</artifactId>
     </plugin>
     </plugins>
    </build>

在  Spring Boot  中多环境配置⽂件名需要满⾜  application-\{profifile\}.properties  的格式，其中  \{profifile\}  对应环境

标识。在  resources  ⽬录下创建以下三个⽂件。

pplication-dev.properties：开发环境
    application-test.properties：测试环境
    application-prod.properties：⽣产环境

不同的配置⽂件对应不同的环境，启动的时候通过参数设置来启⽤不同的配置，开发过程中在

application.properties  ⽂件中通过  spring.profifiles.active  属性来设置，其值对应  \{profifile\}  值，⽣产中使⽤  \--

spring.profifiles.active=dev  参数来控制加载某个配置⽂件。

### 配置项介绍  ###

对  Server  的⼏个常⽤配置做个简单说明：

# 项⽬ contextPath，⼀般不⽤配置
    server.servlet.context-path=/myspringboot
    # 错误⻚，指定发⽣错误时，跳转的 URL
    server.error.path=/error
    # 服务端⼝
    server.port=6060
    # session最⼤超时时间(分钟)，默认为30
    server.session-timeout=60
    # 该服务绑定 IP 地址，启动服务器时如本机不是该 IP 地址则抛出异常启动失败，只有特殊需求的情况下才
    配置
    # server.address=192.168.0.6

如果使⽤的是  Tomcat  还可以进⾏以下的配置：

# tomcat 最⼤线程数，默认为 200 
    server.tomcat.max-threads=600 
    # tomcat 的 URI 编码 
    server.tomcat.uri-encoding=UTF-8 
    # 存放 Tomcat 的⽇志、Dump 等⽂件的临时⽂件夹，默认为系统的 tmp ⽂件夹
    server.tomcat.basedir=/tmp/log 
    # 打开 Tomcat 的 Access ⽇志，并可以设置⽇志格式 
    #server.tomcat.access-log-enabled=true 
    #server.tomcat.access-log-pattern= 
    # accesslog ⽬录，默认在 basedir/logs 
    #server.tomcat.accesslog.directory= 
    # ⽇志⽂件⽬录 
    logging.path=/tmp/log 
    # ⽇志⽂件名称，默认为 spring.log 
    logging.file=myapp.log

以上的配置都为可选，在默认情况下都可不配置，项⽬中根据实际的使⽤情况来调整。

### 项⽬打包  ###

### 打成 **jar** 包  ###

内嵌容器技术的发展为  Spring Boot  部署打下了坚实的基础，内嵌容器不只在部署阶段发挥着巨⼤的作⽤，

在开发调试阶段也会带来极⼤的便利性，对⽐以往开发  Web  项⽬时配置  Tomcat  的繁琐，会让⼤家使⽤

Spring Boot  内嵌容器时有更深的感触。使⽤  Spring Boot  开发  Web  项⽬，不需要关⼼容器的环境问题，专

⼼写业务代码即可。

内嵌容器对部署带来的改变更多，现在  Maven  、 Gradle  已经成了我们⽇常开发必不可少的构建⼯具，使⽤

这些⼯具很容易的将项⽬打包成  Jar  或者  War  包，在服务器上仅仅需要⼀条命令即可启动项⽬，我们以

Maven  为例来进⾏演示。

Maven  默认会将项⽬打成  jar  包，也可以显示指出打包⽅式。

<groupId>com.neo</groupId>
    <artifactId>spring-boot-package</artifactId>
    <version>1.0.0</version>
    
    <packaging>jar</packaging>

Maven  打包会根据  pom  包中的  packaging  配置来决定是⽣成  Jar  包或者  War  包。

pom.xml  同⽬录下，执⾏以下命令：

cd 项⽬跟⽬录（和 pom.xml 同级）
    mvn clean package
    ## 或者执⾏下⾯的命令
    ## 排除测试代码后进⾏打包
    mvn clean package -Dmaven.test.skip=true

*  mvn clean 是清除项⽬ target ⽬录下的⽂件 
 *  mvn package 打包命令，可以和 mvn clean ⼀起执⾏

在使⽤  Maven  进⾏打包的时候，会⾃动对  test  包下⾯的测试⽤例进⾏测试，测试⽤例失败会给出错误提

示，并停⽌打包，可以利⽤这个功能来做项⽬的⾃动化测试，检测基本功能是否正确，也可以选择不执⾏这

些测试⽤例，启动时添加参数  \-Dmaven.test.skip=true 。

打包完成后  jar  包会⽣成到  target  ⽬录下，命名⼀般是 “ 项⽬名 \+ 版本号 .jar” 的形式。

启动  jar  包命令：

java -jar target/spring-boot-package-1.0.0.jar

这种⽅式，只要控制台关闭，服务就会停⽌，⽣产中我们⼀般使⽤后台运⾏的⽅式来启动 :

nohup java -jar spring-boot-package-1.0.0.jar &

设置  jvm  参数：

java -Xms10m -Xmx80m -jar spring-boot-package-1.0.0.jar &

也可以在启动的时候选择读取不同的配置⽂件：

java -jar spring-boot-package-1.0.0.jar --spring.profiles.active=dev

### **gradle**  ###

如果使⽤的是  gradle ，使⽤下⾯命令打包：

gradle build
    java -jar build/libs/mymodule-0.0.1-SNAPSHOT.jar

Spring Boot  ⽀持在启动的时候添加定制，⽐如设置应⽤的堆内存、垃圾回收机制、⽇志路径等。

### 打成 **war** 包  ###

打成  war  包也⾮常的简单，但需要添加⼀些额外的配置。

（ 1 ） Maven  项⽬，修改  pom  包

将

改为

（ 2 ）打包时排除  Tomcat

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
     <scope>provided</scope>
    </dependency>

在这⾥将  scope  属性设置为  provided ，这样在打包产⽣的  war  中就不会包含此  jar 。

（ 3 ）注册启动类

在项⽬的启动类中继承  SpringBootServletInitializer  并重写  confifigure()  ⽅法：

@SpringBootApplication
    public class PackageApplication extends SpringBootServletInitializer {
     @Override
     protected SpringApplicationBuilder configure(SpringApplicationBuilder applicat
    ion) {
     return application.sources(PackageApplication.class);
     }
     public static void main(String[] args) {
     SpringApplication.run(PackageApplication.class, args);
     }
    }

最后执⾏：

mvn clean package -Dmaven.test.skip=true

会在  target  ⽬录下⽣成：项⽬名  \+  版本号 .war  ⽂件，复制到  Tomcat  服务器中启动即可。

打包成功输出的内容：

Results :
    Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
    ...
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 29.290 s
    [INFO] Finished at: 2017-11-26T15:19:43+08:00
    [INFO] Final Memory: 36M/354M
    [INFO] ------------------------------------------------------------------------

### **gradle**  ###

如果使⽤的是  Gradle ，基本步骤和  Maven  类似， build.gradle  中添加  war  的⽀持，排除  spring-boot-starter

tomcat ：

...
    apply plugin: 'war'
    ...
    dependencies {
     compile("org.springframework.boot:spring-boot-starter-web:2.1.0.RELEASE"){
     exclude mymodule:"spring-boot-starter-tomcat"
     }
    }
    ...

再使⽤构建命令：

gradle build

war  会⽣成在  build\\libs  ⽬录下。

### 部署运维  ###

### 单个项⽬  ###

### 简单粗暴  ###

直接  kill  掉进程再次启动  jar  包：

ps -ef|grep java 
    ##拿到对于 Java 程序的 pid
    kill -9 pid
    ## 再次重启
    Java -jar xxxx.jar

当然这种⽅式⽐较传统和暴⼒，建议⼤家使⽤下⾯的⽅式来管理。

### 脚本执⾏  ###

如果使⽤的是  Maven ，需要包含以下的配置：

<plugin>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-maven-plugin</artifactId>
     <configuration>
     <executable>true</executable>
     </configuration>
    </plugin>

如果使⽤是  Gradle ，需要包含下⾯配置：

Spring Boot {
     executable = true
    }

启动⽅式：

（ 1 ）可以直接  ./yourapp.jar  来启动

（ 2 ）注册为服务

也可以做⼀个软链接指向你的  jar  包并加⼊到  init.d  中，然后⽤命令来启动。

init.d  例⼦ :

ln -s /var/yourapp/yourapp.jar /etc/init.d/yourapp
    chmod +x /etc/init.d/yourapp

这样就可以使⽤  stop  或者是  restart  命令去管理你的应⽤了。

/etc/init.d/yourapp start|stop|restart

或者

service yourapp start|stop|restart

如果是打包成独⽴的  war  包部署到  Tomcat  中，就按照  Tomcat  的相关命令来重启。当然以上只是单个项⽬

部署，假设我们有  1000  多个项⽬，如果再按照这种⽅式来打包上传启动的话，整个平台部署完成估计需要

⼏个⼩时，并且⾮常容易出错。在⼤量部署应⽤时，给⼤家介绍另外⼀款⾃动化部署神器  Jenkins 。

### 批量部署  ###

Jenkins  是⽬前持续构建领域使⽤最⼴泛的⼯具之⼀，它是⼀个独⽴的开源⾃动化服务器，可⽤于⾃动化各

种任务，如构建、测试和部署软件。 Jenkins  可以通过本机系统包以  Docker  的⽅式部署项⽬，甚⾄可以通过

安装  Java Runtime Environment  的任何机器独⽴运⾏。

Jenkins  可以很好的⽀持各种语⾔（如  Java 、 C\# 、 PHP  等）项⽬构建，也完全兼容  ant 、 maven 、 gradle  等

多种第三⽅构建⼯具，同时跟  svn 、 git  能⽆缝集成，也⽀持直接与知名源代码托管⽹站，⽐如  GitHub 、

Bitbucket  直接集成。

说直⽩⼀点  Jenkins  就是专⻔来负责如何将代码变成可执⾏的程序包，将它部署到⽬标服务器中，并对其运

营状态（⽇志）进⾏监控的软件。⾃动化、性能、打包、部署、发布、发布结果⾃动化验证、接⼝测试、单

元测试等关于我们打包测试部署的⽅⽅⾯⾯  Jenkins  都可以很友好的⽀持。

Jenkins  搭建部署分为四个步骤：

*  第⼀步，Jenkins 安装 
 *  第⼆步，插件安装和配置 
 *  第三步，Push SSH 
 *  第四步，部署项⽬

具体的安装部署过程可以参考我博客上的⽂章： 使⽤  Jenkins  部署  Spring Boot 。

在这⾥主要看⼀下使⽤  Jenkins  部署  Spring Boot  的脚本。

DATE=$(date +%Y%m%d)
    export JAVA_HOME PATH CLASSPATH
    JAVA_HOME=/usr/java/jdk1.8.0_131
    PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH
    CLASSPATH=.:$JAVA_HOME/lib:$JAVA_HOME/jre/lib:$CLASSPATH
    DIR=/root/xxx
    JARFILE=xxx-1.0.0-SNAPSHOT.jar
    if [ ! -d $DIR/backup ];then
     mkdir -p $DIR/backup
    fi
    cd $DIR
    ps -ef | grep $JARFILE | grep -v grep | awk '{print $2}' | xargs kill -9
    mv $JARFILE backup/$JARFILE$DATE
    mv -f /root/Jenkins-in/$JARFILE .
    java -jar $JARFILE > out.log &
    if [ $? = 0 ];then
     sleep 30
     tail -n 50 out.log
    fi
    cd backup/
    ls -lt|awk 'NR>5{print $NF}'|xargs rm -rf

⾸先导⼊相关环境变量，然后根据⽇期对项⽬进⾏备份， kill  掉正在执⾏的  Spring Boot  项⽬，将推送过来的

项⽬包放到对应⽬录下，使⽤  java -jar  命令来启动应⽤，最后将启动⽇志打印出来。

使⽤  Jenkin  之后，部署项⽬的步骤如下：

*  push 代码到 Github（或者 SVN） 触发 WebHook 
 *  Jenkins 从仓库拉去代码 
 *  Maven 构建项⽬、单元测试 
 *  备份项⽬，停⽌正在运⾏的项⽬ 
 *  启动应⽤ 
 *  查看启动⽇志

使⽤  Jenkin  前期做⼀些简单的配置，后期当发布项⽬时只需要点击项⽬对应的发布按钮，就可以将项⽬从版

本库中拉取、打包、发布到⽬标服务器中，⼤⼤简化了运维后期的部署⼯作。

### 查看应⽤运⾏配置  ###

可以根据  Java  ⾃带的  jinfo  命令：

jinfo -flags pid

来查看  jar  启动后使⽤的是什么  gc 、新⽣代、⽼年代分批的内存都是多少，示例如下：

Attaching to process ID 5589, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 25.131-b11
    Non-default VM flags: -XX:CICompilerCount=2 -XX:InitialHeapSize=16777216 -XX:MaxHe
    apSize=262144000
     -XX:MaxNewSize=87359488 -XX:MinHeapDeltaBytes=196608 -XX:NewSize=5570560 -XX:OldS
    ize=11206656 
     -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseParallelGC

*  \-XX:CICompilerCount：最⼤的并⾏编译数 
 *  \-XX:InitialHeapSize 和 \-XX:MaxHeapSize：指定 JVM 的初始和最⼤堆内存⼤⼩ 
 *  \-XX:MaxNewSize：JVM 堆区域新⽣代内存的最⼤可分配⼤⼩ 
 *  XX:+UseCompressedClassPointers: 压缩类指针 
 *  \-XX:+UseCompressedOops: 压缩对象指针 
 *  \-XX:+UseParallelGC：垃圾回收使⽤ Parallel 收集器

### 总结  ###

Spring Boot  项⽬⽀持在不同环境下指定不同配置⽂件启动，⽅便开发⼈员在各个环节部署。 Spring Boot  因

为使⽤了内嵌容器，因此极⼤的优化了项⽬的部署难度，我们可以根据配置将  Spring Boot  打包成  Jar  或者

War  部署，单个项⽬可以使⽤命令⾏或者脚本的形式部署项⽬，如果涉及⼤量应⽤的部署运维，建议使⽤

Jenkins  发布  Spring Boot  项⽬，使⽤  Jinkins  可以以图形化的形式批量部署  Spring Boot  应⽤。

[点击这⾥下载源码][Link 1]

[Link 1]: https://github.com/ityouknow/spring-boot-leaning/tree/gitbook_column2.0