springboot部署域名

1、springboot如何设置默认的首页

1.spring boot中可以设置默认首页，当输入域名是可以自动跳转到默认指定的网页
@Configuration
public class DefaultView extends WebMvcConfigurerAdapter{

@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("forward:/index");
registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
super.addViewControllers(registry);
}
}

2、如何配置spring boot内嵌的tomcat8的最大线程数，最大连接数

tomcat最大线程数的设置
Tomcat的server.xml中连接器设置如下

<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true" />
<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true" />

tomcat在配置时设置最大线程数，当前线程数超过这个数值时会出错，那么有没有办法捕获到这个错误，从而在client端显示出错信息？

2. 如何加大tomcat连接数
在tomcat配置文件server.xml中的<Connector />配置中，和连接数相关的参数有：
minProcessors：最小空闲连接线程数，用于提高系统处理性能，默认值为10
maxProcessors：最大连接线程数，即：并发处理的最大请求数，默认值为75
acceptCount：允许的最大连接数，应大于等于maxProcessors，默认值为100
enableLookups：是否反查域名，取值为：true或false。为了提高处理能力，应设置为false
connectionTimeout：网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。
其中和最大连接数相关的参数为maxProcessors和acceptCount。如果要加大并发连接数，应同时加大这两个参数。
web server允许的最大连接数还受制于操作系统的内核参数设置，通常Windows是2000个左右，Linux是1000个左右。tomcat5中的配置示例：
<Connector port="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true" />
对于其他端口的侦听配置，以此类推。

3. tomcat中如何禁止列目录下的文件
在{tomcat_home}/conf/web.xml中，把listings参数设置成false即可，如下：
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>

4.如何加大tomcat可以使用的内存
tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，需要调大。
Unix下，在文件{tomcat_home}/bin/catalina.sh的前面，增加如下设置：
JAVA_OPTS='-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】'
需要把这个两个参数值调大。例如：
JAVA_OPTS='-Xms256m -Xmx512m'
表示初始化内存为256MB，可以使用的最大内存为512MB

3、如何通过域名访问阿里云部署的springboot项

1、首先你要有个域名，阿里云可以买
2、域名需要做解析，解析到你阿里云的ip上
3、阿里云控制台的防火墙和阿里云服务器（Linux）本身的防火墙都要打开 80 端口
4、springboot项目启动时设置端口为 80 （获取通过nginx转发也可以）

4、spring cloud 本地配置怎么自动部署

Spring Cloud 习笔记（）——入门、特征、配置

0 放前面
0.1 参考文档

0.2 maven配置

org.springframework.boot
spring-boot-starter-parent
1.5.2.RELEASE

org.springframework.cloud
spring-cloud-dependencies
Dalston.RELEASE
pom
import

org.springframework.cloud
spring-cloud-starter-config

org.springframework.cloud
spring-cloud-starter-eureka

