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

时间  2019-11-25
标签 spring boot 应用 打包 部署 栏目 Spring 繁體版
原文   原文链接

 

摘自: http://blog.csdn.net/hguisu/article/details/51072683html

 

一、Spring Boot内置web

 

 

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

对server的几个经常使用的配置作个简单说明：mysql

 

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. # 项目contextPath，通常在正式发布版本中，咱们不配置  
  2. server.context-path=/myspringboot  
  3. # 错误页，指定发生错误时，跳转的URL。请查看BasicErrorController源码便知  
  4. server.error.path=/error  
  5. # 服务端口  
  6. server.port=9090  
  7. # session最大超时时间(分钟)，默认为30  
  8. server.session-timeout=60  
  9. # 该服务绑定IP地址，启动服务器时如本机不是该IP地址则抛出异常启动失败，只有特殊需求的状况下才配置  
  10. # server.address=192.168.16.11  

 

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

pom.xml依赖配置:git

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

 

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. # tomcat最大线程数，默认为200  
  2. server.tomcat.max-threads=800  
  3. # tomcat的URI编码  
  4. server.tomcat.uri-encoding=UTF-8  
  5. # 存放Tomcat的日志、Dump等文件的临时文件夹，默认为系统的tmp文件夹（如：C:\Users\Shanhy\AppData\Local\Temp）  
  6. server.tomcat.basedir=H:/springboot-tomcat-tmp  
  7. # 打开Tomcat的Access日志，并能够设置日志格式的方法：  
  8. #server.tomcat.access-log-enabled=true  
  9. #server.tomcat.access-log-pattern=  
  10. # accesslog目录，默认在basedir/logs  
  11. #server.tomcat.accesslog.directory=  
  12. # 日志文件目录  
  13. logging.path=H:/springboot-tomcat-tmp  
  14. # 日志文件名称，默认为spring.log  
  15. logging.file=myapp.log  

Jetty 
若是你要选择Jetty，也很是简单，就是把pom中的tomcat依赖排除，并加入Jetty容器的依赖，以下：redis

 

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <dependencies>  
  2.   <dependency>  
  3.     <groupId>org.springframework.boot</groupId>  
  4.     <artifactId>spring-boot-starter-web</artifactId>  
  5.     <exclusions>  
  6.       <exclusion>  
  7.         <groupId>org.springframework.boot</groupId>  
  8.         <artifactId>spring-boot-starter-tomcat</artifactId>  
  9.       </exclusion>  
  10.     </exclusions>  
  11.   </dependency>  
  12.   <dependency>  
  13.     <groupId>org.springframework.boot</groupId>  
  14.     <artifactId>spring-boot-starter-jetty</artifactId>  
  15.   </dependency>  
  16. <dependencies>   

 

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

 

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

 

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

 

1.1 Mavenmongodb

 

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

 

      Maven用户能够继承spring-boot-starter-parent项目来获取合适的默认设置。该父项目提供如下特性：
一、默认编译级别为Java 1.6
二、源码编码为UTF-8
三、一个依赖管理节点，容许你省略普通依赖的 <version>标签，继承自 spring-boot-dependenciesPOM。
      合适的资源过滤
四、合适的插件配置（exec插件，surefire，Git commitID，shade）
五、针对 application.properties和application.yml 的资源过滤
六、最后一点：因为默认配置文件接收Spring风格的占位符（ ${...} ），Maven  filtering改用@..@ 占位符（你可使用Maven属性 resource.delimiter来覆盖它）。

1.2继承starter parent
 
