/**
* 8秒钟内，请求次数达到2个，并且失败率在50%以上，就跳闸
* 跳闸后活动窗口设置为3s
*/
@HystrixCommand(
commandProperties = {
//统计窗口时间的设置
@HystrixProperty(name =
"metrics.rollingStats.timeInMilliseconds",value = "8000"),
//统计窗口内的最小请求数
@HystrixProperty(name =
"circuitBreaker.requestVolumeThreshold",value = "2"),
//统计窗口内错误请求阈值的设置 50%
@HystrixProperty(name =
"circuitBreaker.errorThresholdPercentage",value = "50"),
//自我修复的活动窗口时间
@HystrixProperty(name =
"circuitBreaker.sleepWindowInMilliseconds",value = "3000")
}
)

# 配置熔断策略：
hystrix:
command:
default:
circuitBreaker:
# 强制打开熔断器，如果该属性设置为true，强制断路器进入打开状态，将会拒绝所有的请求。
默认false关闭的
forceOpen: false
# 触发熔断错误比例阈值，默认值50%
errorThresholdPercentage: 50
# 熔断后休眠时长，默认值5秒
sleepWindowInMilliseconds: 3000
# 熔断触发最小请求次数，默认值是20
requestVolumeThreshold: 2
execution:
isolation:
thread:
# 熔断超时设置，默认为1秒
timeoutInMilliseconds: 2000

<?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>
<groupId>com.lagou</groupId>
<artifactId>lagou-cloud-gateway</artifactId>
<version>1.0-SNAPSHOT</version>
<!--spring boot 父启动器依赖-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.6.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-commons</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--GateWay 网关-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--引入webflux-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!--日志依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</dependency>
<!--测试依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--lombok工具-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.4</version>
<scope>provided</scope>
</dependency>
<!--引入Jaxb，开始-->
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.2.11</version>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.2.11</version>
</dependency>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>2.2.10-b140310.1920</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>
<!--引入Jaxb，结束-->
<!-- Actuator可以帮助你监控和管理Spring Boot应用-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<!--链路追踪-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<!--spring cloud依赖版本管理-->
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Greenwich.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<!--编译插件-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>11</source>
<target>11</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
<!--打包插件-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