0.3 简介
Spring Cloud发员提供快速构建布式系统些通用模式（例配置管理服务发现断路器智能路由微代理控制总线性令牌全局锁领导选举布式 群集状态） 布式系统协调引板模式（boiler plate patterns）并且使用Spring Cloud发员快速实现些模式启服务应用程序 任何布式环境工作包括发员自笔记本电脑裸机数据受管平台Cloud Foundry
Version: Brixton.SR7
1 特征
Spring Cloud专注于经典用例扩展机制提供良箱即用
布式/版本配置
服务注册与发现
路由选择
服务调用
负载均衡
熔断机制
全局锁
领导选举集群状态
布式消息
2 原云应用程序
原云应用程序发种风格鼓励持续交付价值驱领域佳实践
Spring Cloud特性基于Spring Boot更由两库实现：Spring Cloud Context and Spring Cloud Commons
2.1 Spring Cloud Context: 应用文服务
Spring Boot关于使用Spring构建应用硬性规定：通用配置文件固定位置通用管理终端监控任务建立基础Spring Cloud增加些额外特性
2.1.1 引导应用程序文
Spring Cloud创建bootstrap文主应用程序父文应配置文件拥高优先级并且默认能本配置文件覆盖应文件名bootstrap.yml或bootstrap.properties
通设置spring.cloud.bootstrap.enabled=false禁止bootstrap进程
2.1.2 应用文层级结构
用SpringApplication或SpringApplicationBuilder创建应用程序文bootstrap文作父文添加进文继承父文属性
文配置信息覆盖父文配置信息
2.1.3 修改Bootstrap配置文件位置
spring.cloud.bootstrap.name（默认bootstrap）或者spring.cloud.bootstrap.location（默认空）
2.1.4 覆盖远程配置文件值
spring.cloud.config.allowOverride=true
spring.cloud.config.overrideNone=true
spring.cloud.config.overrideSystemProperties=false
2.1.5 定制Bootstrap配置
/META-INF/spring.factorieskeyorg.springframework.cloud.bootstrap.BootstrapConfiguration定义Bootstrap启组件
主应用程序启前始Bootstrap文创建spring.factories文件组件@Beans类型bean
2.1.6 定制Bootstrap属性源
关键点：spring.factories、PropertySourceLocator
2.1.7 环境改变
应用程序通EnvironmentChangedEvent监听应用程序并做响应
2.1.8 Refresh Scope
Springbean@RefreshScope做特殊处理用于刷新bean配置信息
注意
需要添加依赖org.springframework.boot.spring-boot-starter-actuator
目前我@Controller测试功
需要自发送POST请求/refresh
修改配置文件即
2.1.9 加密解密
Spring Cloud配置文件值进行加密
"Illegal key size"异需要安装JCE
2.1.10 服务点
除Spring Boot提供服务点Spring Cloud提供些服务点用于管理注意都POST请求
/env：更新Environment、重新绑定@ConfigurationProperties跟志级别
/refresh重新加载配置文件刷新标记@RefreshScopebean
/restart重启应用默认用
命周期：/pause、/resume
2.2 Spring Cloud Commons:通用抽象
服务发现、负载均衡、熔断机制种模式Spring Cloud客户端提供通用抽象层
2.2.1 RestTemplate作负载均衡客户端
通@Bean跟@LoadBalanced指定RestTemplate注意URI需要使用虚拟域名（服务名能用域名）
：
@Configuration
public class MyConfiguration {

@LoadBalanced
@Bean
RestTemplate restTemplate() {
return new RestTemplate();
}
}

public class MyClass {
@Autowired
private RestTemplate restTemplate;

public String doOtherStuff() {
String results = restTemplate.getForObject("", String.class);
return results;
}
}

2.2.2 RestTemplate象
注意@Primary注解使用
@Configuration
public class MyConfiguration {

@LoadBalanced
@Bean
RestTemplate loadBalanced() {
return new RestTemplate();
}

@Primary
@Bean
RestTemplate restTemplate() {
return new RestTemplate();
}
}

public class MyClass {
@Autowired
private RestTemplate restTemplate;

@Autowired
@LoadBalanced
private RestTemplate loadBalanced;

public String doOtherStuff() {
return loadBalanced.getForObject("", String.class);
}

public String doStuff() {
return restTemplate.getForObject("", String.class);
}
}

