【Springboot】学习一应用打包部署-优快云博客

本文详细介绍SpringBoot应用如何使用Maven进行打包成可执行的jar或war文件，并介绍了不同场景下的配置方法，包括内置容器的选择、外部容器的部署、本地Jar包的添加等。

2019独角兽企业重金招聘Python工程师标准>>>

1、Spring Boot内置web

** spring Boot **其默认是集成web容器的，启动方式由像普通Java程序一样，main函数入口启动。其内置Tomcat容器或Jetty容器，具体由配置来决定（默认Tomcat）。当然你也可以将项目打包成war包，放到独立的web容器中（Tomcat、weblogic等等），当然在此之前你要对程序入口做简单调整。

对server的几个常用的配置做个简单说明：

application.properties 文件：

# 项目contextPath，一般在正式发布版本中，我们不配置  
server.context-path=/myspringboot  
# 错误页，指定发生错误时，跳转的URL。请查看BasicErrorController源码便知  
server.error.path=/error  
# 服务端口  
server.port=9090  
# session最大超时时间(分钟)，默认为30  
server.session-timeout=60  
# 该服务绑定IP地址，启动服务器时如本机不是该IP地址则抛出异常启动失败，只有特殊需求的情况下才配置  
# server.address=192.168.16.11

**Tomcat **

Tomcat为Spring Boot的默认容器，下面是几个常用配置：

pom.xml依赖配置:

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

application.properties 文件：

# tomcat最大线程数，默认为200  
server.tomcat.max-threads=800  
# tomcat的URI编码  
server.tomcat.uri-encoding=UTF-8  
# 存放Tomcat的日志、Dump等文件的临时文件夹，默认为系统的tmp文件夹（如：C:\Users\Shanhy\AppData\Local\Temp）  
server.tomcat.basedir=H:/springboot-tomcat-tmp  
# 打开Tomcat的Access日志，并可以设置日志格式的方法：  
#server.tomcat.access-log-enabled=true  
#server.tomcat.access-log-pattern=  
# accesslog目录，默认在basedir/logs  
#server.tomcat.accesslog.directory=  
# 日志文件目录  
logging.path=H:/springboot-tomcat-tmp  
# 日志文件名称，默认为spring.log  
logging.file=myapp.log

Jetty

如果你要选择Jetty，也非常简单，就是把pom中的tomcat依赖排除，并加入Jetty容器的依赖，如下：

<dependencies>  
  <dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-web</artifactId>  
    <exclusions>  
      <exclusion>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-tomcat</artifactId>  
      </exclusion>  
    </exclusions>  
  </dependency>  
  <dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-jetty</artifactId>  
  </dependency>  
<dependencies>

项目构建我们使用Maven或Gradle，这将使项目依赖、jar包管理、以及打包部署变的非常方便。

2、Maven构建Spring Boot框架的可执行Jar包

在spring boot里，很吸引人的一个特性是可以直接把应用打包成为一个jar/war，然后这个jar/war是可以直接启动的，不需要另外配置一个Web Server。单独的JAR包，然后通过Java -jar <name>.jar命令运行。

1.1 Maven

SpringBootMaven插件为Maven提供SpringBoot支持，它允许你打包可执行jar或war存档，然后就地运行应用。为了使用它，你需要使用Maven 3.2（或更高版本）。

  Maven用户可以继承spring-boot-starter-parent项目来获取合适的默认设置。该父项目提供以下特性：

1、默认编译级别为Java 1.6 2、源码编码为UTF-8 3、一个依赖管理节点，允许你省略普通依赖的 <version>标签，继承自 spring-boot-dependenciesPOM。合适的资源过滤 4、合适的插件配置（exec插件，surefire，Git commitID，shade） 5、针对 application.properties和application.yml 的资源过滤 6、最后一点：由于默认配置文件接收Spring风格的占位符（ ${...} ），Maven filtering改用@..@ 占位符（你可以使用Maven属性 resource.delimiter来覆盖它）。

1.2继承starter parent

想配置你的项目继承 spring-boot-starter-parent 只需要简单地设置parent为：

<!-- Inherit defaults    from    Spring  Boot    -->  
<parent>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-starter-parent</artifactId>  
<version>1.3.0.BUILD-SNAPSHOT</version>  
</parent>

注：你应该只需要在该依赖上指定Spring Boot版本。如他的starters，你可以放心的省略版本号。

1.3使用没有父POM的SpringBoot

不是每个人都喜欢继承spring-boot-starter-parentPOM。你可能需要使用公司标准parent，或你可能倾向于显式声明所有 Maven配置。如果你不使用 spring-boot-starter-parent ，通过使用一个scope=import 的依赖，你仍能获取到依赖管理的好处：

<dependencyManagement>  
<dependencies>  
<dependency>  
<!-- Import  dependency  management  from    Spring  Boot    -->  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-dependencies</artifactId>  
<version>1.3.0.BUILD-SNAPSHOT</version>  
<type>pom</type>  
<scope>import</scope>  
</dependency>  
</dependencies>  
</dependencyManagement>

