Spring Boot 简单的打包部署

　　Spring Boot 支持使用 Jar 内嵌 Web 服务器（Tomcat）的方式发布，也支持生成 war 包放在外置的 web 服务器运行。

　　1、使用 Jar 发布应用

　　配置步骤：

　　① pom.xml 要显示加入插件 org.springframework.boot，否则无法产生 jar 清单文件，导致打出来的 jar 无法使用命令运行。

 1 <build>
 2         <plugins>
 3             <plugin>
 4                 <groupId>org.springframework.boot</groupId>
 5                 <artifactId>spring-boot-maven-plugin</artifactId>
 6                 <!-- 排除重新打包 -->
 7                 <executions>
 8                     <execution>
 9                         <goals>
10                             <goal>repackage</goal>
11                         </goals>
12                     </execution>
13                 </executions>
14
15             </plugin>
16         </plugins>
17     </build>
18

　　② 使用里面 package 打包

　　③ 打包成功，产生 spring-boot-demo-01.-1.0.jar 文件

　　④ 将 spring-boot-demo-01-1.0.jar 复制到一个文件夹下，在同一级目录编写一个 bat 文件

　　内容格式：#java -jar <jar 名>，如下：

java -jar spring-boot-demo-01-1.0.jar

　　⑤ 双击 bat 文件 startup.bat

　　可以修改内嵌 Tomcat 的参数

　　在 application.properties 设置相关参数即可，如：

#设置Tomcat端口
server.port=80
#设置Tomcat路径编码
server.tomcat.uri-encoding=UTF-8
#设置超时时间
server.connection-timeout=1000

2、使用 war 发布应用

　　配置流程：

　　① 修改 pom.xml 文件去掉嵌入式的 Tomcat 服务器，以及增加 serlvet-api 依赖包

<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>

<!-- 加入servlet-api的支持 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

　　② 修改 pom.xml 文件的打包方式为 war

　　③ 增加一个 web 程序的 WEB 入口类要和 Application 同一级目录

 1 package cn.mgy;
 2
 3 import org.springframework.boot.builder.SpringApplicationBuilder;
 4 import org.springframework.boot.web.support.SpringBootServletInitializer;
 5 /**
 6  * 如果项目需要使用war发布，需要创建这个类，作为web程序的入口
 7  * @author ranger
 8  *
 9  */
10 public class ServletInitializer extends SpringBootServletInitializer {
11
12     @Override
13     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
14         //表示获得web的请求时，调用Application类的实现
15         return builder.sources(Application.class);
16     }
17 }

　　④ 打包生成 war 文件

　　⑤ 复制 spring-boot-demo-01-1.0.war 放在 Tomcat 的 webapps 下

　　⑥ 启动 Tomcat，Tomcat 控制台提示 SpringBoot 信息

　　⑦ 浏览器访问，成功

http://localhost:8080/spring-boot-demo-01-1.0/index

　　注意事项：

　　① web 网站入口类一定要继承 SpringBootServletInitializer 类，而且必须要给 SpringBoot 入口类 Application 统一级目录