2.2.3 忽略网络接口
忽略确定名字服务发现注册支持则表达式配置
3 Spring Cloud Config
Spring Cloud Config提供服务端客户端布式系统扩展配置支持同环境配置（发、测试、产）使用Git做默认配置端支持配置环境打版本标签
3.1 快速始
通IDE运行或maven运行
默认加载property资源策略克隆git仓库(at spring.cloud.config.server.git.uri')
HTTP服务资源构：
/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

.config.name,(般说'application'规Spring Boot应用),profileactiveprofile(或者逗号隔属性列表),label选git标签(默认"master")
3.1.1 客户端示例
创建Spring Boot应用即添加依赖org.springframework.cloud:spring-cloud-starter-config
配置application.properties注意URL配置服务端址
spring.cloud.config.uri:

3.2 Spring Cloud Config 服务端
针系统外配置项(name-value或相同功能YAML内容),该服务器提供基于资源HTTP接口使用@EnableConfigServer注解,该服务器容易嵌入Spring Boot 系统使用该注解该应用系统配置服务器
@SpringBootApplication
@EnableConfigServer
public class ConfigApplicion {
public static void main(String[] args) throws Exception {
SpringApplication.run(ConfigApplicion.class, args);
}
}

3.2.1 资源库环境
{application} 应客户端"spring.application.name"属性
{profile} 应客户端 "spring.profiles.active"属性(逗号隔列表)
{label} 应服务端属性,属性能标示组配置文件版本
配置库基于文件服务器application.ymlfoo.yml创建Environment象高优先级配置优先转Environment象PropertySource
3.2.1.1 Git端
默认EnvironmentRepository用Git端进行实现Git端于管理升级物理环境便,审计配置变更便file:前缀本配置库读取数据
配置库实现通映射HTTP资源{label}参数作git label(提交id,支名称或tag)git支或tag名称包含斜杠 ("/"),HTTP URLlabel需要使用特殊字符串"(_)"替代(避免与其URL路径相互混淆)使用命令行客户端 curl请谨慎处理URL括号(例：shell请使用引号''转义)
Git URI占位符
Spring Cloud Config Server支持git库URL包含针{application} {profile}占位符(需要,{label}包含占位符, 要牢记任何情况label指gitlabel)所容易支持应用系统配置库策略或profile配置库策略
模式匹配资源库
spring:
cloud:
config:
server:
git:
uri:
repos:
simple:
special:
pattern: special*/dev*,*special*/dev*
uri:
local:
pattern: local*
uri: file:/home/configsvc/config-repo

{application}/{profile}能匹配任何表达式使用spring.cloud.config.server.git.uri应值例于 "simple" 配置库, 匹配模式simple/* (说,论profile匹配application名称simple应用系统)local库匹配所application名称local任何应用系统管profiles(实现覆盖没配置profile匹配规则/*缀自增加任何匹配表达式)
Git搜索路径占位符
spring.cloud.config.server.git.searchPaths
3.2.1.2 版本控制端文件系统使用
伴随着版本控制系统作端(git、svn)文件都check out或clone 本文件系统默认些文件放置config-repo-前缀系统临目录Linux譬应该/tmp/config-repo-目录些操作系统routinely clean out放临目录导致预知问题现避免问题通设置spring.cloud.config.server.git.basedir或spring.cloud.config.server.svn.basedir参数值非系统临目录
3.2.1.3 文件系统端
使用本加载配置文件
需要配置：spring.cloud.config.server.native.searchLocations跟spring.profiles.active=native
路径配置格式：classpath:/, classpath:/config,file:./, file:./config
3.2.1.4 共享配置给所应用
基于文件资源库
基于文件资源库(i.e. git, svn and native)文件名application*命名资源所客户端都共享( application.properties, application.yml, application-*.properties,etc.)
属性覆盖
spring.cloud.config.server.overrides添加Map类型name-value实现覆盖
例
spring:
cloud:
config:
server:
overrides:
foo: bar

使所配置客户端应用程序读取foo=bar自配置参数
3.2.2 健康指示器
通指示器能够检查已经配置EnvironmentRepository否运行
通设置spring.cloud.config.server.health.enabled=false参数禁用健康指示器
3.2.3 安全
自由选择任何觉合理式保护Config Server（物理网络安全OAuth2 令牌）同使用Spring SecuritySpring Boot 能使做更其用事情
使用默认Spring Boot HTTP Basic 安全需要Spring Security 增加classpath(org.springframework.boot.spring-boot-starter-security)默认用户名user应随机密码种情况实际使用并没意义般建议配置密码（通 security.user.password属性进行配置）并密码进行加密
3.2.4 加密与解密
远程属性包含加密内容({cipher}),些值通HTTP传递客户端前解密
使用略
3.2.5 密钥管理
配置服务使用称(共享)密钥或者非称密钥(RSA密钥)
使用略
3.2.6 创建测试密钥库
3.2.7 使用密钥循环密钥
3.2.8 加密属性服务
3.3 替换格式服务
配置文件加缀".yml"、".yaml"、".properties"
3.4 文本解释服务
/{name}/{profile}/{label}/{path}
3.5 嵌入配置服务器
般配置服务运行单独应用面要使用注解@EnableConfigServer即嵌入其应用
3.6 推送通知总线
添加依赖spring-cloud-config-monitor激Spring Cloud 总线/monitor端点即用
webhook激针应用程序能已经变化配置服务端发送RefreshRemoteApplicationEvent
3.7 客户端配置
3.7.1 配置第引导
通spring.cloud.config.uri属性配置Config Server址
3.7.2 发现第引导
用Netflix则用eureka.client.serviceUrl.defaultZone进行配置
3.7.3 配置客户端快速失败
些例面能希望没连接配置服务端直接启失败通spring.cloud.config.failFast=true进行配置
3.7.4 配置客户端重试
添加依赖spring-retry、spring-boot-starter-aop设置spring.cloud.config.failFast=true默认6重试初始补偿间隔1000ms续补偿1.1指数乘数通spring.cloud.config.retry.*配置进行修改
3.7.5 定位远程配置资源
路径：/{name}/{profile}/{label}
"name" = ${spring.application.name}
"profile" = ${spring.profiles.active} (actually Environment.getActiveProfiles())
"label" = "master"
label于滚前版本用
3.7.6 安全
通spring.cloud.config.password、spring.cloud.config.username进行配置

5、springboot接收请求重定向指定url

你好，解决方法如下： 可以通过实现接口来实现： public class Application extends SpringBootServletInitializer implements { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { return builder.sources(Application.class); } public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Override public void customize( container) { container.setPort(8081); }

6、springboot部署到服务器找不到controller

那应该是服务器端的抄Nginx没有配置，需要增加映射按一下流程筛查：
域名解析ip正确 - 访问 -> 服务器 - Nginx - 配置根据域名找到springboot项目，并确保Nginx和springboot项目已启动。

7、为什么选择Spring Boot作为微服务的入门级微框架

1. Spring Boot是什么，解决哪些问题

 1) Spring Boot使编码变简单

 2) Spring Boot使配置变简单

 3) Spring Boot使部署变简单

 4) Spring Boot使监控变简单

 5) Spring Boot的不足

2. Spring Boot在平台中的定位，相关技术如何融合

 1) SpringBoot与SEDA +MicroService + RESTful

 2) SpringBoot与Mock

3. 采用了SpringBoot之后，技术管理应该如何进行

首先，我们来看一下spring boot是什么，它帮助我们解决了哪些问题：

SpringBoot是伴随着Spring4.0诞生的；

从字面理解，Boot是引导的意思，因此SpringBoot帮助开发者快速搭建Spring框架；

SpringBoot帮助开发者快速启动一个Web容器；

SpringBoot继承了原有Spring框架的优秀基因；

SpringBoot简化了使用Spring的过程。

Spring由于其繁琐的配置，一度被人认为“配置地狱”，各种XML、Annotation配置，让人眼花缭乱，而且如果出错了也很难找出原因。

Spring Boot更多的是采用Java Config的方式，对Spring进行配置。

可以看到，采用了spring-boot-start-actuator之后，直接以REST的方式，获取进程的运行期性能参数。

当然这些metrics有些是有敏感数据的，spring-boot-start-actuator为此提供了一些Basic Authentication认证的方案，这些方案在实际应用过程中也是不足的。

Spring Boot作为一个微框架，离微服务的实现还是有距离的。

没有提供相应的服务发现和注册的配套功能，自身的acturator所提供的监控功能，也需要与现有的监控对接。没有配套的安全管控方案，对于REST的落地，还需要自行结合实际进行URI的规范化工作。

下面，我们研究一下Spring Boot在平台中的定位，相关技术如何融合。

上图比较复杂，整体是采用SEDA，也就是Stage-EDA。可以看到，整体是以处理顺序进行展示的，响应过程类似。在处理过程中，主要会有前置过滤，核心功能处理，后置过滤几大部分。

图中的过滤器都是可插拔式的，并且可以根据实际场景进行扩展开发。每个过滤器都是Stage，比如ClientInstance合法性检查、调用鉴权、解密、限流等等。

一个请求Stage与Stage的转换，实现上是切换不同的线程池，并以EDA的方式驱动。

对于业务逻辑的开发者而言，只需要关心CORE部分的业务逻辑实现，其他的非功能都由框架进行统一实现。

Mock不应当再是测试的专有名词了，当然对于测试这个角色而言，mockito这样的工具，依然可以为他们提升不少效率。

SpringBoot为创建REST服务提供了简便的途径，相比之下，采用阿里的bbo在做多团队、多进程联调时，mock的难度就陡增。

Mock是解耦并行开发的利器，在理性的情况下，软件从开发期Mock联调，到开发与开发的真实联调，只需要切换一个依赖的域名即可，比如：

mockURI:http://mock.service.net/v1/function?param1=value1

devURI:http://dev.service.net/v1/function?param1=value1

而上述的域名切换，只需要在开发期定义好一个配置项，在做环境切换的时候自动注入即可，省时、省心、省力。

如上图和docker的集成可以有AB两种方案：

? A方案的核心是，把docker作为操作系统环境的交付基线，也就是不同的fat jar 使用相同的操作系统版本、相同的JVM环境。但对于docker image来说都是一样的。

? B方案的核心是，不同的fat jar，独立的编译为docker image，在启动时直接启动带有特定版本的image。

A相比与B方案的特点是对于docker registry（也就是docker的镜像仓库）的依赖性较低，对于前期编译过程的要求也较低。

采用了Spring Boot之后，技术管理应该如何进行？

正因为Spring Boot是与Spring一脉相承的，所以对于广大的Java开发者而言，对于Spring的学习成本几乎为零。

在实践Spring Boot时学习重点，或者说思维方式改变的重点在于：

1）对于REST的理解，这一点尤为重要，需要从设计、开发多个角色达成共识，很多时候都是对于HTTP 1.1协议以及REST的精髓不理解，导致REST被“盲用”而产生一些不好的效果。

2）对于YAML的理解和对于JavaConfig的理解，这两点相对较为简单，本质上是简化了xml文件，并提供等价的配置表述能力。

1. 丰富的工具链为SpringBoot的推广带来了利好。

2. SpringBoot的工具链主要来自于两个方面：

1) 原有Spring积累的工具链；

2) SpringMVC或者其他REST框架使用HTTP协议，使得HTTP丰富的工具成为SpringBoot天然的资源。

SpringBoot自身对于前面提到的配置文件：“application.yml”提供了多个“Profile”，可以便于开发者描述不同环境的配置，这些配置例如数据库的连接地址、用户名和密码。

但是对于企业用户而言，把不同环境的配置，写到同一个配置文件中，是极其不安全的，是一个非常危险的动作。

有一个经常被提及的例子是，随着开源的进行，很多互联网公司，都由于把相关的代码提交到github之类的开源代码社区，并且没有对代码进行严格的配置审查，导致一些”password”被公开。有些不良用心的人，就利用搜索工具，专门去挖掘这些关键字，进而导致数据库被“拖库”。

所以对于企业用户，更多的应该是采用集中式的配置管理系统，将不同环境的配置严格区分地存放。

虽然SpringBoot的actuator自身提供了基于“用户名+口令”的最简单的认证方式，但它保护的是对框架自身运行期的性能指标敏感数据的最基本的保护。这种保护在实际应用过程中，“用户名+口令”的管理是缺乏的，“用户名+口令”的安全配置过程是缺失的。

SpringBoot也不提供对于我们自己开发的功能的任何防护功能。

一般来讲，一个安全的信道（信息传输的通道），需要通信双方在进行正式的信息传输之前对对方进行身份认证，服务提供方还需要在此基础之上，对请求方的请求进行权限的校验，以确保业务安全。这些内容也需要基于SpringBoot进行外围的安全扩展，例如采用前面提到的S-EDA进行进程级别的安全管控。这些还需要配套的安全服务提供支持。

一般来说，只要企业与互联网对接，那么随便一个面向消费者的“市场活动”，就有可能为企业带来井喷的流量。

传统企业内，更多的系统是管理信息类的支撑系统，这类系统在设计时的主要用户是企业内部员工以及有限的外部供应商。这类系统存在于企业内部的时间一直很长，功能耦合也很多，在功能解耦前，是非常不适合的，或者说绝对不可以直接为互联网的用户进行服务的。

SpringBoot自身并没有提供这样的流控措施，所以需要结合前面提到的S-EDA进行流量的控制，并结合下层的水平扩展能力（例如，Kubernets）进行流量负载合理的动态扩容。

另外，在长业务流程的设计上，也尽可能地采用异步的方式，比如接口调用返回的是一个“受理号”，而不是业务的处理结果，避免井喷业务到来时，同步调用所带来的阻塞导致系统迅速崩溃，这些也都是SpringBoot自身并不解决的问题。

下面我们总结一下：

8、springboot 绑定域名

spring boot把他看作服务容器.前端再加一个apache服务或者nginx服务器做内容分发,分发到不同的app 容器上,就类似于tomcat配置虚拟主机一样

9、如何在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
一键部署到远程服务器了。

10、新手,springBoot项目写完之后,别人怎么通过http的网址访问到我的网址,也就是如何上线,网址已经购买好了？

将项目打包发布到服务器就可以了啊