想配置你的项目继承  spring-boot-starter-parent 只须要简单地设置parent为：
[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <!-- Inherit defaults    from    Spring  Boot    -->  
  2. <parent>  
  3. <groupId>org.springframework.boot</groupId>  
  4. <artifactId>spring-boot-starter-parent</artifactId>  
  5. <version>1.3.0.BUILD-SNAPSHOT</version>  
  6. </parent>  

注：你应该只须要在该依赖上指定Spring Boot版本。如他的starters，你能够放心的省略版本号。
 
 
1.3使用没有父POM的SpringBoot
      不是每一个人都喜欢继承spring-boot-starter-parentPOM。你可能须要使用公司标准parent，或你可能倾向于显式声明全部
Maven配置。
若是你不使用 spring-boot-starter-parent ，经过使用一个scope=import 的依赖，你仍能获取到依赖管理的好处：
[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <dependencyManagement>  
  2. <dependencies>  
  3. <dependency>  
  4. <!-- Import  dependency  management  from    Spring  Boot    -->  
  5. <groupId>org.springframework.boot</groupId>  
  6. <artifactId>spring-boot-dependencies</artifactId>  
  7. <version>1.3.0.BUILD-SNAPSHOT</version>  
  8. <type>pom</type>  
  9. <scope>import</scope>  
  10. </dependency>  
  11. </dependencies>  
  12. </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>节
点处：

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <?xml    version="1.0"   encoding="UTF-8"?>  
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4. <modelVersion>4.0.0</modelVersion>  
  5. <!-- ... -->  
  6. <build>  
  7. <plugins>  
  8. <plugin>  
  9. <groupId>org.springframework.boot</groupId>  
  10. <artifactId>spring-boot-maven-plugin</artifactId>  
  11. <version>1.3.0.BUILD-SNAPSHOT</version>  
  12. <executions>  
  13. <execution>  
  14. <goals>  
  15. <goal>repackage</goal>  
  16. </goals>  
  17. </execution>  
  18. </executions>  
  19. </plugin>  
  20. </plugins>  
  21. </build>  
  22. </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 跳过测试。 

 

 

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. $mvn    package  
  2. $ls target/*.ja  

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

 

1.6 使用Eclipse下打包方法： 

打开maven插件的maven package，就能够打包了：

 

打包出来的文件：

若是不包含像上面那样的<execution/>，你能够本身运行该插件（但只有在package目标也被使用的状况）。例如：

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. $   mvn package spring-boot:repackage  
  2. $   ls  target/*.jar  


target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original
若是使用一个里程碑或快照版本，你还须要添加正确的pluginRepository元素：

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <pluginRepositories>  
  2. <pluginRepository>  
  3. <id>spring-snapshots</id>  
  4. <url>http://repo.spring.io/snapshot</url>  
  5. </pluginRepository>  
  6. <pluginRepository>  
  7. <id>spring-milestones</id>  
  8. <url>http://repo.spring.io/milestone</url>  
  9. </pluginRepository>  
  10. </pluginRepositories>  



 

打包可执行jar和war文件

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

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <?xml    version="1.0"   encoding="UTF-8"?>  
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4. <!-- ... -->  
  5. <packaging>jar</packaging>  
  6. <!-- ... -->  
  7. </project>  

 

 


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


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

 

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. $   mvn package  
  2. $   java    -jar    target/spring-boot01-1.0-SNAPSHOT.jar  

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

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

 

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

 

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <?xml    version="1.0"   encoding="UTF-8"?>  
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4. <!-- ... -->  
  5. <packaging>war</packaging>  
  6. <!-- ... -->  
  7. <dependencies>  
  8. <dependency>  
  9. <groupId>org.springframework.boot</groupId>  
  10. <artifactId>spring-boot-starter-web</artifactId>  
  11. </dependency>  
  12. <dependency>  
  13. <groupId>org.springframework.boot</groupId>  
  14. <artifactId>spring-boot-starter-tomcat</artifactId>  
  15. <scope>provided</scope>  
  16. </dependency>  
  17. <!-- ... -->  
  18. </dependencies>  
  19. </project>  



 

 

四、打包为单个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打好的包的目录结构（不重要的省略掉）：

 

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. ├── META-INF  
  2. │   ├── MANIFEST.MF  
  3. ├── application.properties  
  4. ├── com  
  5. │   └── example  
  6. │       └── SpringBootDemoApplication.class  
  7. ├── lib  
  8. │   ├── aopalliance-1.0.jar  
  9. │   ├── spring-beans-4.2.3.RELEASE.jar  
  10. │   ├── ...  
  11. └── org  
  12.     └── springframework  
  13.         └── boot  
  14.             └── loader  
  15.                 ├── ExecutableArchiveLauncher.class  
  16.                 ├── JarLauncher.class  
  17.                 ├── JavaAgentDetector.class  
  18.                 ├── LaunchedURLClassLoader.class  
  19.                 ├── Launcher.class  
  20.                 ├── MainMethodRunner.class  
  21.                 ├── ...                  

 

依次来看下这些内容。

MANIFEST.MF

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. Manifest-Version: 1.0  
  2. Start-Class: com.example.SpringBootDemoApplication  
  3. Implementation-Vendor-Id: com.example  
  4. Spring-Boot-Version: 1.3.0.RELEASE  
  5. Created-By: Apache Maven 3.3.3  
  6. Build-Jdk: 1.8.0_60  
  7. Implementation-Vendor: Pivotal Software, Inc.  
  8. Main-Class: org.springframework.boot.loader.JarLauncher  


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

还有一个Start-Class是com.example.SpringBootDemoApplication，这个是咱们应用本身的Main函数

[plain]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. @SpringBootApplication  
  2. public class SpringBootDemoApplication {  
  3.   
  4.     public static void main(String[] args) {  
  5.         SpringApplication.run(SpringBootDemoApplication.class, args);  
  6.     }  
  7. }  

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 

 

 

五、Maven添加本地Jar包

咱们有时候项目依赖外部的jar，咱们使用Eclipse开发的时候咱们直接经过build path添加jar就能够，可是使用mvn 打包的时候就会缺乏这个包。

 

1. 使用system scope

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

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <dependency>  
  2.         <groupId>rabbitmq.client</groupId>   
  3.         <artifactId>rabbitmq.client</artifactId>   
  4.         <version>3.0</version>   
  5.         <scope>system</scope>   
  6.         <systemPath>${basedir}/src/main/WEB-INF/lib/rabbitmq-client.jar</systemPath>   
  7.     </dependency>  

一、groupId和artifactId以及version都是能够随便填写的 ，scope必须填写为system，而systemPath咱们如今咱们jar包的目录地址就能够了

 

二、${basedir}就是项目根目录

 

 

2. 将jar包安装到本地repository中

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

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. mvn install:install-file  
  2. -Dfile= jar文件所存放的地址     
  3. -DgroupId= jar文件所属的group：包名   
  4. -DartifactId=  jar的项目名 名称，通常就是去掉后缀的文件名     
  5. -Dversion=版本号  
  6. -Dpackaging=jar：此包的打包形式，就是jar  
  7. -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

 

在项目中引用：

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <dependency>  
  2.     <groupId>com.rabbitmq</groupId>  
  3.     <artifactId>client</artifactId>  
  4.     <version>3.5.0</version>  
  5. </dependency>  

 

 

三、添加 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

 

六、部署到javaEE容器

 

 

修改启动类，继承 SpringBootServletInitializer 并重写 configure 方法
[java]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. public class SpringBootSampleApplication extends SpringBootServletInitializer{  
  2.   
  3.     private static final Logger logger = LoggerFactory.getLogger(SpringBootSampleApplication.class);  
  4.   
  5.     @Override  
  6.     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {  
  7.         return builder.sources(this.getClass());  
  8.     }  
  9.   
  10. }  
修改pom文件中jar 为 war
[java]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <!-- <packaging>jar</packaging> -->  
  2. <packaging>war</packaging>  
修改pom，排除tomcat插件
[java]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. <dependency>  
  2.            <groupId>org.springframework.boot</groupId>  
  3.            <artifactId>spring-boot-starter-web</artifactId>  
  4.            <exclusions>  
  5.                <exclusion>  
  6.                    <groupId>org.springframework.boot</groupId>  
  7.                    <artifactId>spring-boot-starter-tomcat</artifactId>  
  8.                </exclusion>  
  9.            </exclusions>  
  10.        </dependency>  
打包部署到容器 
 

 

 

七、热部署

 

 

在咱们开发过程当中，咱们须要常常修改，为了不重复启动项目，咱们能够启用热部署。
Spring-Loaded项目提供了强大的热部署功能，添加/删除/修改 方法/字段/接口/枚举 等代码的时候均可以热部署，速度很快，很方便。
想在Spring Boot中使用该功能很是简单，就是在spring-boot-maven-plugin插件下面添加依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>springloaded</artifactId>
        <version>1.2.5.RELEASE</version>
    </dependency>
</dependencies>
添加之后，经过mvn spring-boot:run启动就支持热部署了。

注意：使用热部署的时候，须要IDE编译类后才能生效，你能够打开自动编译功能，这样在你保存修改的时候，类就自动从新加载了。

 

 

八、使用Profile区分环境

 

application.properties区分环境

spring boot 能够在 “配置文件”、“Java代码类”、“日志配置” 中来配置profile区分不一样环境执行不一样的结果

一、配置文件 
使用配置文件application.yml 和 application.properties 有所区别 
以application.properties 为例，经过文件名来区分环境 application-{profile}.properties 

application.properties

app.name=MyApp
server.port=8080
spring.profiles.active=dev

application-dev.properties

server.port=8081

application-stg.properties

server.port=8082

在启动程序的时候经过添加 –spring.profiles.active={profile} 来指定具体使用的配置 
例如咱们执行 java -jar demo.jar –spring.profiles.active=dev 那么上面3个文件中的内容将被如何应用？ 
Spring Boot 会先加载默认的配置文件，而后使用具体指定的profile中的配置去覆盖默认配置。

app.name 只存在于默认配置文件 application.properties 中，由于指定环境中不存在一样的配置，因此该值不会被覆盖 
server.port 默认为8080，可是咱们指定了环境后，将会被覆盖。若是指定stg环境，server.port 则为 8082 
spring.profiles.active 默认指定dev环境，若是咱们在运行时指定 –spring.profiles.active=stg 那么将应用stg环境，最终 server.port 的值为8082

Maven环境配置
   项目工程统一使用maven的profile插件定义不一样的项目构建环境(dev, alpha, beta, prod),经过filter插件为不一样环境下的配置项注入对应的参数值来实现动态配置目标。
2.3.1定义profile
在POM.xml中配置四个profile，对应项目所处的四个不一样的环境-dev, alpha, beta, prod, profile的id属性即为每一个环境赋予一个惟一的标示，元素的内容则是以key-value的形式出现的键值对，如咱们定义了一个变量，其值在不一样的环境下(不一样id)被赋予了不一样的值(dev, test, pre-prod, prod),要激活不一样的环境打包，咱们能够在命令行经过mvn package –P${profileId}来让其运行，为了开发便利，默认激活的是dev开发环境，即开发人员不须要经过命令行手动输入-p参数也能运行dev环境的打包。
 <profile>
            <!-- 本地参数 -->
            <id>dev</id>
            <properties>
<server.port>8081</server.port>
<server.address>0.0.0.0</server.address>
<profileActive>dev</profileActive>
            </properties>
<build>
<filters>
<filter>
<groupId>${basedir}/src/main/resources/dev.properties</groupId>
</filter>
 </profile>

九、建立一个Linux 应用的sh脚本

下面几个脚本仅供参考：

打包：clean.sh

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. #0、check user  
  2. TIME_STAMP=`date +%Y%m%d%H%M`  
  3. WHO=`whoami`  
  4. if [ "$WHO" != 'www' ]; then  
  5.         echo 'current user is not www'  
  6.         echo 'exit'  
  7.         exit  
  8. fi  
  9. CODE_HOME=/home/www/app  
  10. PROJECTNAME=qrealtime  
  11. cd $CODE_HOME/$PROJECTNAME  
  12. git pull  
  13. mvn clean package  
  14. pid=`ps -ef |grep $PROJECTNAME |grep -v "grep" |awk '{print $2}' `   
  15. if [ $pid != "" ]; then  
  16.         echo "App  is  running  and pid=$pid"  
  17. else  
  18.         echo "App is not  running."  
  19. fi  

 

 

start.sh

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. #0、check user  
  2. TIME_STAMP=`date +%Y%m%d%H%M`  
  3. WHO=`whoami`  
  4. if [ "$WHO" != 'www' ]; then  
  5.      echo 'current user is not www'  
  6.      echo 'exit'  
  7.      exit  
  8. fi  
  9. CODE_HOME=/home/www/app  
  10. PROJECTNAME=qrealtime  
  11. cd $CODE_HOME/$PROJECTNAME  
  12. pid=`ps -ef |grep $PROJECTNAME |grep -v "grep" |awk '{print $2}'`   
  13. if [ $pid ]; then  
  14.     echo "App  is  running  and pid=$pid"  
  15. else  
  16.    nohup java -jar $CODE_HOME/$PROJECTNAME/target/$<span style="font-family: 'microsoft yahei';">PROJECTNAME</span><span style="font-family: 'microsoft yahei';">-0.0.1-SNAPSHOT.jar > /dev/null 2>&1 &</span>  
  17. fi  



 

stop.sh

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. #0、check user  
  2. TIME_STAMP=`date +%Y%m%d%H%M`  
  3. WHO=`whoami`  
  4. if [ "$WHO" != 'www' ]; then  
  5.         echo 'current user is not www'  
  6.         echo 'exit'  
  7.         exit  
  8. fi  
  9. CODE_HOME=/home/www/app  
  10. PROJECTNAME=qrealtime  
  11. cd $CODE_HOME/$PROJECTNAME  
  12. pid=`ps -ef |grep $PROJECTNAME |grep -v "grep" |awk '{print $2}' `   
  13. if [ $pid ]; then  
  14.     echo "App  is  running  and pid=$pid"  
  15.     kill -9 $pid  
  16.     if [[ $? -eq 0 ]];then   
  17.        echo "sucess to stop $PROJECTNAME "   
  18.     else   
  19.        echo "fail to stop $PROJECTNAME "  
  20.      fi  
  21. fi  

restart

 

 

[html]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. #0、check user  
  2. TIME_STAMP=`date +%Y%m%d%H%M`  
  3. WHO=`whoami`  
  4. if [ "$WHO" != 'www' ]; then  
  5.         echo 'current user is not www'  
  6.         echo 'exit'  
  7.         exit  
  8. fi  
  9. CODE_HOME=/home/www/app  
  10. PROJECTNAME=qrealtime  
  11. cd $CODE_HOME/$PROJECTNAME  
  12. pid=`ps -ef |grep $PROJECTNAME |grep -v "grep" |awk '{print $2}' `   
  13. if [ $pid ]; then  
  14.     echo "App  is  running  and pid=$pid"  
  15.     kill -9 $pid  
  16. fi  
  17. nohup java -jar $CODE_HOME/$PROJECTNAME/target/$PROJECTNAME-0.0.1-SNAPSHOT.jar > /dev/null 2>&1 &  



 

 

 

十、Spring Boot应用的docker化

 

首先看Spring Boot应用程序的Docker化，因为Spring Boot内嵌了tomcat、Jetty等容器，所以咱们对docker镜像的要求就是须要java运行环境。个人应用代码的的Dockerfile文件以下：

#基础镜像：仓库是java，标签用8u66-jdk FROM java:8u66-jdk #当前镜像的维护者和联系方式 MAINTAINER duqi duqi@example.com #将打包好的spring程序拷贝到容器中的指定位置 ADD target/bookpub-0.0.1-SNAPSHOT.jar /opt/bookpub-0.0.1-SNAPSHOT.jar #容器对外暴露8080端口 EXPOSE 8080 #容器启动后须要执行的命令 CMD java -Djava.security.egd=file:/dev/./urandom -jar /opt/bookpub-0.0.1-SNAPSHOT.jar

由于目前的示例程序比较简单，这个dockerfile并无在将应用程序的数据存放在宿主机上。若是你的应用程序须要写文件系统，例如日志，最好利用VOLUME /tmp命令，这个命令的效果是：在宿主机的/var/lib/docker目录下建立一个临时文件并把它连接到容器中的/tmp目录。

把这个Dockerfile放在项目的根目录下便可，后续经过docker-compose build统一构建：基础镜像是只读的，而后会在该基础镜像上增长新的可写层来供咱们使用，所以java镜像只须要下载一次。

docker-compose是用来作docker服务编排，参看《Docker从入门到实践》中的解释：

Compose 项目目前在 Github 上进行维护，目前最新版本是 1.2.0。Compose 定位是“defining and running complex applications with Docker”，前身是 Fig，兼容 Fig 的模板文件。

Dockerfile 可让用户管理一个单独的应用容器；而 Compose 则容许用户在一个模板（YAML 格式）中定义一组相关联的应用容器（被称为一个 project，即项目），例如一个 Web 服务容器再加上后端的数据库服务容器等。

单个docker用起来确实没什么用，docker技术的关键在于持续交付，经过与jekins的结合，能够实现这样的效果：开发人员提交push，而后jekins就自动构建并测试刚提交的代码，这就是我理解的持续交付。

 

十一、守护进程启动

 

使用java命令运行应用很是简单，可是一般咱们都是经过ssh命令链接到服务器并运行它，一旦ssh链接断开，那么由它fork的java子进程也就随之销毁了。因此咱们必须借助工具将应用做为服务运行在服务器上：

Systemd

systemd 是Linux 下的一款系统和服务管理器。能够为Spring Boot应用编写启动脚本：

 

[java]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. [Unit]  
  2. Description=Spring Boot Application  
  3.   
  4. [Service]  
  5. ExecStart=/usr/bin/java -jar location_of_jar_file.jar --spring.config.location=location_of_config.properties --spring.profiles.active=profile  
  6. User=${your expected user}  
  7.   
  8. [Install]  
  9. WantedBy=multi-user.target  

 

 

Supervisord

Supervisord配置：

 

[java]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. [program:app]  
  2. command=/usr/bin/java -jar location_of_jar_file.jar --spring.config.location=location_of_config.properties --spring.profiles.active=profile  
  3. user=${your expected user}  
  4. autostart=true  
  5. autorestart=true  
  6. startsecs=10  
  7. startretries=3  

 

 

 

十二、生产环境运维支持

 

 

    与开发和测试环境不一样的是，当应用部署到生产环境时，须要各类运维相关的功能的支持，包括性能指标、运行信息和应用管理等。全部这些功能都有不少技术和开源库能够实现。Spring Boot 对这些运维相关的功能进行了整合，造成了一个功能完备和可定制的功能集，称之为 Actuator。只须要在 POM 文件中增长对 “org.springframe.boot:spring-boot-starter-actuator” 的依赖就能够添加 Actuator。Actuator 在添加以后，会自动暴露一些 HTTP 服务来提供这些信息。这些 HTTP 服务的说明如表 2。

 Spring Boot Actuator 所提供的 HTTP 服务
名称 说明 是否包含敏感信息
autoconfig 显示 Spring Boot 自动配置的信息。 是
beans 显示应用中包含的 Spring bean 的信息。 是
configprops 显示应用中的配置参数的实际值。 是
dump 生成一个 thread dump。 是
env 显示从 ConfigurableEnvironment 获得的环境配置信息。 是
health 显示应用的健康状态信息。 否
info 显示应用的基本信息。 否
metrics 显示应用的性能指标。 是
mappings 显示 Spring MVC 应用中经过“
@RequestMapping”添加的路径映射。		 是
shutdown 关闭应用。 是
trace 显示应用相关的跟踪（trace）信息。 是

对于表中的每一个服务，经过访问名称对应的 URL 就能够获取到相关的信息。如访问“/info”就能够获取到 info 服务对应的信息。服务是否包含敏感信息说明了该服务暴露出来的信息是否包含一些比较敏感的信息，从而肯定是否须要添加相应的访问控制，而不是对全部人都公开。全部的这些服务都是能够配置的，好比经过改变名称来改变相应的 URL。下面对几个重要的服务进行介绍。

health 服务

Spring Boot 默认提供了对应用自己、关系数据库链接、MongoDB、Redis 和 Rabbit MQ 的健康状态的检测功能。当应用中添加了 DataSource 类型的 bean 时，Spring Boot 会自动在 health 服务中暴露数据库链接的信息。应用也能够提供本身的健康状态信息，如代码清单 7 所示。

health 服务
@Component
public class AppHealthIndicator implements HealthIndicator {
 @Override
 public Health health() {
 return Health.up().build();
 }
}

应用只须要实现 org.springframework.boot.actuate.health.HealthIndicator 接口，并返回一个 org.springframework.boot.actuate.health.Health 对象，就能够经过 health 服务来获取所暴露的信息。health 服务返回的结果

{"status":"UP","app":{"status":"UP"},"db":{"status":"UP","database":"HSQL Database Engine","hello":1}}

info 服务

info 服务所暴露的信息是彻底由应用来肯定的。应用中任何以“info.”开头的配置参数会被自动的由 info 服务来暴露。只须要往 application.properties 中添加以“info.”开头的参数便可，如：

info.app_name=My First Spring Boot Application
info.app_version=1.0.0

当访问“/info”时，访问的 JSON 数据：

{"app_name":"My First Spring Boot Application","app_version":"1.0.0"}

metrics 服务

当访问 metrics 服务时，能够看到 Spring Boot 经过 SystemPublicMetrics 默认提供的一些系统的性能参数值，包括内存、CPU、Java 类加载和线程等的基本信息。应用能够记录其余所须要的信息。Spring Boot 默认提供了两种类型的性能指标记录方式：gauge 和 counter。gauge 用来记录单个绝对数值，counter 用来记录增量或减量值。好比在一个 Web 应用中，能够用 counter 来记录当前在线的用户数量。当用户登陆时，把 counter 的值加 1；当用户退出时，把 counter 的值减 1。

示例：

@RestController
public class GreetingsController {
 @Autowired
 private CounterService counterService;
 @RequestMapping("/greet")
 public String greet() {
 counterService.increment("myapp.greet.count");
 return "Hello!";
 }
}

上面代码添加了对 Spring Boot 提供的 CounterService 的依赖。当 greet 方法被调用时，会把名称为“myapp.greet.count”的计数器的值加 1。也就是当用户每次访问“/greet”时，该计算器就会被加 1。除了 CounterService 以外，还可使用 GaugeService 来记录绝对值。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程