　　②

  1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3     <modelVersion>4.0.0</modelVersion>
  4     <groupId>cn.gzsxt.platform</groupId>
  5     <artifactId>basic_platform_spring_boot</artifactId>
  6     <version>1.0</version>
  7     <packaging>war</packaging>
  8
  9     <parent>
 10         <groupId>org.springframework.boot</groupId>
 11         <artifactId>spring-boot-starter-parent</artifactId>
 12         <version>1.5.13.RELEASE</version>
 13         <relativePath /> <!-- lookup parent from repository -->
 14     </parent>
 15
 16
 17
 18     <!-- 设置自定义属性 -->
 19     <properties>
 20
 21         <project.build.sourceEncoding>GBK</project.build.sourceEncoding>
 22         <project.reporting.outputEncoding>GBK</project.reporting.outputEncoding>
 23
 24         <java.version>1.8</java.version>
 25         <servlet.version>3.0.1</servlet.version>
 26         <jsp.version>2.2.1</jsp.version>
 27     </properties>
 28
 29
 30     <!-- 依赖 -->
 31     <dependencies>
 32         <dependency>
 33             <groupId>org.springframework.boot</groupId>
 34             <artifactId>spring-boot-starter-tomcat</artifactId>
 35             <scope>provided</scope>
 36         </dependency>
 37         <dependency>
 38             <groupId>org.springframework.boot</groupId>
 39             <artifactId>spring-boot-starter-thymeleaf</artifactId>
 40             <!-- 排除掉内置的tomcat使用我们外置tomcat -->
 41             <exclusions>
 42                 <exclusion>
 43                     <groupId>org.springframework.boot</groupId>
 44                     <artifactId>spring-boot-starter-tomcat</artifactId>
 45                 </exclusion>
 46             </exclusions>
 47         </dependency>
 48
 49         <dependency>
 50             <groupId>org.springframework.boot</groupId>
 51             <artifactId>spring-boot-starter-web</artifactId>
 52             <!-- 移除嵌入式tomcat服务器 -->
 53             <exclusions>
 54                 <exclusion>
 55                     <groupId>org.springframework.boot</groupId>
 56                     <artifactId>spring-boot-starter-tomcat</artifactId>
 57                 </exclusion>
 58             </exclusions>
 59         </dependency>
 60         <dependency>
 61             <groupId>org.springframework.boot</groupId>
 62             <artifactId>spring-boot-starter-jdbc</artifactId>
 63         </dependency>
 64
 65         <dependency>
 66             <groupId>org.mybatis.spring.boot</groupId>
 67             <artifactId>mybatis-spring-boot-starter</artifactId>
 68             <version>1.3.2</version>
 69         </dependency>
 70
 71         <dependency>
 72             <groupId>mysql</groupId>
 73             <artifactId>mysql-connector-java</artifactId>
 74             <scope>runtime</scope>
 75         </dependency>
 76         <dependency>
 77             <groupId>org.springframework.boot</groupId>
 78             <artifactId>spring-boot-starter-test</artifactId>
 79             <scope>test</scope>
 80         </dependency>
 81         <!-- servlet -->
 82         <dependency>
 83             <groupId>javax.servlet</groupId>
 84             <artifactId>javax.servlet-api</artifactId>
 85         </dependency>
 86         <!-- jsp -->
 87         <dependency>
 88             <groupId>javax.servlet.jsp</groupId>
 89             <artifactId>javax.servlet.jsp-api</artifactId>
 90             <version>2.2.1</version>
 91         </dependency>
 92
 93         <dependency>
 94             <groupId>org.apache.commons</groupId>
 95             <artifactId>commons-dbcp2</artifactId>
 96         </dependency>
 97
 98         <!-- jstl -->
 99
100
101         <dependency>
102             <groupId>javax.servlet</groupId>
103             <artifactId>jstl</artifactId>
104
105         </dependency>
106
107
108         <dependency>
109             <groupId>log4j</groupId>
110             <artifactId>log4j</artifactId>
111             <version>1.2.17</version>
112
113         </dependency>
114
115     </dependencies>
116
117     <!-- 构建项目使用Tomcat7插件 -->
118     <build>
119
120
121         <plugins>
122
123
124             <!-- 配置isntall安装时，不要执行JUnit测试代码 -->
125
126             <plugin>
127                 <groupId>org.apache.maven.plugins</groupId>
128                 <artifactId>maven-surefire-plugin</artifactId>
129
130                 <configuration>
131                     <!-- 跳过打包安装时自动执行Junit的测试代码 -->
132                     <skipTests>true</skipTests>
133                 </configuration>
134             </plugin>
135             <!-- 配置编译的时候使用1.8 的JDK -->
136
137             <plugin>
138                 <groupId>org.apache.maven.plugins</groupId>
139                 <artifactId>maven-compiler-plugin</artifactId>
140
141                 <configuration>
142                     <!-- 源码检查时使用1.8的JDK -->
143                     <source>1.8</source>
144                     <!-- 源码打包成目标程序时，使用1.8JDK -->
145                     <target>1.8</target>
146                 </configuration>
147             </plugin>
148
149
150             <plugin>
151                 <groupId>org.apache.maven.plugins</groupId>
152                 <artifactId>maven-war-plugin</artifactId>
153
154                 <configuration>
155                     <failOnMissingWebXml>false</failOnMissingWebXml>
156                 </configuration>
157             </plugin>
158         </plugins>
159     </build>
160
161 </project>

　　③ 将映射接口使用@Mapper

@Mapper
public interface ModularMapper

　　④ 关闭 thymeleaf 模板引擎

　　注意：关闭 thymeleaf 模板引擎

#忽略默认的模板引擎
spring.thymeleaf.cache=false
spring.thymeleaf.enabled=false

　　⑤ 启动的是 WebApplicationInitializer 类

　　所以直接启动页面就可以

 1 package cn.mgy.platform;
 2
 3 import org.springframework.boot.builder.SpringApplicationBuilder;
 4 import org.springframework.boot.web.support.SpringBootServletInitializer;
 5
 6 public class WebApplicationInitializer extends  SpringBootServletInitializer  {
 7
 8     @Override
 9     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
10
11        return builder.sources(Application.class);
12     }
13
14 }

原文地址：https://www.cnblogs.com/maigy/p/10884961.html

时间： 2024-08-29 23:20:43

Spring Boot 简单的打包部署的相关文章