server:
port: 9300
eureka:
client:
serviceUrl: # eureka server的路径
defaultZone:
http://LagouCloudEurekaServerA:9200/eureka,http://LagouCloudEurekaServerB:9201/e
ureka
instance:
prefer-ip-address: true
instance-id: ${spring.cloud.client.ipaddress}:${spring.application.name}:${server.port}:@project.version@
spring:
application:
name: lagou-cloud-gateway
#网关的配置
cloud:
gateway:
routes: #配置路由
- id: service-page-router
uri: http://127.0.0.1:9100
predicates: #当断言成功后，交给某一个微服务处理时使用的是转发
- Path=/page/**
- id: service-product-router
uri: http://127.0.0.1:9000
predicates:
- Path=/product/**
filters:
# http://127.0.0.1:9300/product/service/port --> /service/port -->
商品微服务
- StripPrefix=1 #去掉uri中的第一部分，所以就要求我们通过网关访问的时候，把uri
的第一部分设置为product，从uri的第二部分开始才是真正的uri

 

 

 启动类

package com.lagou.gateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class,args);
}
}

测试

http://127.0.0.1:9501/page/getData/1

http://127.0.0.1:9501/product/product/query/1

5.5 GateWay 路由规则详解

Spring Cloud GateWay 帮我们内置了很多 Predicates 功能，实现了各种路由匹配规则（通过

Header 、请求参数等作为条件）匹配到对应的路由。

 时间点后匹配

spring:
cloud:
gateway:
routes:
- id: after_route
uri: https://example.org
predicates:
- After=2017-01-20T17:42:47.789-07:00[America/Denver]

时间点前匹配

spring:
cloud:
gateway:
routes:
- id: before_route
uri: https://example.org
predicates:
- Before=2017-01-20T17:42:47.789-07:00[America/Denver]

时间区间匹配

spring:
cloud:
gateway:
routes:
- id: between_route
uri: https://example.org
predicates:
- Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-
21T17:42:47.789-07:00[America/Denver]

指定 Cookie 正则匹配指定值

spring:
cloud:
gateway:
routes:
- id: cookie_route
uri: https://example.org
predicates:
- Cookie=chocolate, ch.p

指定 Header 正则匹配指定值

spring:
cloud:
gateway:
routes:
- id: header_route
uri: https://example.org
predicates:
- Header=X-Request-Id, \d+

请求 Host 匹配指定值

spring:
cloud:
gateway:
routes:
- id: host_route
uri: https://example.org
predicates:
- Host=**.somehost.org,**.anotherhost.org

请求 Method 匹配指定请求方式

spring:
cloud:
gateway:
routes:
- id: method_route
uri: https://example.org
predicates:
- Method=GET,POST

请求路径正则匹配

spring:
cloud:
gateway:
routes:
- id: path_route
uri: https://example.org
predicates:
- Path=/red/{segment},/blue/{segment}

请求包含某参数

spring:
cloud:
gateway:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=green

请求包含某参数并且参数值匹配正则表达式

spring:
cloud:
gateway:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=red, gree.

远程地址匹配

spring:
cloud:
gateway:
routes:
- id: remoteaddr_route
uri: https://example.org
predicates:
- RemoteAddr=192.168.1.1/24

5.6 GateWay 动态路由详解

GateWay 支持自动从注册中心中获取服务列表并访问，即所谓的动态路由

实现步骤如下

1 ） pom.xml 中添加注册中心客户端依赖（因为要获取注册中心服务列表， eureka 客户端已经引入）

2 ）动态路由配置

注意：动态路由设置时， uri 以 lb: // 开头（ lb 代表从注册中心获取服务），后面是需要转发到的服务名 称

5.7 GateWay 过滤器

57.1 GateWay 过滤器简介

从过滤器生命周期（影响时机点）的角度来说，主要有两个 pre 和 post ：

生命周 期时机 点	作用
pre	这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选 择请求的微服务、记录调试信息等。
post	这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的 HTTP Header 、收集统计信息和指标、将响应从微服务发送给客户端等。

从过滤器类型的角度， Spring Cloud GateWay 的过滤器分为 GateWayFilter 和 GlobalFilter 两种

过滤器类型	影响范围
GateWayFilter	应用到单个路由路由上
GlobalFilter	应用到所有的路由上

如 Gateway Filter 可以去掉 url 中的占位后转发路由，比如

predicates:
- Path=/product/**
filters:
- StripPrefix=1 # 可以去掉product之后转发

注意： GlobalFilter 全局过滤器是程序员使用比较多的过滤器，我们主要讲解这种类型

5.7.2 自定义全局过滤器实现 IP 访问限制（黑白名单）

请求过来时，判断发送请求的客户端的 ip ，如果在黑名单中，拒绝访问

自定义 GateWay 全局过滤器时，我们实现 Global Filter 接口即可，通过全局过滤器可以实现黑白名

单、限流等功能。

package com.lagou.gateway;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.ArrayList;
import java.util.List;
/**
* 定义全局过滤器，会对所有路由生效
*/
@Slf4j
@Component // 让容器扫描到，等同于注册了
public class BlackListFilter implements GlobalFilter, Ordered {
// 模拟黑名单（实际可以去数据库或者redis中查询）
private static List<String> blackList = new ArrayList<>();
static {
blackList.add("0:0:0:0:0:0:0:1"); // 模拟本机地址
blackList.add("127.0.0.1");
}
/**
* 过滤器核心方法
* @param exchange 封装了request和response对象的上下文
* @param chain 网关过滤器链（包含全局过滤器和单路由过滤器）
* @return
*/
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain
chain) {
System.out.println("....BlackListFilter....");
// 思路：获取客户端ip，判断是否在黑名单中，在的话就拒绝访问，不在的话就放行
// 从上下文中取出request和response对象
ServerHttpRequest request = exchange.getRequest();
ServerHttpResponse response = exchange.getResponse();
// 从request对象中获取客户端ip
String clientIp = request.getRemoteAddress().getHostString();
// 拿着clientIp去黑名单中查询，存在的话就决绝访问
if(blackList.contains(clientIp)) {
// 决绝访问，返回
response.setStatusCode(HttpStatus.UNAUTHORIZED); // 状态码
log.info("=====>IP:" + clientIp + " 在黑名单中，将被拒绝访问！");
String data = "Request be denied!";
DataBuffer wrap = response.bufferFactory().wrap(data.getBytes());
return response.writeWith(Mono.just(wrap));
}
// 合法请求，放行，执行后续的过滤器
return chain.filter(exchange);
}
/**
* 返回值表示当前过滤器的顺序(优先级)，数值越小，优先级越高
* @return
*/
@Override
public int getOrder() {
return 0;
}
}

