SpringCloud学习
SpringCloud学习
1 | 三层架构 + MVC |
1、常见的面试题
1.1、什么是微服务？
1.2、微服务之间是如何独立通讯的？
1.3、SpringCloud和Dubbo有哪些区别？
1.4、SpringBoot和SpringCloud，请你谈谈对他们的理解？
1.5、什么是服务熔断？什么是服务降级？
1.6、微服务的优缺点分别是什么？说下你在项目开发中遇到的坑
1.7、你所知道的微服务技术栈有哪些？请列举一二。。
1.8、Eureka和Zookeeper都可以提供服务的注册与发现的功能，请说说两个的区别？
2. 微服务概述
2.1、什么是微服务
什么是微服务？微服务（Microservice Architecture）是最近几年流行的一种架构思想，关于它的概念很难一言蔽之。
究竟什么是微服务呢？我们在此引用ThoughtWorks公司的首席科学家Martin Fowler于2014年提出的一段话：
原文：https://martinfowler.com/articles/microservices.html
汉化：https://www.cnblogs.com/liuning8023/p/4493156.html
- 就目前而言，对于微服务，业界并没有一个统一的，标准的定义
- 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它提倡将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值。服务之间采用轻量级的通信机制互相沟通，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言，工具对其进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储;
可能有的人觉得官方的话太过生涩，我们从技术维度来理解下:
- 微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术的角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。
2.2、微服务与微服务架构
微服务
强调的是服务的大小，他关注的是某一个点，是具体解决某一个问题/提供落地对应服务的一个服务应用，狭义的看，可以看做是IDEA中的一个个微服务工程，或者Module
1 | IDEA工具里面使用Maven开发的一个个独立的小Module，它具体是使用springboot开发的一个小模块，专业的事情交个专业的模块来做，一个模块就做着一件事情 |
微服务架构
一种新的架构形式，Martin Fowler于2014年提出
微服务架构是一种架构模式，它提倡将单一的应用程序划分成一组小的服务，服务之间相互协调、相互配合，为用户提供最终的价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据业务的上下文，选择合适的语言、工具对其进行构建。
2.2、微服务的优缺点
优点：
- 单一职责原则；
- 每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求；
- 开发简单，开发效率提高，一个服务可能就是专一的只干一件事；
- 微服务能够被小团队单独开发，这个小团队是2~5人的开发人员组成；
- 微服务是松耦合的，是有功能意义的服务，无论是开发阶段或者部署阶段都是独立的；
- 微服务能使用不同的语言开发；
- 易于和第三方集成，微服务允许容器且灵活的方式集成自动部署，通过持续集成工具，如Jenkins、Hudson、Bamboo；
- 微服务易于被一个开发人员理解、修改和维护，这样小团队能够更关注自己的工作成果。无需通过合作才能体现价值；
- 微服务允许你利用融合最新技术；
- 微服务只是业务逻辑的代码，不会和HTML、CSS或者其他界面混合；
- 每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库。
缺点：
- 开发人员要处理分布式系统的复杂性；
- 多服务运维难度，随着服务的增加，运维的压力也在增大；
- 系统部署依赖；
- 服务间通信成本；
- 数据一致性；
- 系统集成测试；
- 性能测试。。。
2.4、微服务的技术栈有哪些？
| 微服务条目 | 落地技术 |
|---|---|
| 服务开发 | SpringBoot、Spring、SpringMVC |
| 服务配置与管理 | Netflix公司的Archaius，阿里的Diamond等 |
| 服务的注册与发现 | Eureka、Consul、Zookeeper等 |
| 服务调用 | Rest、RPC、gRPC |
| 服务熔断器 | Hystrix、Envoy等 |
| 负载均衡 | Ribbon、Nginx等 |
| 服务接口调用（客户端调用服务的简化工具） | Feign等 |
| 消息队列 | Kafka、RabbitMQ、ActiveMQ等 |
| 服务配置中心管理 | SpringCloudConfig、Chef等 |
| 服务路由（API网关） | Zuul等 |
| 服务监控 | Zabbix、Nagiox、Metrics、Specatator等 |
| 全链接追踪 | Zipkin、Brave、Dapper等 |
| 服务部署 | Docker、OpenStack、Kubernetes等 |
| 数据流操作开发包 | SpringCloud Stream（封装与Redis、Rabbit、Kafka等发送接收消息） |
| 事件消息总线 | SpringCloud Bus |
2.5、为什么选择SpringCloud作为微服务架构
1、选型依据
- 整体解决方案和框架成熟度
- 社区热度
- 可维护性
- 学习曲线
2、当前各大IT公司用的微服务架构有哪些？
- 阿里：Dubbo+HFS
- 京东：JSF
- 新浪：Motan
- 当当网：DubboX
- ……
3、各位服务框架对比
| 功能点/服务架构 | Netflix/SpringCloud | Motan | gRPC | Thrift | Dubbo/DubboX |
|---|---|---|---|---|---|
| 功能定位 | 完整额微服务加框架 | RPC框架，但整合了ZK或Consul，实现集群环境的基本服务注册/发现 | RPC矿建 | RPC框架 | 服务框架 |
| 支持Rest | 是，Ribbon支持多种可拔插的序列化选择 | 否 | 否 | 否 | 否 |
| 支持RPC | 否 | 是（Hession2） | 是 | 是 | 是 |
| 支持多语言 | 是（Rest形式）？ | 否 | 是 | 是 | 否 |
| 负载均衡 | 是（服务端zuul+客户端Ribbon），zuul-服务，动态路由，云端负载均衡Eureka（针对中间层服务器） | 是（客户端） | 否 | 否 | 是（客户端） |
| 服务配置 | Netflix Archaius，SpringCloud Config Server集中配置 | 是（Zookeeper提供） | 否 | 否 | 否 |
| 服务调用链监控 | 是（zuul），zuul提供边缘服务，API网关 | 否 | 否 | 否 | 否 |
| 高可用/容错 | 是（服务端Hystrix+客户端Ribbon） | 是（客户端） | 否 | 否 | 是（客户端） |
| 典型应用案例 | Netflix | Sina | |||
| 社区活跃程度 | 高 | 一般 | 高 | 一般 | 2017年之后重新开始维护，之前中断了5年 |
| 学习难度 | 中等 | 低 | 高 | 高 | 低 |
| 文档丰富程度 | 高 | 一般 | 一般 | 高 | |
| 其他 | Spring Cloud Bus为我们的应用程序带来了更多管理端点 | 支持降级 | Netflix内部在开发集成gRPC | IDL定义 | 实践的公司比较多 |
3、SpringCloud入门概述
3.1、SpringCloud是什么
Spring 官网：https://spring.io/
SpringCloud,基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件。
SpringCloud利用SpringBoot的开发便利性，巧妙地简化了分布式系统基础设施的开发，SpringCloud为开发人员提供了快速构建分布式系统的一些工具，包括配置管理，服务发现，断路器，路由，微代理，事件总线，全局锁，决策竞选，分布式会话等等，他们都可以用SpringBoot的开发风格做到一键启动和部署。
SpringBoot并没有重复造轮子，它只是将目前各家公司开发的比较成熟，经得起实际考研的服务框架组合起来，通过SpringBoot风格进行再封装，屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂，易部署和易维护的分布式系统开发工具包
SpringCloud是分布式微服务架构下的一站式解决方案，是各个微服务架构落地技术的集合体，俗称微服务全家桶。
3.2、SpringCloud和SpringBoot关系
- SpringBoot专注于快速方便的开发单个个体微服务；
- SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等集成服务；
- SpringBoot可以离开SpringCloud单独使用，开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系；
- SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架。
3.3、Dubbo和SpringCloud技术选型
1、分布式+服务治理Dubbo
目前成熟的互联网架构：应用服务化拆分+消息中间件
2、Dubbo和SpringCloud对比
可以看一下社区活跃度
https://github.com/spring-cloud
结果：
| Dubbo | Spring | |
|---|---|---|
| 服务注册中心 | Zookeeper | Spring Cloud Netflix Eureka |
| 服务调用方式 | RPC | REST API |
| 服务监控 | Dubbo-monitor | Spring Boot Admin |
| 断路器 | 不完善 | Spring Cloud Netflix Hystrix |
| 服务网关 | 无 | Spring Cloud Netflix Zuul |
| 分布式配置 | 无 | Spring Cloud Config |
| 服务跟踪 | 无 | Spring Cloud Sleuth |
| 消息总线 | 无 | Spring Cloud Bus |
| 数据流 | 无 | Spring Cloud Stream |
| 批量任务 | 无 | Spring Cloud Task |
最大的区别：SpringCloud抛弃了Dubbo的RPC通道，采用的是基于HTTP的REST方式。
严格来说，这两种方式各有优劣。虽然从一定程度来说，后者牺牲了服务调用的性能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的强依赖，这在强调快速演化的微服务环境下，显得更加合适。
品牌机与组装机的区别
很明显，Spring Cloud的功能比DUBBO更加强大，涵盖面更广，而且作为Spring的拳头项目，它也能够与Spring Framework、Spring Boot、Spring Data、Spring Batch等其他Spring项目完美融合，这些对于微服务而言是至关重要的。使用Dubbo构建的微服务架构就像组装电脑，各环节我们的选择自由度很高，但是最终结果很有可能因为一条内存质量不行就点不亮了，总是让人不怎么放心，但是如果你是一名高手，那这些都不是问题；而SpringCloud就像品牌机，在Spring Source的整合下，做了大量的兼容性测试，保证了机器拥有更高的稳定性，但是如果要在使用非原装组件外的东西，就需要对其基础有足够的了解。
社区支持与更新力度
最为重要的是，DUBBO停止了5年左右的更新，虽然2017.7重启了。对于技术发展的新需求，需要由开发者自行拓展升级（比如当当网弄出了DubboX)，这对于很多想要采用微服务架构的中小软件组织，显然是不太合适的，中小公司没有这么强大的技术能力去修改Dubbo源码+周边的一整套解决方案，并不是每一个公司都有阿里的大牛+真实的线上生产环境测试过。
总结:
曾风靡国内的开源RPC服务框架Dubbo在重启维护后，令许多用户为之雀跃，但同时，也迎来了一些质疑的声音。互联网技术发展迅速，Dubbo是否还能跟上时代? Dubbo与Spring Cloud相比又有何优势和差异？是否会有相关举措保证Dubbo的后续更新频率？
人物：Dubbo重启维护开发的刘军，主要负责人之一
刘军，阿里巴巴中间件高级研发工程师，主导了Dubbo重启维护以后的几个发版计划，专注于高性能RPC框架和微服务相关领域。曾负责网易考拉RPC框架的研发及指导在内部使用，参与了服务治理平台、分布式跟踪系统、分布式一致性框架等从无到有的设计和开发过程。
解决的问题域不一样：Dubbo的定位是一款RPC框架，Spring Cloud的目标是微服务架构下的一站式解决方案
3.4、SpringCloud能干嘛
- Distributed/versioned configuration(分布式/版本控制配置)
- Service registration and discovery(服务注册与发现)
- Routing(路由)
- Service-to-service calls(服务到服务的调用)
- Load balancing(负载均衡配置)
- Circuit Breakers（断路器)
- Distributed messaging(分布式消息管理)
- ……
3.5、SpringCloud在哪里下
官网：https://spring.io/projects/spring-cloud
这玩意儿的版本号有点特别！
1 | Spring Cloud是一个由众多独立子项目组成的大型综合项目，每个子项目有不同的发行节奏，都维护着自己的发布版本号。Spring Cloud通过一个资源清单BOM(Bil1 of Materials）来管理每个版本的子项目清单。为避免与子项目的发布号混淆，所以没有采用版本号的方式，而是通过命名的方式。 |
参考书：
- https://springcloud.cc/spring-cloud-netflix.html
- 中文APl文档：https://springcloud.cc/spring-cloud-dalston.html
- SpringCloud中国社区：http://springcloud.cn/
- SpringCloud中文网：https://springcloud.cc
4、开始学习
4.1、总体介绍
我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者（Client）通过REST调用Provider提供者（Server）提供的服务。
回忆Spring、SpringMVC、Mybatis等已学习的知识；
Maven的分包分模块架构复习
1
2
3
4
5
6
7
8
9
10一个简单的Maven模块结构是这样的：
-- app-parent：一个父项目（app-parent）聚合很多子项目（app-util、app-dao、app-web...）
|-- pom.xml
|
|-- app-core
||--- pom.xml
|
|-- app-web
||--- pom.xml
.......一个父工程带着多个子Module子模块
MicroServiceCloud父工程（Project）下初次带着3个子模块（Modules）
- microservicecloud-api【封装的整体entity、接口、公共配置等】
- microservicecloud-provider-dept-8001【服务提供者】
- microservicecloud-consumer-dept-80【服务消费者】
4.2、SpringCloud版本选择
大版本说明
| Spring Boot | Spring Cloud | 关系 |
|---|---|---|
| 1.2.x | Angel版本（天使） | 兼容Spring Boot 1.2.x |
| 1.3.x | Brixtpn版本（布里克斯顿） | 兼容Spring Boot 1.3.x，也兼容兼容Spring Boot 1.4.x |
| 1.4.x | Camden版本（卡姆登） | 兼容Spring Boot 1.4.x，也兼容兼容Spring Boot 1.5.x |
| 1.5.x | Dalston版本（多尔斯顿） | 兼容Spring Boot 1.5.x，不兼容兼容Spring Boot 2.0.x |
| 1.5.x | Edgware版本（埃其威尔） | 兼容Spring Boot 1.5.x，不兼容兼容Spring Boot 2.0.x |
| 2.0.x | Finchley版本（芬奇利） | 兼容Spring Boot 2.0.x，不兼容兼容Spring Boot 1.5.x |
| 2.1.x | Greenwich版本（格林威治） |
实际开发版本关系
| spring-boot-starter-parent | spring-cloud-dependencies | ||
|---|---|---|---|
| 版本号 | 发布日期 | 版本号 | 发布日期 |
| 1.5.2.RELEASE | 2017年3月 | Dalston.RC1 | 2017年未知月 |
| 1.5.9.RELEASE | Nov，2017 | Edgware.RELEASE | Nov，2017 |
| 1.5.16.RELEASE | Sep，2017 | Edgware.SR5 | Oct，2017 |
| 1.5.20.RELEASE | Apr，2018 | Edgware.SR5 | Oct，2017 |
| 2.0.2RELEASE | May，2018 | Finchley.BUILD-SNAPSHOT | 2018年未知月 |
| 2.0.6.RELEASE | Oct，2018 | Finchley.SR2 | Oct，2018 |
| 2.1.4.RELEASE | Apr，2019 | Greenwich.SR1 | Mar，2019 |
使用最后的这两个
4.3、创建父工程
- 新建父工程项目microservicecloud，切记Packageing是pom模式
- 主要是定义POM文件，将后续各个子模块共用的jar包等统一提取出来，类似一个抽象父类
pom.xml
1 |
|
5、Eureka服务注册与发现
5.1、什么是Eureka
- Eureka：怎么读？
- Netflix在设计Eureka时，遵循的就是AP原则
- Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改调用的配置文件了，功能类似于Dubbo的注册中心，比如Zookeeper；
5.2、原理讲解
Eureka的基本架构
SpringCloud封装了Netflix公司开发的Eureka模块来实现服务注册和发现（对比Zookeeper）；
Eureka采用了C-S的架构设计，EurekaServer作为服务注册功能的服务器，他是服务注册中心；
而系统中的其他微服务。使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行，SpringCloud的一些其他模块（比如Zuul）就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑；
和Dubbo架构对比
![image-20200910142222004]()
![image-20200910142250595]()
Eureka包含两个组件：Eureka Server 和 Eureka Client；
Eureka Server提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到；
Eureka Client是一个java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳（默认周期为30秒）。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉（默认周期90秒）
三大角色
- Eureka Server：提供服务的注册与发现；
- Service Provider：将自身服务注册到Eureka中，从而使消费方能够找到；
- Service Consumer：服务消费方从Eureka中获取注册服务列表，从而找到消费服务
盘点目前工程状况
5.3、构建步骤
1、eureka-server
microservicecloud-eureka-7001模块建立
pom.xml配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<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>spring-cloud-master</artifactId>
<groupId>com.demo</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-cloud-eureka-7001</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>yml 文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16server:
port: 7001
# Eureka 配置
eureka:
instance:
# Eureka 服务器的示例名称
hostname: localhost
client:
# 表示是否向Eureka注册中心注册自己
register-with-eureka: false
# 如果为false 表示自己为注册中心
fetch-registry: false
# 配置Eureka监控页面地址
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/编写主启动类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20package com.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* @author: zxj
* @date: 2020-09-07 18:05:24
* @tags:
*/
// 服务端的启动类
public class EurekaServer_7001 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7001.class, args);
}
}启动，访问测试结果
![image-20200910144456082]()
2、Service Provider
将8001的服务入驻到7001的eureka中
修改8001服务的pom文件，添加eureka的支持！
1
2
3
4
5<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>yml修改
1
2
3
4
5# Eureka配置注册到哪里
eureka:
client:
service-url:
defaultZone: http://localhost:7001/eureka/8001的主启动类配置注解支持
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20package com.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* @author: zxj
* @date: 2020-09-07 15:59:26
* @tags:
*/
// 服务启动后自动注册到Eureka中
public class DeptProvider_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProvider_8001.class,args);
}
}启动，访问测试结果
![image-20200910152805205]()
3、服务的配置延伸
在注册服务状态中，自定义状态信息
![image-20200910145706338]()
修改yml文件
1
2
3
4
5
6
7
8
9
10# Eureka配置注册到哪里
eureka:
client:
service-url:
defaultZone: http://localhost:7001/eureka/
instance:
# 修改Eureka上默认的描述信息
instance-id: microservicecloud-provider-dept-8001
# 可以使用IP:端口形式设置服务ID spring.cloud.client.ip-address:获取ip地址
instance-id: ${spring.cloud.client.ip-address}:${server.port}刷新后查看结果
![image-20200910150058772]()
在访问注册的服务信息，得到如下信息
![image-20200910150428965]()
点击Info，出现Error页面
![image-20200910151526041]()
修改8001的pom文件，新增依赖
1
2
3
4<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>继续在8001的yml配置文件中添加如下信息
1
2
3
4
5
6# info 配置
info:
app:
name: jiang
company: uoso
produce: uoso重新访问刚才的info链接地址，得到如下信息：
![image-20200910152000012]()
4、Eureka的自我保护机制
之前出现的这个红色情况
我们修改一个服务名，故意制造错误！
这是Eureka的自我保护机制，好死不如赖活着
一句话总结：某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存！
- 默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生时，微服务与Eureka之间无法正常通信，以上行为可能变得非常危险了，因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过自我保护机制来解决这个问题，当EurekaServer节点在短时间内丢失过多客户端是（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册中的信息，不在删除服务注册表中的数据（也就是不会注销任何微服务）。当网络故障恢复后，该EurekaServer节点会自动退出自我保护模式。
- 在自我保护模式中，EurekaServer会保护服务注册表中额信息，不再注销任何服务实例。当它收到的心跳书重新恢复到阀值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话：好死不如赖活着
- 综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康微服务和不健康的微服务都会保留），也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的稳定和健壮
- 在SpringCloud中，可以使用
eureka.server.enable-self-preservation=false禁用自我保护模式【不推荐关闭自我保护机制】
5、8001服务发现Discovery
对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息。【对外暴露的服务】
修改microservicecloud-provider-dept-8001工程中的DeptController
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public Object getDiscovery() {
List<String> services = client.getServices();
System.out.println("discovery=>services:"+services);
List<ServiceInstance> instances = client.getInstances("SPRING-CLOUD-PROVIDER-DEPT");
for (ServiceInstance instance : instances) {
System.out.println(
instance.getHost()+"\t"+
instance.getPort()+"\t"+
instance.getUri()+"\t"+
instance.getServiceId()
);
}
return this.client;
}在8001启动类中开启Discovery，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22package com.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* @author: zxj
* @date: 2020-09-07 15:59:26
* @tags:
*/
// 服务启动后自动注册到Eureka中
// 服务的注册发现 Discovery
public class DeptProvider_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProvider_8001.class,args);
}
}
6、consumer访问服务
microservicecloud-consumer-dept-80
修改DeptConsumerController增加一个方法
1 |
|
5.4、集群配置
新建工程microservicecloud-eureka-7002、microservicecloud-eureka-7003
按照7001为模板粘贴POM
修改7002和7003的主启动类
修改映射配置
Windows域名映射
![image-20200910170415183]()
集群配置分析
![image-20200910170513346]()
修改3个EurekaServer的yml文件
7001：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18server:
port: 7001
# Eureka 配置
eureka:
instance:
# Eureka 服务器的示例名称
hostname: localhost
client:
# 表示是否向Eureka注册中心注册自己
register-with-eureka: false
# 如果为false 表示自己为注册中心
fetch-registry: false
# 配置Eureka监控页面地址
service-url:
# 单机连接
# defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/7002：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16server:
port: 7002
# Eureka 配置
eureka:
instance:
# Eureka 服务器的示例名称
hostname: localhost
client:
# 表示是否向Eureka注册中心注册自己
register-with-eureka: false
# 如果为false 表示自己为注册中心
fetch-registry: false
# 配置Eureka监控页面地址
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/7003：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16server:
port: 7003
# Eureka 配置
eureka:
instance:
# Eureka 服务器的示例名称
hostname: localhost
client:
# 表示是否向Eureka注册中心注册自己
register-with-eureka: false
# 如果为false 表示自己为注册中心
fetch-registry: false
# 配置Eureka监控页面地址
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/将8001微服务发布到3台eureka集群配置中，修改yml配置
1
2
3
4
5
6
7
8
9
10
11# Eureka配置注册到哪里
eureka:
client:
service-url:
# 单机连接
# defaultZone: http://localhost:7001/eureka/
# 连接集群
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
# 修改Eureka上默认的描述信息
instance-id: spring-cloud-provider-dept-8001启动集群测试
![image-20200910173531083]()
5.5、对比Zookeeper
回顾CAP原则
RDBMS（Mysql、Oracle、SqlServer）====> ACID
NoSQL（Redis、MongoDB）====> CAP
ACID是什么？
- A（Atomicity）原子性
- C（Consistency）一致性
- I（Isolation）隔离性
- D（Durability）持久性
CAP是什么？
- C（Consistency）强一致性
- A（Availability）可用性
- P（Partition tolerance）分区容错性
CAP的三进二：CA、AP、CP
CAP理论的核心：
- 一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性这三个需求；
- 根据CAP原理，将NoSQL数据库分成了满足CA原则、满足CP原则和满足AP原则三大类：
- CA：单点集群，满足一致性、可用性的系统，通常可扩展性较差；
- CP：满足一致性、分区容错性的系统，通常性能不是特别高；
- AP：满足可用性、分区容错性的系统，通常可能对一致性要求低一些
作为服务注册中心，Eureka比Zookeeper好在哪里？
著名的CAP理论指出，一个好的分布式系统不可能同时满足C（一致性）、A（可用性）、P（容错性）。
由于分区容错性P在分布式系统中是必须要保证的，因此我们只能在A和C之间权衡。
- Zookeeper保证的是CP；
- Eureka保证的是AP；
Zookeeper保证的是CP
当向注册中兴查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种清空，当master节点因为网络故障与其他节点失去联系时，剩余的节点会重新进行leader选举。问题在于，选举leader的时间太长，30~120s，而且选举期间整个zk集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境中，因为网路问题使得zk集群失去master节点是较大概率会发生的事件，虽然服务最终能够恢复，但是漫长的选举时间导致的注册长期不可用是不能容忍的。
Eureka保证的是AP
Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供服务注册和查询服务。而Eureka的客户端在向某个Eureka注册时，如果发现连接失败，则会自动切换至其他节点，只要有一条Eureka还在，就能保证注册服务额可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有一只自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳。那么Eureka就会认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：
- Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务；
- Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上（保证当前节点依然可用）；
- 当网络稳定时，当前实例新的注册信息会被同步到其他节点中。
因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会向Zookeeper那样使得整个注册服务瘫痪
6、Ribbon
Ribbon是什么？
- Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具
- 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置如：连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalance（简称LB：负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等等）去连接这些机器。我们也很容器使用Ribbon实现自定义的负载均衡算法！
Ribbon能干嘛？
- LB，即负载均衡（Load Balance），在微服务或者分布式集群中经常用的一中应用；
- 负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）；
- 常见的负载均衡软件有Nginx、Lvs等等；
- Dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
- 负载均衡简单分类：
- 集中式LB
- 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx：反向代理服务器！，由该设施负责把访问请求通过某种策略转发至服务的提供方！
- 进程式LB
- 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器
- Ribbon就是属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取服务提供方的地址
- 集中式LB
Ribbon的服务请求重试：
在服务消费者的pom文件中添加如下依赖：
1
2
3
4<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>application.xml文件添加如下配置
1
2
3
4
5
6
7
8
9
10# 修改ribbon的负载均衡策略 服务名 - ribbon - NFLoadBalancerRuleClassName:策略
spring-cloud-provider-dept:
ribbon:
# 自定义负载策略
# NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
ConnectTimeout: 250 # Ribbon的连接超时时间
ReadTimeout: 1000 # Ribbon的数据读取超时时间
OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
MaxAutoRetriesNextServer: 1 # 切换实例的重试次数
MaxAutoRetries: 1 # 对当前实例的重试次数
7、Feign负载均衡
7.1、简介
Feign是声明式的web server客户端，它让微服务之间的调用变得更简单了，类似Controller调用Service，Spring Cloud集成了Ribbon和Eureka，可在使用Feign时提供负载均衡的http客户端。
只需要创建一个接口，然后添加注解即可！
Feign，主要是社区，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法
- 微服务名称【Ribbon】
- 接口和注解【Feign】
Feign能干什么？
- Feign旨在使编写Java Http客户端变得更容易
- 前面在使用Ribbon+RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式配置它（类似于以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可。）即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的并发量。
Feign集成了Ribbon
- 利用Ribbon维护了MicroServiceCLoud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而且简单的实现了服务调用。
7.2、Feign使用步骤
7.3、Feign 请求压缩
Spring Cloud Feign 支持对请求和响应进行GZIP压缩，以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能：
1 | feign: |
8、Hystrix
分布式系统面临的问题
复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免的失败！
服务雪崩
多个微服务之间调用的时候，假设微服务A调用微服务B和服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”、如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统的崩溃，所谓的“雪崩效应”。
对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒中内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障，这些都是需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消某个应用程序或系统。
我们需要 ·弃车保帅·
什么是Hystrix
Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，需要依赖不可避免的会调用失败，比如超时，异常等，Hystrix能够保证在一个依赖出现问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。
“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个服务预期的，可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方法无法处理的异常，这样就保证了服务调用方的线程不会被长时间，不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩
能干嘛：
服务降级
服务熔断
配置服务自动熔断时间，编写Hystrix配置
1
2
3
4
5
6
7hystrix:
command:
default:
execution:
isolasion:
thread:
timeoutInMilliseconds: 3000 #默认的连接超时时间1秒，若1秒没有返回数据，自动触发熔断机制实现统一的熔断处理方法
在需要做熔断处理的类上面实现一个注解配置即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20/**
* @DefaultProperties：指定此接口中公共的熔断设置
* 如果在@DefaultProperties制定了公共的降级方法，
* 在@HystrixCommand就不需要单独指定了
*/
public class DeptController {
/**
* 指定统一的降级方法
* 参数：没有参数
* @return
*/
public Dept defaultFallBack(){
Dept dept = new Dept();
dept.setDname("触发统一的降级方法");
return dept;
}
}
服务限流
接近实时的监控
……
官网资料
https://github.com/Netflix/Hystrix/wiki
服务熔断
是什么
熔断机制是对应雪崩效应的一种微服务链路保护机制。
当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。当检测到该节点调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内20次调用失败就会启动熔断机制，熔断机制的注解是@HystrixCommand。
总结：
服务熔断：服务端，某个服务超时或者异常，引起熔断，相当于保险丝
服务降级：客户端，从整体网站请求负载考虑，当某个服务熔断或者关闭后，服务将不再调用，此时在客户端，我们可以准备一个FallbackFactory，返回一个默认的值（缺省值），整体的服务水平下降了，但是，好歹能用，比直接挂掉强
配置 Hystrix 监控页面（Hystrix DashBoard）
1、创建一个项目 即 spring-cloud-consumer-hystrix-dashboard
2、pom.xml 中添加如下依赖包
1 | <!--Hystrix的依赖--> |
3、创建application.yml文件，并设置服务端口为9001
4、配置服务启动类为
1 |
|
5、在之前配置了服务端熔断器项目spring-cloud-provider-dept-hystrix-8001的主启动类添加如下配置
1 | /** |
pom文件中必须添加如下依赖
1 | <!--服务监控依赖--> |
依次分别启动 spring-cloud-eureka-7001、spring-cloud-consumer-hystrix-dashboard 、spring-cloud-provider-dept-hystrix-8001项目
6、访问http://127.0.0.1:9001/hystrix 得到如下页面
配置 https://hostname:port/turbine/turbine.stream输入框为 http://127.0.0.1:8001/actuator/hystrix.stream，
Delay 项输入 2000 ，Title随便输入吧
点击 Monitor Stream
如下：
得到如下页面：
页面说明：
7色
![image-20200914164244304]()
一圈
实心圆：共有两种含义，它通过颜色的变化代表了实例的健康程度
它的健康程度从 绿色<黄色<橙色<红色 递减
该实心圆除了颜色的变化之外，它的大小也会根据实例的请求流量发生变化，流量越大，该实心圆越大，所以通过该实心圆的展示，就可以在大量的实例中快速发现故障实例和高压力实例。
![image-20200914164657448]()
一线
曲线：用来记录2分钟内流量的相对变化，可以通过它来观察到流量的上升和下降趋势
默认的情况下：
![image-20200914165349589]()
有请求的情况下：
![image-20200914165510100]()
整图说明
![image-20200914172722755]()
Hystrix 的替换方案 Sentinel
Sentinel 和 Hystrix、Resilience4j对比
| Sentinel | Hystrix | Resilience4j | |
|---|---|---|---|
| 隔离策略 | 信号量隔离（并发线程数限流） | 线程池隔离/信号量隔离 | 信号量隔离 |
| 熔断降级策略 | 基于响应时间、异常比率、异常数 | 基于异常比率 | 基于响应时间、异常比率 |
| 实时统计实现 | 滑动窗口（LeapArray） | 滑动窗口（RxJava） | Ring Bit Buffer |
| 动态规则配置 | 支持多种数据源 | 支持多种数据源 | 有限支持 |
| 扩展性 | 多个扩展点 | 插件的形式 | 接口的形式 |
| 基于注解的支持 | 支持 | 支持 | 支持 |
| 限流 | 基于QPS，支持基于调用关系的限流 | 有限的支持 | Rate Limiter |
| 流量整形 | 支持预热模式、匀速器模式、预热排队模式 | 不支持 | 简单的Rate Limiter |
| 系统自适应保护 | 支持 | 不支持 | 不支持 |
| 控制台 | 提供开箱即用的控制台，可配置规则、查看秒级监控、机器发现等 | 简单的监控查看 | 不提供控制台，可对接其他监控系统 |
9、Spring Cloud 路由网关
9.1、Zuul
9.1.1、介绍
什么是Zuul？
Zuul包含了对请求的路由和过滤两个最主要的功能：
其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验、服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。
注意：Zuul服务最终还是会注册进Eureka
提供：代理 + 路由 + 过滤 三大功能！
Zuul能干嘛？
- 路由
- 过滤
官网文档：https://github.com/Netflix/zuul
9.1.2、Zuul 网关环境搭建
1、创建工程，并导入依赖
1
2
3
4
5
6
7
8
9
10
11
12
13<!--zuul的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>
<!--Eureka依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>2、编写配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27server:
port: 9527
spring:
application:
name: springcloud-zuul
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:7001/eureka/
instance:
instance-id: zuul9527.com
prefer-ip-address: true
# 配置路由规则
zuul:
routes:
# 路由ID，直接指定到某服务上spring-cloud-provider-dept 服务名称
mydept.serviceId: spring-cloud-provider-dept
# 映射的路径
mydept.path: /mydept/**
# 不能再使用这个路径访问了
#ignored-services: spring-cloud-provider-dept
# 所有的服务名都被隐藏了
ignored-services: "*"
# 配置所有请求的前缀
prefix: /demo3、创建启动类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23package com.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
/**
* @author: zxj
* @date: 2020-09-14 17:53:24
* @tags:
*/
/**
* 配置开启网关代理
*/
public class ZuulApplication_9527 {
public static void main(String[] args) {
SpringApplication.run(ZuulApplication_9527.class,args);
}
}
9.1.3、路由
路由：根据请求的URL，将请求分配到对应的微服务中进行处理
路由的简化配置：
1 | # 配置路由规则 |
9.1.4、过滤器
Zuul的过滤器有4中情况，分别如下：
- PRE：这种过滤器在请求被路由之前调用，我们可以利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等；
- ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或者Netflix Ribbon请求微服务
- POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等
- ERROR：在其他阶段发生错误时执行该过滤器
配置过滤器代码如下：
1 | package com.demo.filter; |
9.1.5 zuul网关存在的问题
在实际使用中我们会发现直接使用Zuul会存在诸多问题，包括：
- 性能问题
- Zuul1.x版本本质上就是一个同步Servlet，采用多线程阻塞模型进行请求转发，简单讲，每来一个请求，Servlet容器要为该请求分配一个线程专门负责处理这个请求，直到响应返回客户端这个线程才会被释放返回容器线程池。如果后台服务调用比较耗时，那么这个线程就会被阻塞，阻塞期间线程资源被占用，不能用于干其他事情。我们知道Servlet容器线程池的大小是有限制的，当前端请求量大，而后台慢服务较多时，很容易耗尽容器线程池内的线程，造成容器无法接受新的请求
- 不支持任何长连接，如WebSocket
Zuul网关的替换方案
Zuul2.x版本
Spring Cloud Gateway
9.2、Spring Cloud Gateway
Zuul1.x是一个基于阻塞的IO的API Gateway以及Servlet；直到2018年5月，Zuul2.x（基于Netty，也是非阻塞的，支持长连接）才发布，但是Spring Cloud 暂时还没有整合计划。Spring Cloud Gateway 比Zuul1.x系列的性能和功能整体要好。
9.2.1Gateway简介
Spring Cloud Gateway 是Spring官方基于Spring5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，旨在为微服务架构提供一种简单而有效的统一的API路由管理方式，统一访问接口。Spring Cloud Gateway 作为SpringCloud生态系中的网关，目标是替代Netflix Zuul，其不仅提供统一的路由方式，并且基于Filter链的方式提供了网关基本的功能，例如：安全、监控/埋点，和限流等，它是基于Netty的响应式开发模式。
| 组件 | RPS（request per second） |
|---|---|
| Spring Cloud Gateway | Requests/sec:32213.38 |
| Zuul1.x | Requests/sec:20800.13 |
上表为Spring Cloud Gateway和Zuul的性能对比，从结果可知，Spring Cloud Gateway的RPS是Zuul的1.6倍
9.2.2、路由配置
9.2.2.1、环境搭建
创建工程导入依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16<dependencies>
<!--
Spring Cloud Gateway 的内部是通过Netty+webFlux实现
webflux实现与SpringMVC存在冲突
-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
<version>2.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>配置启动类
1
2
3
4
5
6
7
8
9
10
11
12
13package com.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}编写配置文件
1
2
3
4
5
6
7
8
9
10
11
12spring:
application:
name: springcloud-gateway
# 配置Spring Cloud Gateway 的路由
cloud:
gateway:
routes:
# 配置路由：路由ID，路由到微服务的uri，断言（判断条件）
- id: mydept # 保持唯一
uri: http://127.0.0.1:8001/ # 目标微服务请求地址
predicates:
- Path=/dept/** # 路由条件，Path：路由匹配条件
9.2.2.2、路由规则
断言：路由条件
- datatime：请求时间校验条件谓语；
- After：请求时间满足在配置时间之后；
- Before：请求时间满足在配置时间之前；
- Between：请求时间满足在配置时间之间；
- Cookie：请求Cookie校验条件谓语，请求指定Cookie正则匹配指定值；
- Header：请求Header校验条件；
- HeaderRoute：请求指定Header正则匹配指定值；
- CloudFoundRouteServiceRoute：请求Headers是否包含指定的名称；
- Host：请求Host校验条件，请求Host匹配指定值；
- Method：请求Method校验条件，请求Method匹配配置的method；
- Path：请求Path校验条件，请求路径正则匹配指定值；
- QueryParam：请求查询参数校验条件，请求查询参数正则匹配指定值；
- RemoteAddr：请求远程地址校验条件，请求远程地址正则匹配指定值。
示例：
1 | #路由断言之后匹配 |
9.2.2.3、动态路由（面向服务的路由）
添加Eureka客户端依赖
1 | <!--Eureka--> |
添加Eureka服务注册中心配置，重写routes的uri指向Eureka中的服务名称
1 | # Eureka配置 |
9.2.2.4、路由路径重写
1 | spring: |
9.2.2.5、开启微服务名称转发
1 | spring: |
9.2.3、过滤器
9.2.3.1、基于filter的限流
准备工作
redis 环境
在项目工程中引入Redis依赖，基于reactive的Redis依赖
1
2
3
4
5<!--Redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>
修改网关中的application.yml配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25spring:
application:
name: springcloud-gateway
# 配置Spring Cloud Gateway 的路由
cloud:
gateway:
routes:
# 配置路由：路由ID，路由到微服务的uri，断言（判断条件）
- id: mydept # 保持唯一
#uri: http://127.0.0.1:8001/ # 目标微服务请求地址
uri: lb://spring-cloud-provider-dept # lb://根据微服务名称从注册中心中拉取服务请求路径
predicates:
#- Path=/dept/** # 路由条件，Path：路由匹配条件
- Path=/uoso/** # 将当前请求转发到 http://127.0.0.1:8001/dept/list
# 配置路由过滤器 http://127.0.0.1:8080/uoso/dept/list ---> http://127.0.0.1:8001/dept/list
filters:
- name: RequestRateLimiter
args:
# 使用SpEL从容器中获取对象
key-resolver: '#{@pathKeyResolver}'
# 令牌桶每秒填充平均速率
redis-rate-limiter.replenishRate: 1
# 令牌桶的上限
redis-rate-limiter.burstCapacity: 3
- RewritePath=/uoso/(?<segment>.*), /$\{segment} # 路径重写的过滤器，在yml中$写为$\配置redis中key的解析器KeySesolver
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55package com.demo.config;
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
/**
* @author: zxj
* @date: 2020-09-27 15:50:22
* @tags:
*/
public class KeyResolverConfiguration {
/**
* 编写基于请求路径的限流规则
* //abc
* //基于请求ip 127.0.0.1
* //基于参数
*/
//@Bean
public KeyResolver pathKeyResolver(){
return new KeyResolver(){
/**
* ServerWebExchange 上下文参数
* @param exchange
* @return
*/
public Mono<String> resolve(ServerWebExchange exchange) {
return Mono.just(exchange.getRequest().getPath().toString());
}
};
}
/**
* 基于参数的过滤
* @return
*/
public KeyResolver userKeyResolver(){
return new KeyResolver() {
public Mono<String> resolve(ServerWebExchange exchange) {
return Mono.just(
exchange.getRequest().getQueryParams().getFirst("userId")
// 基于IP的配置
//exchange.getRequest().getHeaders().getFirst("X-Forwarded-For")
);
}
};
}
}
9.2.4、统一鉴权
9.2.5、网关限流
9.2.6、网关的高可用
10、Spring Cloud Config 分布式配置
1、概述
分布式系统面临的–配置文件的问题
微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务，由于每个服务都需要必要的配置信息才能运行，所以一套集中式的，动态的配置管理设施是必不可少的。SpringCloud提供了ConfigServer来解决这个问题，我们每一个微服务自己带着一个application.yml，那上百个的配置文件要修改起来，岂不是要发疯！
2、什么设计Spring Cloud Config 分布式配置中心
Spring Cloud Config 为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同的微服务应用的所有环节提供了一个中心化的外部配置。
Spring Cloud Config 分为服务端和客户端两部分：
服务端也称为 分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口。
客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理。并且可以通过git客户端工具来方便的管理和访问配置内容。
Spring Cloud Config 分布式配置中心能干嘛
- 集中管理配置文件
- 不同环境，不同配置，动态化的配置更新，分环境部署，比如 /dev /test /prod /beta /release
- 运行期间动态调整配置，不再需要在每个服务器部署的机器上编写配置文件，服务会向配置中心统一拉取配置自己的信息。
- 当配置发生变动时，服务不需要重启，即可感知到配置的变化，并应用新的配置
- 将配置信息以REST接口的形式暴露
Spring Cloud Config 分布式配置中心与GitHub整合
由于Spring Cloud Config 默认使用Git来存储配置文件（也有其他方式，比如支持SVN和本地文件），但是最推荐的还是Git，而且使用时的 http/https 访问的形式；
3、在远程配置文件修改后微服务客户端如何及时刷新配置文件
3.1、pom.xml中添加服务监控依赖
1 | <!--监控信息依赖--> |
3.2、在需要刷新配置信息的地方开启刷新注解
1 | // 示例 |
3.3、application.yml添加刷新配置
1 | # 开启动态刷新的请求路径端点 |
3.4、通过以下链接发送post请求
http://127.0.0.1:8001/actuator/refresh
得到如下信息：
1 | [ |
3.5、微服务的配置文件已被刷新了
4、实现Config 服务的高可用
#### 4.1、在Spring Cloud Config 服务中添加Eureka依赖
1 | <!--eureka--> |
4.2、在服务的 application.yml中添加Eureka注册配置
1 | spring: |
4.3、在需要访问Spring Cloud Config 服务的 bootstrap.yml中 修改配置为
1 | spring: |
以上就是Spring Cloud Config的高可用配置
总结
以上就是 Spring Netflix下面的5大金刚，分别是：
Eureka
实现服务的注册与发现
Ribbon、Feign
实现服务的负载均衡
Hystrix
实现服务熔断处理，包含对服务的降级，限流等
Zuul
实现服务的网关配置，
Spring Cloud Config
远程管理分布式服务的配置文件
其他Spring Cloud 组件整理
1、 Spring Cloud Stream
介绍：
在开发中使用消息队列中间件（如：RabbitMQ、ActiveMQ、Kafka）的时候，如果一个项目的前期使用的是RabbitMQ，在项目的后期切换使用Kafka，这样可能会导致前面的代码会进行相关的重构，添加了代码的编写压力，Spring Cloud Stream就是解决这方便的问题的，