Spring boot(4)-应用打包部署

摘自: http://blog.csdn.net/hguisu/article/details/51072683 1.Spring Boot内置web spring Boot 其默认是集成web容器的,启动方式由像普通Java程序一样,main函数入口启动.其内置Tomcat容器或Jetty容器,具体由配置来决定(默认Tomcat).当然你也可以将项目打包成war包,放到独立的web容器中(Tomcat.weblogic等等),当然在此之前你要对程序入口做简单调整. 对server的几个常用的配

Spring Boot(十二)：Spring Boot 如何测试打包部署

有很多网友会时不时的问我, Spring Boot 项目如何测试,如何部署,在生产中有什么好的部署方案吗?这篇文章就来介绍一下 Spring Boot 如何开发.调试.打包到最后的投产上线. 开发阶段单元测试在开发阶段的时候最重要的是单元测试了, Spring Boot 对单元测试的支持已经很完善了. 1.在 pom 包中添加 spring-boot-starter-test 包引用 <dependency> <groupId>org.springframework.boot&

Spring Boot Tomcat 容器化部署实践与总结

在平时的工作和学习中经常会构建简单的web应用程序.如果只是HelloWorld级别的程序,使用传统的Spring+SpringMVC框架搭建得话会将大部分的时间花费在搭建框架本身上面,比如引入SpringMVC,配置DispatcheherServlet等.并且这些配置文件都差不多,重复这些劳动似乎意义不大.所以使用Springboot框架来搭建简单的应用程序显得十分的便捷和高效. 前两天在工作中需要一个用于测试文件下载的简单web程序,条件是使用Tomcat Docker Image作为载体

Spring Boot 2.0 热部署指南

Spring Boot 2.0 支持热部署,实现方法很简单 Spring Boot 2.0 有几种热重载的选项. 推荐的方法是使用spring-boot-devtools 因为它提供了额外的开发时间功能,例如支持快速应用程序重启和LiveReload以及合理的开发时配置(如模板缓存). Devtools通过监视类路径的变化来工作. 这意味着静态资源更改必须"建立",以使更改生效. 默认情况下,当您保存更改时,这会在Eclipse中自动发生. 在IntelliJ IDEA中,Make P

Spring Boot将WAR文件部署到Tomcat

在本文中,将演示如何将Spring Boot WAR文件部署到Tomcat servlet容器中. 对于Spring Boot WAR部署,需要执行三个步骤: 扩展SpringBootServletInitializer 根据提供标记嵌入式servlet容器. 更新包装为 War 测试工具: Spring Boot 1.4.2.RELEASE Tomcat 8.5.9 Maven 3 注意在Spring Boot中,具有嵌入服务器解决方案的最终可执行JAR文件可能不适合所有生产环境,特别是部署团

如何把kotlin+spring boot开发的项目部署在tomcat上

本文只讲部署过程,你首先要保证你的程序能在IDE里跑起来: 先看看你的application.properties中设置的端口号与你服务器上tomcat的端口号是否一致 server.port=80 (我现在不确定此配置是否会影响部署) 看看你的应用程序的入口函数 @SpringBootApplication@EnableAutoConfiguration(exclude = arrayOf(DataSourceAutoConfiguration::class))class JnaApplica

Spring Boot 2构建可部署的war包

默认情况下Spring Boot使用了内嵌的Tomcat服务器,项目最终被打成jar包运行,每个jar包可以被看作一个独立的Web服务器.传统的Web开发,一般会将Web应用打成一个war包,然后将其部署到Web服务器中运行.Spring Boot也支持传统的部署模式. 开发环境:IntelliJ IDEA 2019.2.2Spring Boot版本:2.1.8 1.新建一个名称为demo的Spring Boot项目. 2.修改pom.xml文件下面粗体部分为所加代码,注释掉原来的build节

Spring Boot 五种热部署方式

[推荐]2019 Java 开发者跳槽指南.pdf(吐血整理)>>> 1.模板热部署在SpringBoot中,模板引擎的页面默认是开启缓存的,如果修改了页面的内容,则刷新页面是得不到修改后的页面的,因此我们可以在application.properties中关闭模版引擎的缓存,如下: Thymeleaf的配置: spring.thymeleaf.cache=false FreeMarker的配置: spring.freemarker.cache=false Groovy的配置: spr

Spring boot 两种热部署方式 springloader 和 devtools

什么是热部署? 热部署,就是在应用正在运行的时候升级软件,却不需要重新启动应用.在平时编写代码的时候,你会发现我们只是简单把打印信息改变了,就需要重新部署,如果要改变这样的方式,就需要用到热部署springloaded. 使用方式,在项目中的pom.xml中plugin里添加依赖: <dependencies>  <dependency> <groupId>org.springframework&