5.8 GateWay 高可用

网关作为非常核心的一个部件，如果挂掉，那么所有请求都可能无法路由处理，因此我们需要做

GateWay 的高可用。

GateWay 的高可用很简单： 可以启动多个 GateWay 实例来实现高可用，在 GateWay 的上游使用

Nginx 等负载均衡设备进行负载转发以达到高可用的目的。

启动多个 GateWay 实例（假如说两个，一个端口 9002 ，一个端口 9003 ），剩下的就是使用 Nginx 等完成负载代理即可。示例如下：

#配置多个GateWay实例
upstream gateway {
server 127.0.0.1:9002;
server 127.0.0.1:9003;
}
location / {
proxy_pass http://gateway;
}

第 6 节 Spring Cloud Config 分布式配置中心

6.1 分布式配置中心应用场景

往往，我们使用配置文件管理一些配置信息，比如 application.yml

单体应用架构， 配置信息的管理、维护并不会显得特别麻烦，手动操作就可以，因为就一个工程；

微服务架构， 因为我们的分布式集群环境中可能有很多个微服务，我们不可能一个一个去修改配置

然后重启生效，在一定场景下我们还需要在运行期间动态调整配置信息，比如：根据各个微服务的负载情况，动态调整数据源连接池大小，我们希望配置内容发生变化的时候，微服务可以自动更新。

场景总结如下：

1 ）集中配置管理，一个微服务架构中可能有成百上千个微服务，所以集中配置管理是很重要的

（一次修改、到处生效）

2 ）不同环境不同配置，比如数据源配置在不同环境（开发 dev, 测试 test, 生产 prod ）中是不同的

3 ）运行期间可动态调整。例如，可根据各个微服务的负载情况，动态调整数据源连接池大小等配

置修改后可自动更新

4 ）如配置内容发生变化，微服务可以自动更新配置

那么，我们就需要对配置文件进行 集中式管理 ，这也是分布式配置中心的作用。

6.2 Spring Cloud Config

6.2.1 Config 简介

Spring Cloud Con fifi g 是一个分布式配置管理方案，包含了 Server 端和 Client 端两个部分。

 

Server 端：提供配置文件的存储、以接口的形式将配置文件的内容提供出去，通过使用

@EnableCon fifi gServer 注解在 Spring boot 应用中非常简单的嵌入

Client 端：通过接口获取配置数据并初始化自己的应用

6.2.2 Config 分布式配置应用

说明： Con fifi g Server 是集中式的配置服务，用于集中管理应用程序各个环境下的配置。 默认使用 Git 存储配置文件内容，也可以 SVN 。

比如，我们要对 “ 静态化微服务或者商品微服务 ” 的 application.yml 进行管理（区分开发环境

（ dev ）、测试环境 (test) 、生产环境 (prod) ）