1.4改变Java版本

spring-boot-starter-parent选择相当保守的Java兼容策略。如果你遵循我们的建议，使用最新的Java版本，你可以添加一个 java.version属性：

<properties>
<java.version>1.8</java.version>
</properties>

1.5 使用Spring Boot Maven插件

SpringBoot包含一个Maven插件，它可以将项目打包成一个可执行jar。如果想使用它，你可以将该插件添加到<plugins>节点处：

<?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>  
<!-- ... -->  
<build>  
<plugins>  
<plugin>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-maven-plugin</artifactId>  
<version>1.3.0.BUILD-SNAPSHOT</version>  
<executions>  
<execution>  
<goals>  
<goal>repackage</goal>  
</goals>  
</execution>  
</executions>  
</plugin>  
</plugins>  
</build>  
</project>

注：如果使用Spring-Boot-tarter-parent pom，你只需要添加该插件而无需配置它，除非你想改变定义在partent中的设置。该配置会在Maven生命周期的 package阶段重新打包一个jar或war。下面的示例显示在target目录下既有重新打包后的jar，也有原始的jar：

**1.6 Linux下打包方法： **

使用 mvn clean package 命令打包如果还没有安装maven :

yum -y install apache-maven

或者单独下载安装：

wget http://apache.fayea.com/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz
tar zxvf apache-maven-3.3.9-bin.tar.gz

设置环境变量：

MVN_HOME=/usr/local/app/apache-maven-3.3.9
export PATH=$PATH:$MVN_HOME/bin

然后可以使用以下命令编译：

mvn clean package

可以追加参数 -Dmaven.test.skip=true 跳过测试。

