SpringBoot 项目支持两种打包方式，一种是 WAR 包，然后在 Tomcat 上部署运行，一种是 JAR 包，内置了 Tomcat，可以直接运行。
打成 JAR 包
Spring Boot 默认自带了一个嵌入式的 Tomcat , 支持以 jar 方式运行.
① pom.xml 添加打包插件
xml
代码解读
复制代码
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<!--指定编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<!--打包出的 jar 包的名字-->
<finalName>ts_eureka_server</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.0.6.RELEASE</version>
<!--这里写上main方法所在类的路径-->
<configuration>
<mainClass>com.ts.eureka.EurekaApplication</mainClass>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<resources>
<!-- 在这里将你需要添加到 jar 文件的所有文件都配置进去 -->
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.yml</include>
<include>**/*.html</include>
</includes>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.yml</include>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
② 打包
在 cmd 中，使用 mvn clean package 命令进行打包.
③ 运行
在 cmd 中, 通过 java -jar + jar包名, 即可运行该项目. 只要不关闭 cmd, 就会一直运行.
如果是在 linux 中想要运行且在后台运行该 jar 包时, 使用如下命令, 返回的是其 pid 号.
c
代码解读
复制代码
// 结尾的 & 表示在后台进程运行
// > log.log 是在当前目录下生成日志文件
java -jar xxx.jar > log.log &
④ 配置 JVM 参数运行
可以在启动的时候, 指定 JVM 参数.
ruby
代码解读
复制代码
nohup java -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m -Xms1024m -Xmx1024m -Xmn256m -Xss256k -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC -jar /jar包路径
⑤ 访问
访问地址为： http://服务器ip:项目中配置的端口/接口路径
打成 WAR 包
① 修改打包方式, 在 pom.xml 中, 修改打包方式为 war 方式 :
xml
代码解读
复制代码
<packaging>war</packaging>
② 移除自带的 Tomcat 依赖. 添加 servlet-api 的依赖.
xml
代码解读
复制代码
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- 移除嵌入式tomcat插件 -->
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
③ 修改启动类, 并重写初始化方法
启动类继承SpringBootServletInitializer类, 并重写 configure 方法.
scala
代码解读
复制代码
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
}
④ 打包
mvn clean package 打包完成后会在 target 目录下生成 .war 文件.
⑤ 部署
将 war 文件放到 Tomcat 的 webapps 目录下, 启动 Tomcat 即可自动解压部署.
⑥ 访问
访问地址为： http://服务器ip:服务器里Tomcat配置的端口/项目名/接口路径
注意：项目名以 Tomcat 的 webapps 目录下解压后的文件夹名字为准, 由于不使用 Spring Boot 自带的 Tomcat, 所以 yml 文件里的 server 配置不起作用.
打包之后, 配置文件的修改
在将 SpringBoot 项目打成 jar 包之后, 配置文件也被加入到了 jar 文件里面, 无法再对其修改了, 但有时又有对其进行修改的需求, 这时, 不可能重新修改项目, 重新打包, 这样十分麻烦.
只需要在打出的 jar 文件所在的目录, 创建一个 application.yml文件或者 application.properties 文件, 因为外部的配置文件的优先级高于jar包内部的配置文件, 所以将要修改的配置, 写在该外部文件即可. 然后, java -jar xxx.jar 启动即可, 可以看到配置已经修改了.
还可以通过启动参数 –spring.config.location=/opt/jars/oauth/application.yml来指定外部配置文件的位置.
不过, 经过测试发现, 这种方式只支持 SpringBoot 本身存在的属性, 对我们自定义的属性配置好像无法覆盖. 还是使用 JAR 包里面的配置.
最后的解决方式 :
- 编写项目时, 暂时将自定义的配置写在 application.yml 中.
- 在准备打成 JAR 包的时候, 将所有的自定义的配置, 剪切到外部的 application.yml, 然后再打 JAR 包. 这样打完 JAR 包后, 配置就分为两部分,
一部分 SpringBOOt 本身的可以被覆盖的, 在 JAR 包里面, 另外一部分自定义的, 在 JAR 包外面.
SpringBoot 项目增量更新部署
背景：SpringBoot 项目打 jar 包方便是方便, 就是每次打包出来的 jar 太大了, 先不说上传时间的问题, 如果只修改了 1 个类就需要重新打包项目, 然后重新上传项目到服务器, 怎么觉得还不如之前使用 war 包方便呢, 使用 war 包时, 虽然要部署到 Tomcat 中, 但只需要将修改的 class 替换一下, 重启一下 Tomcat 就可以快速部署了.
瘦身前的Jar包
Tomcat 在部署 Web 工程的时候, 可以进行增量更新, 其实, Spring Boot 也是可以的. Spring Boot 编译出来的 Jar 包中, 占用空间大的, 都是一些外部依赖库 jar 包.
例如：进入项目工程根目录, 执行 mvn clean install 命令, 得到的 Jar 包, 用压缩软件打开, 目录结构如下：
整个 Jar 包 16.7M, 但是 BOOT-INF/lib 就占用了将近 16.6 M.
瘦身步骤
1.第一次打包时, 打包出带有外部依赖的 jar 包. 并将 jar 包进行解压, 将 lib 文件夹解压到指定目录中.
打包所用的 pom :
xml
代码解读
复制代码
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>it.com.XXApplication</mainClass>
<layout>ZIP</layout>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugins>
<build>
2.第二次打包, 打包出没有外部依赖的 jar 包.
打包所用的 pom :
xml
代码解读
复制代码
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>it.com.XXApplication</mainClass>
<layout>ZIP</layout>
<includes>
<include>
<groupId>nothing</groupId>
<artifactId>nothing</artifactId>
</include>
</includes>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugins>
<build>
3.将解压出来的 lib 文件夹、第二次打包的 jar 包放在同一个目录下, 运行下面命令 就能成功运行.
ini
代码解读
复制代码
// 指定 lib 位置
java -Dloader.path=lib -jar xxxx.jar
4.后续对代码的修改, 都按照第二次打包的方式, 进行打包.
5.当然了, 这种方式要求打包后, 没有引入新的外部依赖, 如果有新的依赖, 则需要重新按照第一次的方式进行打包.
