springboot部署腳本
A. spring boot 環境怎麼搭建
SpringBoot是Spring產品中一個新的子項目，致力於簡便快捷地搭建基於Spring的獨立可運行的應用。大多數的SpringBoot應用只需要非常少的Spring配置。你能夠使用SpringBoot創建java應用並通過java-jar來運行或者創建傳統的通過war來部署的應用。SpringBoot也提供了一個命令行工具來運行spring腳本。SpringBoot的目標是：快速開發基於Spring的應用開箱即用的微服務提供一些大型項目常用的非功能性特性，例如：嵌入式服務、安全、監控、健康檢查、外部配置不用生成代碼，沒有xml配置
B. 如何部署Spring Boot應用
在Ubuntu中安裝Java8
以下是一個簡單的安裝方法。
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
$ java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)
2. 本地使用Gradle發布Spring Boot應用
我這里使用Jetty9作為內置的伺服器。
// ...
bootRun {
systemProperties = System.properties
}
configurations {
compile.exclude mole: "spring-boot-starter-tomcat"
}
dependencies {
// spring boot
compile "org.springframework.boot:spring-boot-starter-web:1.3.0.M5"
compile "org.springframework.boot:spring-boot-starter-jetty"
// ...
}
//...
在本地運行默認使用src/main/resources/application.yml作為配置文件，而在proction環境中我們系統它支持提供外部的配置文件application-proction.yml。
./gradlew bootRun # 開發環境下默認使用項目里的application.yml
# 在本地測試使用外部配置文件
./gradlew bootRun -Dspring.config.location=/path/to/application-proction.yml
# 發布
./gradlew build
# 運行
java -jar build/libs/SpringBlog-0.1.jar # 默認使用jar包裡面的application.yml配置文件
# 使用外部配置文件
java -jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/application-proction.yml
3. 在Ubuntu伺服器上部署Spring Boot應用
# 上傳SpringBlog-0.1.jar到伺服器
scp build/libs/SpringBlog-0.1.jar root@your_server_ip:/root/spring-blog/current
# 在伺服器上配置生產環境的配置文件
scp application-proction.yml root@your_server_ip:/root/spring-blog/current
然後SSH登錄伺服器，修改配置文件application-proction.yml，試運行應用。
ssh root@your_server_ip
cd spring-blog/current
java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
# application-proction.yml
server:
address: raysmond.com # 使用域名或者IP，啟動之後就可以這個域名或IP訪問網站了
port: 80
contextPath:
spring:
profiles:
active: proction
thymeleaf:
cache: true
jade4j:
caching: true
dataSource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1/spring_blog
username: root
password:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
hbm2ddl.auto: update
show_sql: false
redis:
host: localhost
port: 6379
4. 如何在Ubuntu中後台運行Spring Boot應用？
推薦使用nohup這個命令。
cd /root/spring-blog/current
nohup java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
> ../logs/proction.log 2> ../logs/proction.err &
在Ubuntu還可以/etc/init.d目錄下新建一個腳本，把SpringBlog作為service來運行，這樣不用每次都打這么繁瑣的命令了。新建一個/etc/init.d/spring_blog文件，內容如下：
#!/bin/sh
SERVICE_NAME=spring_blog
HOME=/root/spring-blog
PATH_TO_JAR=$HOME/current/SpringBlog-0.1.jar
PID_PATH_NAME=/tmp/spring_blog.pid
LOG=$HOME/logs/proction.log
ERROR_LOG=$HOME/logs/proction.err
CONFIG=$HOME/application-proction.yml
case $1 in
start)
echo "Starting $SERVICE_NAME ..."
if [ ! -f $PID_PATH_NAME ]; then
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is already running ..."
fi
;;
stop)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stoping ..."
kill $PID;
echo "$SERVICE_NAME stopped ..."
rm $PID_PATH_NAME
else
echo "$SERVICE_NAME is not running ..."
fi
;;
restart)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stopping ...";
kill $PID;
echo "$SERVICE_NAME stopped ...";
rm $PID_PATH_NAME
echo "$SERVICE_NAME starting ..."
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is not running ..."
fi
;;
esac
現在就可以使用service的方式來運行網站了。
sudo service spring_blog start
sudo service spring_blog stop
sudo service spring_blog restart
5. 在本地自動化部署網站到遠程伺服器
在本地我用了一個shell腳本和一個python腳本來配合自動化部署。
deploy.sh 使用gradle的命令發布jar包，使用scp命令吧jar包上傳到伺服器上；
deploy.py 使用SSH遠程登錄伺服器，並在伺服器上執行部署命令。
# deploy.sh
#!/bin/bash
SERVER="your_server_ip"
JAR="build/libs/SpringBlog-0.1.jar"
echo "Building $JAR..."
./gradlew build
echo "Upload $JAR to server $SERVER..."
scp $JAR root@$SERVER:/root/spring-blog/
python deploy.py
deploy.py主要使用了一個paramiko庫，用於SSH遠程登錄伺服器，並執行命令。這個腳本會把伺服器上/root/spring-blog/current/SpringBlog-0.1.jar備份到/root/spring-blog/releases中，並把新發布的jar包放到/root/spring-blog/current中，然後重啟spring_blog服務。
全選復制放進筆記#!/usr/bin/python
import paramiko
import threading
import time
ip = 'your_server_ip'
user = 'root'
password = ''
jar = 'SpringBlog-0.1.jar'
home='/root/spring-blog'
current=home+"/current"
releases=home+"/releases"
def execute_cmds(ip, user, passwd, cmd):
try:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,user,passwd,timeout=5)
for m in cmd:
print m
stdin, stdout, stderr = ssh.exec_command(m)
# stdin.write("Y")
out = stdout.readlines()
for o in out:
print o,
print '%s OK '%(ip)
ssh.close()
except :
print '%s Error '%(ip)
if __name__=='__main__':
print 'Start deploying %s to server %s'%(jar, ip)
now = time.strftime("%Y%m%d%H%M%S")
cmd = [
'echo Stop spring_blog service... && service spring_blog stop',
'echo Flush all redis cache data... && redis-cli -r 1 flushall',
'echo Stop redis server... && service redis_6379 stop',
'echo Use new jar... ' +
' && mv ' + current + '/' + jar + ' ' + releases + '/' + now + '_' + jar ,
'mv ' + home + '/' + jar + ' ' + current + '/' + jar,
'echo Stop redis... && service redis_6379 start',
'echo Start spring_blog service... && service spring_blog start ' +
' && echo All done.'
]
a=threading.Thread(target=execute_cmds, args=(ip,user,password,cmd))
a.start()
配置完以後，在本地寫完代碼就可以運行./deploy.sh一鍵部署到遠程伺服器了。
C. SpringBoot項目如何進行打包部署
打成jar進行部署(步驟)
1. 需要在application.properties當中配置埠
2.marven的配置文件
注意:這塊一定要配置否則打jar的時候會說找不到主類
3.在啟動類當中加上extends SpringBootServletInitializer並重寫configure方法，這是為了打包springboot項目用的
4.然後按照順序運行mvn clean再mvn install
D. 為什麼越來越多的開發者選擇使用Spring Boot
(1) Spring Boot使編碼變簡單
(2) Spring Boot使配置變簡單
(3) Spring Boot使部署變簡單
(4) Spring Boot使監控變簡單
Spring Boot繼承了Spring的優點，並新增了一些新功能和特性：
(1)SpringBoot是伴隨著Spring4.0誕生的，一經推出，引起了巨大的反向;
(2)從字面理解，Boot是引導的意思，因此SpringBoot幫助開發者快速搭建Spring框架;
(3)SpringBoot幫助開發者快速啟動一個Web容器;
(4)SpringBoot繼承了原有Spring框架的優秀基因;
(5)SpringBoot簡化了使用Spring的過程;
(6)Spring Boot為我們帶來了腳本語言開發的效率，但是Spring Boot並沒有讓我們意外的新技術，都是Java EE開發者常見的額技術。
Spring Boot主要特性
(1)遵循「習慣優於配置」的原則，使用Spring Boot只需要很少的配置，大部分的時候我們直接使用默認的配置即可;
(2)項目快速搭建，可以無需配置的自動整合第三方的框架;
(3)可以完全不使用XML配置文件，只需要自動配置和Java Config;
(4)內嵌Servlet容器，降低了對環境的要求，可以使用命令直接執行項目，應用可用jar包執行：java -jar;
(5)提供了starter POM, 能夠非常方便的進行包管理, 很大程度上減少了jar hell或者dependency hell;
(6)運行中應用狀態的監控;
(7)對主流開發框架的無配置集成;
(8)與雲計算的天然繼承;
E. spring boot 需要安裝嗎
在開發Spring Boot應用的過程中，Spring Boot直接執行public static void main()函數並啟動一個內嵌的應用伺服器（取決於類路徑上的以來是Tomcat還是jetty）來處理應用請求。對於生產環境，這樣的部署方式同樣有效，同時Spring Boot也支持傳統的部署方式——將war包放入應用伺服器中啟動運行。內嵌應用伺服器在使用Maven或Gradle構建Spring Boot應用的過程中，Spring Boot插件提供了巨大的幫助，除了生命各類預定義的依賴，它還能夠構建可以直接運行的jar包——包含了所有的依賴以及內嵌應用伺服器。應用的分發也就變得非常簡單，任何人拿到了這個jar包，只需要簡單運行java -jar your.jar就可以啟動應用，無需任何構建工具、安裝過程以及應用伺服器。內嵌應用伺服器配置在生產環境中，應用伺服器需要各類配置，Spring Boot本身提供了一種非常簡單的配置機制——application.properties：server.port=8080 # 監聽埠server.address= # 綁定的地址server.session-timeout= #session有效時長server.context-path= #默認為/server.ssl.* #ssl相關配置Tomcat默認情況下，Spring Boot啟動的內嵌容器就是Tomcat，對於Tomcat有幾個非常重要的配置：server.tomcat.basedir=/tmptomcat的baseDir，日誌、mp等文件都存在於這個目錄中，一般是系統的臨時文件夾/tmp，但也可以按照自己的需求變更位置。server.tomcat.access-log-pattern= # log pattern of the access logserver.tomcat.access-log-enabled=false # is access logging enabled這兩個配置打開Tomcat的Access日誌，並可以設置日誌格式。Jetty如果你不喜歡Tomcat，Jetty也是一個非常不錯的選擇。使用Jetty的方式也非常簡單——把tomcat依賴從Maven或Gradle中移除，加入Jetty內嵌容器的依賴： org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-tomcat org.springframework.boot spring-boot-starter-jetty Java EE應用伺服器除了內嵌容器的部署模式，Spring Boot也支持將應用部署至已有的Tomcat容器, 或JBoss, WebLogic等傳統Java EE應用伺服器。以Maven為例，首先需要將從jar改成war，然後取消spring-boot-maven-plugin，然後修改Application.java：package demo;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.EnableAutoConfiguration;import org.springframework.boot.builder.SpringApplicationBuilder;import org.springframework.boot.context.web.SpringBootServletInitializer;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@Configuration@ComponentScan@EnableAutoConfigurationpublic class Application extends SpringBootServletInitializer { public static void main(String[] args) { SpringApplication.run(applicationClass, args); } @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(applicationClass); } private static Class applicationClass = Application.class;}接下來打包應用，將生成的war包放入應用伺服器目錄即可。使用外部配置文件在應用程序中有很多配置項，例如資料庫連接地址、日誌文件位置、應用伺服器配置等等。為了安全與靈活性，我們推薦將Spring Boot的配置文件放在生產環境的伺服器上，並嚴格控制訪問許可權。在運行應用時可以通過命令行參數指定配置文件：java -jar location_of_your_jar_file.jar --spring.config.location=location_of_your_config_file.properties這樣做的好處是：配置位於生產環境中，資料庫連接等私密信息不容易泄露靈活性強，同一份代碼（包括構建的jar包）可以應用於不同的環境配置（開發、測試、生產）使用Profile區分環境在某些情況下，應用的某些業務邏輯可能需要有不同的實現。例如郵件服務，假設EmailService中包含的send(String email)方法向指定地址發送電子郵件，但是我們僅僅希望在生產環境中才執行真正發送郵件的代碼，而開發環境里則不發送以免向用戶發送無意義的垃圾郵件。我們可以藉助Spring的註解@Profile實現這樣的功能，這樣需要定義兩個實現EmailService借口的類：@Service@Profile("dev")class DevEmailService implements EmailService { public void send(String email) { //Do Nothing }}@Service@Profile("prod")class ProdEmailService implements EmailService { public void send(String email) { //Real Email Service Logic }}@Profile("dev")表明只有Spring定義的Profile為dev時才會實例化DevEmailService這個類。那麼如何設置Profile呢？在配置文件中指定在application.properties中加入：spring.profiles.active=dev通過命令行參數java -jar app.jar --spring.profiles.active=dev以服務的形式運行應用使用java命令運行應用非常簡單，但是通常我們都是通過ssh命令連接到伺服器並運行它，一旦ssh連接斷開，那麼由它fork的java子進程也就隨之銷毀了。所以我們必須藉助工具將應用作為服務運行在伺服器上：Systemdsystemd 是Linux 下的一款系統和服務管理器。可以為Spring Boot應用編寫啟動腳本：[Unit]Description=Spring Boot Application[Service]ExecStart=/usr/bin/java -jar location_of_jar_file.jar --spring.config.location=location_of_config.properties --spring.profiles.active=profileUser=${your expected user}[Install]WantedBy=multi-user.targetSupervisordSupervisord是用Python實現的一款非常實用的進程管理工具。可以為Spring Boot應用編寫：[program:app]command=/usr/bin/java -jar location_of_jar_file.jar --spring.config.location=location_of_config.properties --spring.profiles.active=profileuser=${your expected user}autostart=trueautorestart=truestartsecs=10startretries=3spring boot 需要安裝嗎
F. springboot 怎麼部署
1、要將$http中的Content-Type設置為application/x-www-form-urlencoded因為目前的瀏覽器只支持這種類型的跨域
2、需要在Application同級目錄下寫一個配置類，在裡面配置一個返回類型為WebMvcConfigurerAdapter的Bean，用registry.addMapping("/*")設置攔截的范圍"/*"代表攔截所有請求。
G. spring boot 使用腳本啟動.bat怎麼寫
Spring Boot 是 Spring 產品中一個新的子項目，致力於簡便快捷地搭建基於 Spring 的獨立可運行的應用。大多數的 Spring Boot 應用只需要非常少的 Spring 配置。
你能夠使用 Spring Boot 創建 Java 應用並通過 java -jar 來運行或者創建傳統的通過 war 來部署的應用。Spring Boot 也提供了一個命令行工具來運行 spring 腳本。
Spring Boot 的目標是：
快速開發基於 Spring 的應用
開箱即用的微服務
提供一些大型項目常用的非功能性特性，例如：嵌入式服務、安全、監控、健康檢查、外部配置
不用生成代碼，沒有 xml 配置
H. 如何在Ubuntu 14.04伺服器上自動化部署Spring Boot的應用
1. 在Ubuntu中安裝Java8
以下是一個簡單的安裝方法。
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
$ java -version
java version "1.8.0_60"
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)
2. 本地使用Gradle發布Spring Boot應用
我這里使用Jetty9作為內置的伺服器。
// ...
bootRun {
systemProperties = System.properties
}
configurations {
compile.exclude mole: "spring-boot-starter-tomcat"
}
dependencies {
// spring boot
compile "org.springframework.boot:spring-boot-starter-web:1.3.0.M5"
compile "org.springframework.boot:spring-boot-starter-jetty"
// ...
}
//...
在本地運行默認使用 src/main/resources/application.yml
作為配置文件，而在proction環境中我們系統它支持提供外部的配置文件 application-proction.yml
。
./gradlew bootRun # 開發環境下默認使用項目里的application.yml
# 在本地測試使用外部配置文件
./gradlew bootRun -Dspring.config.location=/path/to/application-proction.yml
# 發布
./gradlew build
# 運行
java -jar build/libs/SpringBlog-0.1.jar # 默認使用jar包裡面的application.yml配置文件
# 使用外部配置文件
java -jar build/libs/SpringBlog-0.1.jar --spring.config.location=/path/to/application-proction.yml
3. 在Ubuntu伺服器上部署Spring Boot應用
# 上傳SpringBlog-0.1.jar到伺服器
scp build/libs/SpringBlog-0.1.jar root@your_server_ip:/root/spring-blog/current
# 在伺服器上配置生產環境的配置文件
scp application-proction.yml root@your_server_ip:/root/spring-blog/current
然後 SSH
登錄伺服器，修改配置文件 application-proction.yml
，試運行應用。
ssh root@your_server_ip
cd spring-blog/current
java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml
# application-proction.yml
server:
address: raysmond.com # 使用域名或者IP，啟動之後就可以這個域名或IP訪問網站了
port: 80
contextPath:
spring:
profiles:
active: proction
thymeleaf:
cache: true
jade4j:
caching: true
dataSource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1/spring_blog
username: root
password:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
hbm2ddl.auto: update
show_sql: false
redis:
host: localhost
port: 6379
4. 如何在Ubuntu中後台運行Spring Boot應用？
推薦使用 nohup
這個命令。
cd /root/spring-blog/current
nohup java -jar SpringBlog-0.1.jar --spring.config.location=application-proction.yml \
> ../logs/proction.log 2> ../logs/proction.err &
在Ubuntu還可以 /etc/init.d
目錄下新建一個腳本，把SpringBlog作為service來運行，這樣不用每次都打這么繁瑣的命令了。新建一個 /etc/init.d/spring_blog
文件，內容如下：
#!/bin/sh
SERVICE_NAME=spring_blog
HOME=/root/spring-blog
PATH_TO_JAR=$HOME/current/SpringBlog-0.1.jar
PID_PATH_NAME=/tmp/spring_blog.pid
LOG=$HOME/logs/proction.log
ERROR_LOG=$HOME/logs/proction.err
CONFIG=$HOME/application-proction.yml
case $1 in
start)
echo "Starting $SERVICE_NAME ..."
if [ ! -f $PID_PATH_NAME ]; then
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is already running ..."
fi
;;
stop)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stoping ..."
kill $PID;
echo "$SERVICE_NAME stopped ..."
rm $PID_PATH_NAME
else
echo "$SERVICE_NAME is not running ..."
fi
;;
restart)
if [ -f $PID_PATH_NAME ]; then
PID=$(cat $PID_PATH_NAME);
echo "$SERVICE_NAME stopping ...";
kill $PID;
echo "$SERVICE_NAME stopped ...";
rm $PID_PATH_NAME
echo "$SERVICE_NAME starting ..."
cd $HOME/current
nohup java -jar $PATH_TO_JAR --spring.config.location=application-proction.yml > $LOG 2> $ERROR_LOG &
echo $! > $PID_PATH_NAME
echo "$SERVICE_NAME started ..."
else
echo "$SERVICE_NAME is not running ..."
fi
;;
esac
現在就可以使用service的方式來運行網站了。
sudo service spring_blog start
sudo service spring_blog stop
sudo service spring_blog restart
5. 在本地自動化部署網站到遠程伺服器
在本地我用了一個shell腳本和一個python腳本來配合自動化部署。
deploy.sh
使用 gradle
的命令發布jar包，使用 scp
命令吧jar包上傳到伺服器上；
deploy.py
使用 SSH
遠程登錄伺服器，並在伺服器上執行部署命令。
# deploy.sh
#!/bin/bash
SERVER="your_server_ip"
JAR="build/libs/SpringBlog-0.1.jar"
echo "Building $JAR..."
./gradlew build
echo "Upload $JAR to server $SERVER..."
scp $JAR root@$SERVER:/root/spring-blog/
python deploy.py
deploy.py
主要使用了一個 paramiko
庫，用於 SSH
遠程登錄伺服器，並執行命令。這個腳本會把伺服器上 /root/spring-blog/current/SpringBlog-0.1.jar
備份到 /root/spring-blog/releases
中，並把新發布的jar包放到 /root/spring-blog/current
中，然後重啟 spring_blog
服務。
#!/usr/bin/python
import paramiko
import threading
import time
ip = 'your_server_ip'
user = 'root'
password = ''
jar = 'SpringBlog-0.1.jar'
home='/root/spring-blog'
current=home+"/current"
releases=home+"/releases"
def execute_cmds(ip, user, passwd, cmd):
try:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,user,passwd,timeout=5)
for m in cmd:
print m
stdin, stdout, stderr = ssh.exec_command(m)
# stdin.write("Y")
out = stdout.readlines()
for o in out:
print o,
print '%s\tOK\n'%(ip)
ssh.close()
except :
print '%s\tError\n'%(ip)
if __name__=='__main__':
print 'Start deploying %s to server %s'%(jar, ip)
now = time.strftime("%Y%m%d%H%M%S")
cmd = [
'echo Stop spring_blog service... && service spring_blog stop',
'echo Flush all redis cache data... && redis-cli -r 1 flushall',
'echo Stop redis server... && service redis_6379 stop',
'echo Use new jar... ' + \
' && mv ' + current + '/' + jar + ' ' + releases + '/' + now + '_' + jar ,
'mv ' + home + '/' + jar + ' ' + current + '/' + jar,
'echo Stop redis... && service redis_6379 start',
'echo Start spring_blog service... && service spring_blog start ' + \
' && echo All done.'
]
a=threading.Thread(target=execute_cmds, args=(ip,user,password,cmd))
a.start()
配置完以後，在本地寫完代碼就可以運行 ./deploy.sh
一鍵部署到遠程伺服器了。
I. spring boot 怎麼部署
1、使用maven
2、maven install，生成一個jar包，假設名字是「MyApp-1.10.jar」
3、在命令行窗口輸入 java -jar MyApp-1.10.jar就可以運行了！