1 ）登录 GitHub ，创建项目 lagou-config

2 ）上传 yml 配置文件，命名规则如下：

{application}-{pro fifi le}.yml 或者 {application}-{pro fifi le}.properties

其中， application 为应用名称， pro fifi le 指的是环境（用于区分开发环境，测试环境、生产环境

等）

示例：lagou-service-page-dev.yml 、 lagou-service-page-test.yml 、 lagou-service-page

prod.yml

3 ） 构建 Config Server 统一配置中心

新建 SpringBoot 工程，引入依赖坐标 （需要注册自己到 Eureka ）

<?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">
<parent>
<artifactId>lagou-parent</artifactId>
<groupId>com.lagou</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>lagou-cloud-config</artifactId>
<dependencies>
<!--eureka client 客户端依赖引入-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--config配置中心服务端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
</dependencies>
</project>

配置启动类，使用注解 @EnableConfigServer 开启配置中心服务器功能

package com.lagou.config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.config.server.EnableConfigServer;
import java.io.ObjectInputFilter;
@SpringBootApplication
@EnableConfigServer // 开启配置服务器功能
@EnableDiscoveryClient
public class ConfigApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigApplication.class, args);
}
}

application.yml 配置

server:
port: 9400
#注册到Eureka服务中心
eureka:
client:
service-url:
defaultZone:
http://LagouCloudEurekaServerA:9200/eureka,http://LagouCloudEurekaServerB:9201/e
ureka
instance:
prefer-ip-address: true
instance-id: ${spring.cloud.client.ipaddress}:${spring.application.name}:${server.port}:@project.version@
spring:
application:
name: lagou-service-config
cloud:
config:
server:
git:
uri: https://github.com/jetwu-do/lagou-config.git #配置git服务地址
username: jetwu-do #配置git用户名
password: wu7787879 #配置git密码
search-paths:
- lagou-config
# 读取分支
label: master

测试

http://127.0.0.1:9600/master/application-dev.yml

master ：分支名称

application-dev.yml ：文件名称

4 ） 构建 Client 客户端（在已有页面静态化微服务基础上）

案例实现：在 lagou-service-page 微服务中动态获取 config server 的配置信息

已有工程中添加依赖坐标

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-client</artifactId>
</dependency>

application.yml 修改为 bootstrap.yml 配置文件

bootstrap.yml 是系统级别的，优先级比 application.yml 高，应用启动时会检查这个配置文件，

在这个配置文件中指定配置中心的服务地址，会自动拉取所有应用配置并且启用。

（主要是把与统一配置中心连接的配置信息放到 bootstrap.yml ）

注意：需要统一读取的配置信息，从配置中心获取

bootstrap.yml （部分）

server:
port: 9100 # 后期该微服务多实例，端口从9100递增（10个以内）
Spring:
application:
name: lagou-service-page
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/lagou?
useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
username: root
password: wu7787879
cloud:
config:
#config客户端配置,和ConfigServer通信，并告知ConfigServer希望获取的配置信息在哪个文
件中
name: application
profile: dev #后缀名称
label: master #分支名称
uri: http://localhost:9400 #ConfigServer配置中心地址

ConfigController

package com.lagou.page.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/config")
public class ConfigClientController {
@Value("${mysql.user}")
private String mysqlUser;
@Value("${person.name}")
private String personName;
@RequestMapping("/remote")
public String findRemoteConfig() {
return mysqlUser + " " + personName;
}
}

启动日志：

 

测试：

http://127.0.0.1:9100/config/remote

6.3 Config 配置手动刷新

不用重启微服务，只需要手动的做一些其他的操作（访问一个地址 /refresh ）刷新，之后再访问即

可此时，客户端取到了配置中心的值，但当我们修改GitHub 上面的值时，服务端（ Con fifi g Server ）能实时获取最新的值，但客户端（Con fifi g Client ）读的是缓存，无法实时获取最新值。 Spring Cloud 已 经为我们解决了这个问题，那就是客户端使用post 去触发 refresh ，获取最新数据。