$mvn    package  
$ls target/*.ja  

target/myproject-1.0.0.jartarget/myproject-1.0.0.jar.original

**1.6 使用Eclipse下打包方法： **

可以自己运行该插件（但只有在package目标也被使用的情况）。例如：

$   mvn package spring-boot:repackage  
$   ls  target/*.jar

打包可执行jar和war文件

一旦spring-boot-maven-plugin被包含到你的pom.xml中，它就会自动尝试使用spring-boot:repackage目标重写存档以使它们能够执行。为了构建一个jar或war，你应该使用常规的packaging元素配置你的项目：

<?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">  
<!-- ... -->  
<packaging>jar</packaging>  
<!-- ... -->  
</project>

生成的存档在 package 阶段会被SpringBoot增强。你想启动的main类即可以通过指定一个配置选项，也可以通过为manifest添加一个Main-Class属性这种常规的方式实现。如果你没有指定一个main类，该插件会搜索带有publicstaticvoidmain(String[]args)方法的类。

为了构建和运行一个项目的artifact，你可以输入以下命令：

$   mvn package  
$   java    -jar    target/spring-boot01-1.0-SNAPSHOT.jar

这种方式，只要控制台关闭，服务就不能访问了。下面我们使得 jar 包在后台运行:

java -jar spring-boot01-1.0-SNAPSHOT.jar > log.file 2>&1 &

为了构建一个即是可执行的，又能部署到一个外部容器的war文件，你需要标记内嵌容器依赖为"provided"，例如：

<?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">  
<!-- ... -->  
<packaging>war</packaging>  
<!-- ... -->  
<dependencies>  
<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>  
<!-- ... -->  
</dependencies>  
</project>

4、打包为单个jar时，spring boot的启动方式

maven打包之后，会生成两个jar文件：

demo-0.0.1-SNAPSHOT.jar demo-0.0.1-SNAPSHOT.jar.original

其中demo-0.0.1-SNAPSHOT.jar.original是默认的maven-jar-plugin生成的包。

demo-0.0.1-SNAPSHOT.jar是spring boot maven插件生成的jar包，里面包含了应用的依赖，以及spring boot相关的类。下面称之为fat jar。

先来查看spring boot打好的包的目录结构（不重要的省略掉）：


├── META-INF  
│   ├── MANIFEST.MF  
├── application.properties  
├── com  
│   └── example  
│       └── SpringBootDemoApplication.class  
├── lib  
│   ├── aopalliance-1.0.jar  
│   ├── spring-beans-4.2.3.RELEASE.jar  
│   ├── ...  
└── org  
    └── springframework  
        └── boot  
            └── loader  
                ├── ExecutableArchiveLauncher.class  
                ├── JarLauncher.class  
                ├── JavaAgentDetector.class  
                ├── LaunchedURLClassLoader.class  
                ├── Launcher.class  
                ├── MainMethodRunner.class  
                ├── ...

依次来看下这些内容。

MANIFEST.MF

Manifest-Version: 1.0  
Start-Class: com.example.SpringBootDemoApplication  
Implementation-Vendor-Id: com.example  
Spring-Boot-Version: 1.3.0.RELEASE  
Created-By: Apache Maven 3.3.3  
Build-Jdk: 1.8.0_60  
Implementation-Vendor: Pivotal Software, Inc.  
Main-Class: org.springframework.boot.loader.JarLauncher

可以看到有Main-Class是org.springframework.boot.loader.JarLauncher ，这个是jar启动的Main函数。

还有一个Start-Class是com.example.SpringBootDemoApplication，这个是我们应用自己的Main函数

@SpringBootApplication  
public class SpringBootDemoApplication {  
  
    public static void main(String[] args) {  
        SpringApplication.run(SpringBootDemoApplication.class, args);  
    }  
}

com/example 目录

这下面放的是应用的.class文件。

lib目录

这里存放的是应用的Maven依赖的jar包文件。比如spring-beans，spring-mvc等jar。

org/springframework/boot/loader 目录

这下面存放的是Spring boot loader的.class文件。

启动：

我们直接启动：java -jar demo-0.0.1-SNAPSHOT.jar

5、Maven添加本地Jar包

我们有时候项目依赖外部的jar，我们使用Eclipse开发的时候我们直接通过build path添加jar就可以，但是使用mvn 打包的时候就会缺少这个包。

使用system scope

我们直接引入rabbitmq-client.jar。这个方式比较灵活，到新的服务器上，无需做额外的操作。

<dependency>  
        <groupId>rabbitmq.client</groupId>   
        <artifactId>rabbitmq.client</artifactId>   
        <version>3.0</version>   
        <scope>system</scope>   
        <systemPath>${basedir}/src/main/WEB-INF/lib/rabbitmq-client.jar</systemPath>   
    </dependency>

1、groupId和artifactId以及version都是可以随便填写的，scope必须填写为system，而systemPath我们现在我们jar包的目录地址就可以了 2、${basedir}就是项目根目录

将jar包安装到本地repository中

这个需要在新机器上执行mvn install:install-file命令。

mvn install:install-file  
-Dfile= jar文件所存放的地址     
-DgroupId= jar文件所属的group：包名   
-DartifactId=  jar的项目名 名称，一般就是去掉后缀的文件名     
-Dversion=版本号  
-Dpackaging=jar：此包的打包形式，就是jar  
-DgeneratePom=true  
例如执行命令：
mvn install:install-file -Dfile=D:\JAR_LIB\rabbitmq-client.jar -DgroupId=com.rabbitmq -DartifactId=client -Dversion=3.5.0 -Dpackaging=jar  -DgeneratePom=true -DcreateChecksum=true

在项目中引用：

<dependency>  
    <groupId>com.rabbitmq</groupId>  
    <artifactId>client</artifactId>  
    <version>3.5.0</version>  
</dependency>

3、添加 in project repository

设置项目的库目录

<repository>
    <id>in-project</id>
    <name>In Project Repo</name>
    <url>file://${project.basedir}/lib</url>
</repository>

添加依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>client</artifactId>
    <version>3.5.0</version>
</dependency>

jar包及路径必须严格遵循格式：

/groupId/artifactId/version/artifactId-verion.jar

本例中： lib/com/rabbitmq/client/3.5.0/rabbitmq-client-3.5.0.jar

6、部署到javaEE容器

修改启动类，继承 SpringBootServletInitializer 并重写 configure 方法

@RestController
@SpringBootApplication
public class RestjpademoApplication extends SpringBootServletInitializer{

	@RequestMapping("/")
	String return_a_string() {
		return "Spring Data JPA Rest Demo.";
	}
	
//	生成war包的配置，将项目的启动类RestjpademoApplication.java继承SpringBootServletInitializer并重写configure方法
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
	        // TODO Auto-generated method stub
	        return builder.sources(RestjpademoApplication.class);
	    }   
	
	public static void main(String[] args) {
		SpringApplication.run(RestjpademoApplication.class, args);
	}


// 此bean是为了在存储照片信息时，获取到当前hibernate的session，使用在Service包下的FileUpDownload类中，
//	从而能够完成文件信息从字节到Blob类型的转换。
	@Bean
    public HibernateJpaSessionFactoryBean sessionFactory() {
        return new HibernateJpaSessionFactoryBean();
    }
}

修改pom文件中jar 为 war

 <!-- <packaging>jar</packaging> -->  
 <packaging>war</packaging>

修改pom，排除tomcat插件

<dependency>  
           <groupId>org.springframework.boot</groupId>  
           <artifactId>spring-boot-starter-web</artifactId>  
           <exclusions>  
               <exclusion>  
                   <groupId>org.springframework.boot</groupId>  
                   <artifactId>spring-boot-starter-tomcat</artifactId>  
               </exclusion>  
           </exclusions>  
       </dependency>

打包部署到容器

其他 http://blog.youkuaiyun.com/hguisu/article/details/51072683

转载于:https://my.oschina.net/whitejavadog/blog/949600