1 ） Client 客户端添加依赖 springboot-starter-actuator （已添加）

2 ） Client 客户端 bootstrap.yml 中添加配置（暴露通信端点）

management:
    endpoints:
        web:
            exposure:
            include: refresh
#也可以暴露所有的端口
management:
    endpoints:
        web:
            exposure:
                include: "*"

3 ） Client 客户端使用到配置信息的类上添加 @RefreshScope

package com.lagou.page.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/config")
@RefreshScope //手动刷新
public class ConfigClientController {
@Value("${mysql.user}")
private String mysqlUser;
@Value("${person.name}")
private String personName;
@RequestMapping("/remote")
public String findRemoteConfig() {
return mysqlUser + " " + personName;
}
}

4 ）手动向 Client 客户端发起 POST 请求， http://localhost:9100/actuator/refresh ，刷新配置信息

 

注意：手动刷新方式避免了服务重启

思考：可否使用广播机制，一次通知，处处生效，方便大范围配置自动刷新？

6.4 Config 配置自动更新

实现一次通知，处处生效

在微服务架构中，我们可以结合消息总线（Bus ）实现分布式配置的自动更新（ Spring Cloud

Config + Spring Cloud Bus ）

6.4.1 消息总线 Bus

所谓消息总线 Bus ，即我们经常会使用 MQ 消息代理构建一个共用的 Topic ，通过这个 Topic 连接各个

微服务实例， MQ 广播的消息会被所有在注册中心的微服务实例监听和消费。 换言之就是通过一个主题 连接各个微服务，打通脉络 。

Spring Cloud Bus （基于 MQ 的，支持 RabbitMq/Kafka ） 是 Spring Cloud 中的消息总线方案，

Spring Cloud Config + Spring Cloud Bus 结合可以实现配置信息的自动更新。

 

6.4.2 Spring Cloud Config + Spring Cloud Bus 实现自动刷新

MQ 消息代理，我们还选择使用 RabbitMQ ， ConfigServer 和 ConfigClient 都添加都消息总线的支持

以及与 RabbitMq 的连接信息

1 ） Config Server 服务端和客户端添加消息总线支持

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

2 ） Config Server 和客户端添加配置

spring:
rabbitmq:
host: 192.169.200.128
port: 5672
username: guest
password: guest

3 ） Config Server 微服务暴露端口

management:
endpoints:
web:
exposure:
include: bus-refresh
#建议暴露所有的端口
management:
endpoints:
web:
exposure:
include: "*"

4 ）重启各个服务，更改配置之后，向配置中心服务端发送 post 请求，各个客户端配置即可自动刷新

http://127.0.0.1:9400/actuator/bus-refresh

 

 

5 ） Config Client 测试

http://localhost:9100/config/remote

在广播模式下实现了一次请求，处处更新，如果我只想定向更新呢？

在发起刷新请求的时候 http://localhost:9006/actuator/bus-refresh/lagou-service-page:9100

即为最后面跟上要定向刷新的实例的 服务名 : 端口号 即可

第五部分 第二代 Spring Cloud 核心组件（ SCA ）

SpringCloud 是若干个框架的集合，包括 spring-cloud-config 、 spring-cloud-bus 等近 20 个子项

目，提供了服务治理、服务网关、智能路由、负载均衡、断路器、监控跟踪、分布式消息队列、配置管理等领域的解决方案。Spring Cloud 通过 Spring Boot 风格的封装，屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、容易部署的分布式系统开发工具包。一般来说，Spring Cloud 包含以下组件，主要以 Netflix 开源为主。

同 Spring Cloud 一样， Spring Cloud Alibaba 也是一套微服务解决方案，包含开发分布式应用微服

务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Greenwich.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--SCA -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.1.0.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

cloud:
    nacos:
        discovery:
            server-addr: 127.0.0.1:8848 #nacos server 地址