# SpringCloud学习笔记
**Repository Path**: XianYuZhonErMeng/spring-cloud
## Basic Information
- **Project Name**: SpringCloud学习笔记
- **Description**: 根据B站黑马教程学习的相关笔记及资料、源码
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 1
- **Created**: 2022-08-28
- **Last Updated**: 2023-10-29
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# SpringCloud学习笔记
## 一、认识微服务
### 1、服务架构演变
#### 1.1 单体架构
**单体架构：**将业务的所有功能集中在一个项目中开发，打成一个包部署。
**优点：**架构简单、部署成本低
**缺点：**耦合度高
**单体架构特点**: 简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统。
#### 1.2 分布式架构
**分布式架构**：根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务。
**优点：**降低服务耦合、有利于服务升级拓展
**分布式架构特点：**松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝。
#### 1.3 微服务
**微服务**： 微服务是一种经过良好架构设计的**分布式**架构方案，
**优点**：拆分粒度更小、服务更独立、耦合度更低
**缺点：**架构非常复杂，运维、监控、部署难度提高
**微服务架构特征：**
* 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
* 面向服务：微服务对外暴露业务接口
* 自治：团队独立、技术独立、数据独立、部署独立
* 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题
#### 1.4 微服务结构
微服务这种方案需要技术框架来落地，全球的互联网公司都在积极尝试自己的微服务落地技术。在国内最知名的就是SpringCloud和阿里巴巴的Dubbo。
**微服务技术对比**
#### 1.4 企业需求
在企业中，如果使用SpringCloud的技术，大部分都会用以下四种微服务架构方式
1、使用SpringCloud技术栈、服务接口采用Restful风格、服务调用采用Feign方式
2、使用SpringCloudAlibaba技术栈、服务接口采用Restful风格、服务调用采用Feign方式
3、使用SpringCloudAlibaba技术栈、服务接口采用Dubbo协议标准、服务调用采用Dubbo方式
### 2、SpringCLoud
SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。
SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验：
**注册与发现：**Eureka、Nacos、Consul
**统一配置管理：**SpringCloudConfig、Nacos
**服务远程调用：**OpenFeign、Dubbo
**统一网关路由：**SpringCloudGateway、Zuul
**服务链路监控：**Zipkin、Sleuth
**控流、降级、保护：**Hystix、Sentinel
**SpringCloud与SpringBoot的版本兼容关系如下：**
##
## 二、服务拆分及远程调用
### 1、服务拆分
微服务需要根据业务模块拆分，做到单一职责,不要重复开发相同业务
微服务可以将业务暴露为接口，供其它微服务使用
不同微服务都应该有自己独立的数据库
**服务拆分注意事项**
* 单一职责：不同微服务，不要重复开发相同业务
* 数据独立：不要访问其它微服务的数据库
* 面向服务：将自己的业务暴露为接口，供其它微服务调用
### 2、微服务远程调用
**1、下载demo地址：**https://gitee.com/XianYuZhonErMeng/spring-cloud-learning-notes
cloud-demo：父工程，管理依赖
- order-service：订单微服务，负责订单相关业务
- user-service：用户微服务，负责用户相关业务
要求：
- 订单微服务和用户微服务都必须有**各自的数据库**，相互独立
- 订单服务和用户服务**都对外暴露 Restful 的接口**
- 订单服务如果需要查询用户信息，**只能调用用户服务的 Restful 接口**，不能查询用户数据库
**2、根据订单id查询订单功能**
1、在OrderApplication启动类中注册RestTemplate
~~~ java
@MapperScan("cn.xydream.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
/**
* 创建RestTemplate
* @return
*/
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
~~~
2、服务远程调用RestTemplate
~~~ java
@RestController
@RequestMapping("order")
public class OrderController {
@Autowired
private OrderService orderService;
@Autowired
private RestTemplate restTemplate;
@GetMapping("{orderId}")
public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
// 根据id查询订单并返回
Order order = orderService.queryOrderById(orderId);
// 利用RestTemplate发起http请求，查询用户
// url路径
String url = "http://localhost:8081//user/" + order.getUserId();
User user = restTemplate.getForObject(url,User.class);
order.setUser(user);
return order;
}
}
~~~
3、微服务项目下，打开 idea 中的 Service，可以很方便的启动。
4、启动完成后，访问 http://localhost:8080/order/101
正如上面的服务拆分要求中所提到：基于RestTemplate发起的http请求实现远程调用，**只能调用用户服务的 Restful 接口**，不能查询用户数据库、http请求做远程调用是与语言无关的调用，只要知道对方的ip、端口、接口路径、请求参数即可。
### 3、提供者与消费者
服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）
**思考：**如果服务A调用服务B，服务B调用服务C，那么服务B是什么角色？
**解：**A是B的消费者，B则是A的提供者，那么同理B就是C的消费者，C则是B的提供者。
**服务调用关系**
* 服务提供者：暴露接口给其它微服务调用
* 服务消费者：调用其它微服务提供的接口
* 提供者与消费者角色其实是相对的
* 一个服务可以同时是服务提供者和服务消费者
## 三、Eureka注册中心
### 1、Eureka的作用
在Eureka架构中，微服务角色有两类：
1、EurekaServer：服务端，注册中心
* 记录服务信息
* 心跳监控
2、EurekaClient：客户端
* Provider：服务提供者，例如案例中的 user-service
* 注册自己的信息到EurekaServer
* 每隔30秒向EurekaServer发送心跳
* uconsumer：服务消费者，例如案例中的 order-service
* 根据服务名称从EurekaServer拉取服务列表
* 基于服务列表做负载均衡，选中一个微服务后发起远程调用
**消费者该如何获取服务提供者具体信息？**
* 服务提供者启动时向eureka注册自己的信息
* eureka保存这些信息
* 消费者根据服务名称向eureka拉取提供者信息
**如果有多个服务提供者，消费者该如何选择？**
* 服务消费者利用负载均衡算法，从服务列表中挑选一个
**消费者如何感知服务提供者健康状态？**
* 服务提供者会每隔30秒向EurekaServer发送心跳请求，报告健康状态
* eureka会更新记录服务列表信息，心跳不正常会被剔除
* 消费者就可以拉取到最新的信息
### 2、Eureka注册中心
1.搭建EurekaServer
* 引入eureka-server依赖
* 添加@EnableEurekaServer注解
* 在application.yml中配置eureka地址
2.服务注册
* 引入eureka-client依赖
* 在application.yml中配置eureka地址
3.服务发现
* 引入eureka-client依赖
* 在application.yml中配置eureka地址
* 给RestTemplate添加@LoadBalanced注解
* 用服务提供者的服务名称远程调用
#### 2.1 搭建EurekaServer
1、创建项目，引入spring-cloud-starter-netflix-eureka-server的依赖
~~~ xml
org.springframework.cloud
spring-cloud-starter-netflix-eureka-server
~~~
2、编写启动类，添加@EnableEurekaServer注解
~~~ java
@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class);
}
}
~~~
3、添加application.yml文件，编写下面的配置
~~~ yaml
server:
port: 10086 # 服务端口
spring:
application:
name: eurekaserver # eureka服务名称
eureka:
client:
service-url: # eureka的地址信息
defaultZone: http://127.0.0.1:10086/eureka
~~~
#### 2.2注册order-service
order-service虽然是消费者，但与user-service一样都是eureka的client端，同样可以实现服务注册
1、在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖
~~~ xml
org.springframework.cloud
spring-cloud-starter-netflix-eureka-client
~~~
2、在application.yml文件，编写下面的配置
~~~ yaml
spring:
application:
name: orderservice # user服务名称
eureka:
client:
service-url: # eureka的地址信息
defaultZone: http://127.0.0.1:10086/eureka
~~~
#### 2.3 注册user-service
1、在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖
~~~xml
org.springframework.cloud
spring-cloud-starter-netflix-eureka-client
~~~
2、在application.yml文件，编写下面的配置
~~~ yaml
spring:
application:
name: userservice # user服务名称
eureka:
client:
service-url: # eureka的地址信息
defaultZone: http://127.0.0.1:10086/eureka
~~~
3、3个项目启动后，访问 http://localhost:10086/
另外，我们可以将user-service多次启动， 模拟多实例部署，但为了避免端口冲突，需要修改端口设置：
#### 2.3 服务拉取
服务拉取是基于服务名称获取服务列表，然后在对服务列表做负载均衡
1、在order-service项目的启动类OrderApplication中的RestTemplate添加**负载均衡**注解：
~~~ java
@MapperScan("cn.xydream.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
/**
* 创建RestTemplate
* @LoadBalanced 添加负责均衡
* @return
*/
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
~~~
2、修改OrderService的代码，修改访问的url路径，用服务名代替ip、端口。
~~~ java
@GetMapping("{orderId}")
public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
// 根据id查询订单并返回
Order order = orderService.queryOrderById(orderId);
// 利用RestTemplate发起http请求，查询用户
// url路径
// String url = "http://localhost:8081//user/" + order.getUserId();
// 使用eureka服务拉取
String url = "http://userservice/user/" + order.getUserId();
User user = restTemplate.getForObject(url,User.class);
order.setUser(user);
return order;
}
~~~
## 四、Ribbon负载均衡
#### 1、负载均衡原理
我们添加了 `@LoadBalanced` 注解，即可实现负载均衡功能，这是什么原理呢？
**SpringCloud 底层提供了一个名为 Ribbon 的组件，来实现负载均衡功能。**
**源码追踪**
为什么我们只输入了 service 名称就可以访问了呢？为什么不需要获取ip和端口，这显然有人帮我们根据 service 名称，获取到了服务实例的ip和端口。它就是`LoadBalancerInterceptor`，这个类会在对 RestTemplate 的请求进行拦截，然后从 Eureka 根据服务 id 获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务 id。
我们进行源码跟踪：
在`LoadBalancerInterceptor`这个类中继承了`ClientHttpRequestInterceptor`拦截器
这里的 `intercept()` 方法，拦截了用户的 HttpRequest 请求，然后做了几件事：
- `request.getURI()`：获取请求uri，即 http://user-service/user/8
- `originalUri.getHost()`：获取uri路径的主机名，其实就是服务id `user-service`
- `this.loadBalancer.execute()`：处理服务id，和用户请求
这里的 `this.loadBalancer` 是 `LoadBalancerClient` 类型
继续跟入 `execute()` 方法：
- `getLoadBalancer(serviceId)`：根据服务id获取 `ILoadBalancer`，而 `ILoadBalancer` 会拿着服务 id 去 eureka 中获取服务列表。
- `getServer(loadBalancer)`：利用内置的负载均衡算法，从服务列表中选择一个。在图中**可以看到获取了8082端口的服务**
可以看到获取服务时，通过一个 `getServer()` 方法来做负载均衡
继续跟入：
继续跟踪源码 `chooseServer()` 方法，发现这么一段代码：
我们看看这个 `rule` 是谁：
这里的 rule 默认值是一个 `RoundRobinRule` ，看类的介绍：
负载均衡默认使用了轮训算法，当然我们也可以自定义。
**流程总结**
SpringCloud Ribbon 底层采用了一个拦截器，拦截了 RestTemplate 发出的请求，对地址做了修改。
基本流程如下：
- 拦截我们的 `RestTemplate` 请求 http://userservice/user/1
- `RibbonLoadBalancerClient` 会从请求url中获取服务名称，也就是 user-service
- `DynamicServerListLoadBalancer` 根据 user-service 到 eureka 拉取服务列表
- eureka 返回列表，localhost:8081、localhost:8082
- `IRule` 利用内置负载均衡规则，从列表中选择一个，例如 localhost:8081
- `RibbonLoadBalancerClient` 修改请求地址，用 localhost:8081 替代 userservice，得到 http://localhost:8081/user/1，发起真实请求
#### 2、负载均衡策略
负载均衡的规则都定义在 IRule 接口中，而 IRule 有很多不同的实现类：
不同规则的含义如下：
| **内置负载均衡规则类** | **规则描述** |
| :------------------------ | :----------------------------------------------------------- |
| RoundRobinRule | 简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。 |
| AvailabilityFilteringRule | 对以下两种服务器进行忽略：（1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule 规则的客户端也会将其忽略。并发连接数的上限，可以由客户端设置。 |
| WeightedResponseTimeRule | 为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。 |
| **ZoneAvoidanceRule** | 以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。 |
| BestAvailableRule | 忽略那些短路的服务器，并选择并发数较低的服务器。 |
| RandomRule | 随机选择一个可用的服务器。 |
| RetryRule | 重试机制的选择逻辑 |
默认的实现就是 `ZoneAvoidanceRule`，**是一种轮询方案**。
#### 3、自定义策略
通过定义 IRule 实现可以修改负载均衡规则，有两种方式：
1 代码方式在 order-service 中的 OrderApplication 类中，定义一个新的 IRule【该方案是全局的】：
~~~ java
@MapperScan("cn.xydream.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
/**
* 创建RestTemplate
* @return
*/
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
/**
* 键负载均衡设置为随机
* @return
*/
@Bean
public IRule randomRule() {
return new RandomRule();
}
}
~~~
2、配置文件方式：在 order-service 的 application.yml 文件中，添加新的配置也可以修改规则【该方案是指定某个微服务】：
~~~ yaml
userservice: # 给需要调用的微服务配置负载均衡规则，orderservice服务去调用userservice服务
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则
~~~
**注意**：一般用默认的负载均衡规则，不做修改。
#### 4、饥饿加载
Ribbon 默认是采用懒加载，即第一次访问时才会去创建 LoadBalanceClient，拉取集群地址，所以请求时间会很长。
而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：
~~~ yaml
ribbon:
eager-load:
enabled: true
clients: userservice # 项目启动时直接去拉取userservice的集群，多个用","隔开
~~~
## 五、Nacos注册中心
### 1、认识Nacos
Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件。相比Eureka功能更加丰富，在国内受欢迎程度较高。
GitHub主页：https://github.com/alibaba/nacos
GitHub的Release下载页：https://github.com/alibaba/nacos/releases
安装Nacos：http://www.xydream.cn/articles/71
### 2、服务注册到Nacos
1、在父工程的xml文件添加管理依赖【如果有Eureka相关的依赖全部注释掉】
~~~ xml
com.alibaba.cloud
spring-cloud-alibaba-dependencies
2.2.5.RELEASE
pom
import
~~~
2、给子工程添加nacos的客户端依赖
~~~ xml
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
~~~
3、修改子工程的application.yml文件【如果有Eureka相关的配置全部注释掉】
~~~ yaml
spring:
application:
name: orderservice
cloud:
nacos:
server-addr: 127.0.0.1:8848
discovery:
cluster-name: HZ # 集群名字
~~~
4、启动并测试
### 3、Nacos服务分级存储模型
Nacos服务分级存储模型
* 一级是服务，例如userservice
* 二级是集群，例如杭州或上海
* 三级是实例，例如杭州机房的某台部署了userservice的服务器
设置实例的集群属性
* 修改application.yml文件，添加spring.cloud.nacos.discovery.cluster-name属性即可
#### 3.1 Nacos服务分级存储模型图
#### 3.2 服务跨集群调用问题
服务调用尽可能选择本地集群的服务，跨集群调用延迟较高，本地集群不可访问时，再去访问其它集群
#### 3.3 服务集群属性
1、修改application.yml，添加如下内容：
~~~ yaml
spring:
cloud:
nacos:
server-addr: 127.0.0.1:8848 # nacos 服务端地址
discovery:
cluster-name: HZ # 配置集群名称，也就是机房位置，例如：HZ，杭州
~~~
2、在Nacos控制台可以看到集群变化：
### 4、集群负载均衡策略
**NacosRule负载均衡策略**：
* 优先选择同集群服务实例列表
* 本地集群找不到提供者，才去其它集群寻找，并且会报警告
* 确定了可用实例列表后，再采用随机负载均衡挑选实例
**实际部署中会出现这样的场景**：
* 服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求
Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高
#### 4.1 NacosRule负载均衡策略
1、配置多个集群属性后，Nacos后台显示：
2、修改集群中**服务消费者**的application.yml，设置集群为HZ：
~~~ yaml
spring:
application:
name: orderservice # 服务名称
cloud:
nacos:
server-addr: 127.0.0.1:8848
discovery:
cluster-name: HZ # 集群名字
~~~
3、然后在**服务消费者**中设置负载均衡的IRule为NacosRule，这个规则优先会寻找与自己同集群的服务
~~~ yaml
userservice: # 提供者的服务名称
ribbon:
NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule #负载均衡规则
~~~
#### 4.2 根据权重负载均衡
1、在Nacos控制台可以设置实例的权重值，首先选中实例后面的编辑按钮
2、将权重设置为0.1，测试可以发现8081被访问到的频率大大降低
### 5、环境隔离
Nacos中服务存储和数据存储的最外层都是一个名为namespace的东西，用来做最外层隔离，每个namespace都有唯一id，服务设置namespace时要写id而不是名称，不同namespace下的服务互相不可见。
1、在Nacos控制台可以创建namespace，用来隔离不同环境
2、然后填写一个新的命名空间信息
3、保存后会在控制台看到这个命名空间的id
4、修改**服务消费者**的application.yml，添加namespace
~~~ yaml
spring:
application:
name: orderservice
cloud:
nacos:
server-addr: 127.0.0.1:8848
discovery:
cluster-name: HZ # 集群名字
namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # nacos环境隔离Id
~~~
5、重启服务后，再来查看控制台
6、此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错
### 6、Nacos注册中心原理
#### 6.1 nacos注册中心细节分析
#### 6.2 临时实例和非临时实例
临时实例宕机时，会从nacos的服务列表中剔除，而非临时实例则不会。
服务注册到Nacos时，可以选择注册为临时或非临时实例，通过下面的配置来设置
~~~ yaml
spring:
application:
name: orderservice
cloud:
nacos:
server-addr: 127.0.0.1:8848
discovery:
cluster-name: HZ # 集群名字
ephemeral: false # 设置为非临时实例
~~~
#### 6.3 Nacos与eureka的区别
**Nacos与eureka的共同点**：
* 都支持服务注册和服务拉取
* 都支持服务提供者心跳方式做健康检测
**Nacos与Eureka的区别**：
*
* Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
* 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
* Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
* Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式
## 六、Nacos配置中心
### 1、创建配置
在Nacos控制面板中添加配置文件
然后在弹出的表单中，填写配置信息：
**注意**：项目的核心配置，需要热更新的配置才有放到 nacos 管理的必要。基本不会变更的一些配置(例如数据库连接)还是保存在微服务本地比较好。
### 2、统一配置管理
#### 2.1统一配置介绍
首先我们需要了解 Nacos 读取配置文件的环节是在哪一步，在没加入 Nacos 配置之前，获取配置是这样：
加入 Nacos 配置，它的读取是在 application.yml 之前的：
这时候如果把 nacos 地址放在 application.yml 中，显然是不合适的，**Nacos 就无法根据地址去获取配置了。**
因此，nacos 地址必须放在优先级最高的 bootstrap.yml 文件。
#### 2.2 拉取配置
首先，在 user-service 服务中，引入 nacos-config 的客户端依赖：
**1、引入 nacos-config 依赖**
在服务提供者【user-service】中引入 nacos-config 依赖
~~~ xml
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-config
~~~
2、 **添加 bootstrap.yml**
然后，在 u服务提供者【user-service】中添加一个 bootstrap.yml 文件，内容如下：
~~~ yaml
spring:
application:
name: userservice # 服务名称
profiles:
active: dev #开发环境，这里是dev
cloud:
nacos:
server-addr: localhost:8848 # Nacos地址
config:
file-extension: yaml # 文件后缀名
~~~
根据 spring.cloud.nacos.server-addr 获取 nacos地址，再根据`${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}`作为文件id，来读取配置。
在这个例子例中，就是去读取 `userservice-dev.yaml`
**3、使用代码来验证是否拉取成功**
在 user-service 中的 UserController 中添加业务逻辑，读取 pattern.dateformat 配置并使用：
~~~ java
@Value("${pattern.dateformat}")
private String dateformat;
@GetMapping("now")
public String now(){
//格式化时间
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
}
~~~
**4、启动服务后，访问：http://localhost:8081/user/now**
### 3、 配置热更新
我们最终的目的，是修改 nacos 中的配置后，微服务中无需重启即可让配置生效，也就是**配置热更新**。
有两种方式：
1. 用 `@value` 读取配置时，搭配 `@RefreshScope`
2. 直接用 `@ConfigurationProperties` 读取配置
#### 3.1 @RefreshScope
方式一：在 `@Value` 注入的变量所在类上添加注解 `@RefreshScope`
#### 3.2 @ConfigurationProperties
使用@ConfigurationProperties注解代替@Value注解。
在user-service服务中，添加一个类，读取patterrn.dateformat属性：
~~~ Java
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
public String dateformat;
}
~~~
在UserController中使用这个类代替@Value：
~~~ java
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
@Resource
private UserService userService;
// @Value("${pattern.dataformat}")
// private String dateformat;
@Resource
private PatternProperties patternProperties;
/**
* 获取当前时间
* @return
*/
@GetMapping("now")
public String now() {
// 格式化时间
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
}
}
~~~
### 4、配置共享
其实在服务启动时，nacos 会读取多个配置文件，例如：
- `[spring.application.name]-[spring.profiles.active].yaml`，例如：userservice-dev.yaml
- `[spring.application.name].yaml`，例如：userservice.yaml
这里的 `[spring.application.name].yaml` 不包含环境，**因此可以被多个环境共享**。
**添加一个环境共享配置**
我们在 nacos 中添加一个 userservice.yaml 文件：
**在 user-service 中读取共享配置**
在 user-service 服务中，修改 PatternProperties 类，读取新添加的属性：
在 user-service 服务中，修改 UserController，添加一个方法：
**运行两个 UserApplication，使用不同的profile**
修改 UserApplication2 这个启动项，改变其profile值：
这样，UserApplication(8081) 使用的 profile 是 dev，UserApplication2(8082) 使用的 profile 是test 启动 UserApplication 和 UserApplication2
访问地址：http://localhost:8081/user/prop，结果：
访问地址：http://localhost:8084/user/prop 结果：
可以看出来，不管是 dev，还是 test 环境，都读取到了 envSharedValue 这个属性的值。
上面的都是同一个微服务下，**那么不同微服务之间可以环境共享吗？**
通过下面的两种方式来指定：
**1、extension-configs**
~~~ yaml
spring:
cloud:
nacos:
config:
file-extension: yaml # 文件后缀名
extends-configs: # 多微服务间共享的配置列表
- dataId: common.yaml # 要共享的配置文件id
~~~
**2、shared-configs**
~~~ yaml
spring:
cloud:
nacos:
config:
file-extension: yaml # 文件后缀名
shared-configs: # 多微服务间共享的配置列表
- dataId: common.yaml # 要共享的配置文件id
~~~
### 5、配置优先级
当nacos、服务本地同时出现相同属性时，优先级有高低之分
## 七、Nacos集群
### 1、集群结构图
官方给出的Nacos集群图
其中包含3个nacos节点，然后一个负载均衡器代理3个Nacos。这里负载均衡器可以使用nginx。
我们计划的集群结构
三个nacos节点的地址：
| 节点 | ip | port |
| ------ | ------------- | ---- |
| nacos1 | 192.168.150.1 | 8845 |
| nacos2 | 192.168.150.1 | 8846 |
| nacos3 | 192.168.150.1 | 8847 |
### 2、搭建集群
搭建集群的基本步骤：
* 搭建数据库，初始化数据库表结构
* 下载nacos安装包
* 配置nacos
* 启动nacos集群
* nginx反向代理
#### 2.1 初始化数据库
Nacos默认数据存储在内嵌数据库Derby中，不属于生产可用的数据库。
官方推荐的最佳实践是使用带有主从的高可用数据库集群， 这里我们以单点的数据库为例。
首先新建一个数据库，命名为nacos，而后导入下面的SQL：
~~~ sql
CREATE TABLE `config_info` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(255) DEFAULT NULL,
`content` longtext NOT NULL COMMENT 'content',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
`app_name` varchar(128) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
`c_desc` varchar(256) DEFAULT NULL,
`c_use` varchar(64) DEFAULT NULL,
`effect` varchar(64) DEFAULT NULL,
`type` varchar(64) DEFAULT NULL,
`c_schema` text,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_aggr */
/******************************************/
CREATE TABLE `config_info_aggr` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(255) NOT NULL COMMENT 'group_id',
`datum_id` varchar(255) NOT NULL COMMENT 'datum_id',
`content` longtext NOT NULL COMMENT '内容',
`gmt_modified` datetime NOT NULL COMMENT '修改时间',
`app_name` varchar(128) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='增加租户字段';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_beta */
/******************************************/
CREATE TABLE `config_info_beta` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL COMMENT 'content',
`beta_ips` varchar(1024) DEFAULT NULL COMMENT 'betaIps',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_info_tag */
/******************************************/
CREATE TABLE `config_info_tag` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
`tag_id` varchar(128) NOT NULL COMMENT 'tag_id',
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL COMMENT 'content',
`md5` varchar(32) DEFAULT NULL COMMENT 'md5',
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
`src_user` text COMMENT 'source user',
`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = config_tags_relation */
/******************************************/
CREATE TABLE `config_tags_relation` (
`id` bigint(20) NOT NULL COMMENT 'id',
`tag_name` varchar(128) NOT NULL COMMENT 'tag_name',
`tag_type` varchar(64) DEFAULT NULL COMMENT 'tag_type',
`data_id` varchar(255) NOT NULL COMMENT 'data_id',
`group_id` varchar(128) NOT NULL COMMENT 'group_id',
`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',
`nid` bigint(20) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`nid`),
UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),
KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = group_capacity */
/******************************************/
CREATE TABLE `group_capacity` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`group_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Group ID，空字符表示整个集群',
`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数，，0表示使用默认值',
`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_group_id` (`group_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='集群、各Group容量信息表';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = his_config_info */
/******************************************/
CREATE TABLE `his_config_info` (
`id` bigint(64) unsigned NOT NULL,
`nid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`data_id` varchar(255) NOT NULL,
`group_id` varchar(128) NOT NULL,
`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',
`content` longtext NOT NULL,
`md5` varchar(32) DEFAULT NULL,
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
`src_user` text,
`src_ip` varchar(50) DEFAULT NULL,
`op_type` char(10) DEFAULT NULL,
`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',
PRIMARY KEY (`nid`),
KEY `idx_gmt_create` (`gmt_create`),
KEY `idx_gmt_modified` (`gmt_modified`),
KEY `idx_did` (`data_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='多租户改造';
/******************************************/
/* 数据库全名 = nacos_config */
/* 表名称 = tenant_capacity */
/******************************************/
CREATE TABLE `tenant_capacity` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`tenant_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',
`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',
`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',
`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',
`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数',
`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',
`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',
`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='租户容量信息表';
CREATE TABLE `tenant_info` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
`kp` varchar(128) NOT NULL COMMENT 'kp',
`tenant_id` varchar(128) default '' COMMENT 'tenant_id',
`tenant_name` varchar(128) default '' COMMENT 'tenant_name',
`tenant_desc` varchar(256) DEFAULT NULL COMMENT 'tenant_desc',
`create_source` varchar(32) DEFAULT NULL COMMENT 'create_source',
`gmt_create` bigint(20) NOT NULL COMMENT '创建时间',
`gmt_modified` bigint(20) NOT NULL COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),
KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';
CREATE TABLE `users` (
`username` varchar(50) NOT NULL PRIMARY KEY,
`password` varchar(500) NOT NULL,
`enabled` boolean NOT NULL
);
CREATE TABLE `roles` (
`username` varchar(50) NOT NULL,
`role` varchar(50) NOT NULL,
UNIQUE INDEX `idx_user_role` (`username` ASC, `role` ASC) USING BTREE
);
CREATE TABLE `permissions` (
`role` varchar(50) NOT NULL,
`resource` varchar(255) NOT NULL,
`action` varchar(8) NOT NULL,
UNIQUE INDEX `uk_role_permission` (`role`,`resource`,`action`) USING BTREE
);
INSERT INTO users (username, password, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);
INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');
~~~
#### 2.2 下载Nacos
nacos在GitHub上有下载地址：https://github.com/alibaba/nacos/tags可以选
择任意版本下载，本例中才用1.4.1版本。
#### 2.3 配置Nacos
进入 nacos 的 conf 目录，修改配置文件 cluster.conf.example，重命名为 cluster.conf
添加内容
~~~ reStructuredText
127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847
~~~
然后修改application.properties文件，添加数据库配置
```properties
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=123
```
#### 2.4 启动
将nacos文件夹复制三份，分别命名为：nacos1、nacos2、nacos3
然后分别修改三个文件夹中的application.properties，
nacos1
```properties
server.port=8845
```
nacos2
```properties
server.port=8846
```
nacos3
```properties
server.port=8847
```
然后分别启动三个nacos节点：
```
startup.cmd
```
#### 2.5 Nginx反向代理
修改 nginx 文件夹下的 conf/nginx.conf 文件，配置如下
~~~ nginx
upstream nacos-cluster {
server 127.0.0.1:8845;
server 127.0.0.1:8846;
server 127.0.0.1:8847;
}
server {
listen 80;
server_name localhost;
location /nacos {
proxy_pass http://nacos-cluster;
}
}
~~~
启动 nginx，在浏览器访问：http://localhost/nacos
在代码中的 application.yml 文件配置改为如下：
~~~ yaml
spring:
cloud:
nacos:
server-addr: localhost:80 # Nacos地址
~~~
实际部署时，需要给做反向代理的 Nginx 服务器设置一个域名，这样后续如果有服务器迁移 Nacos 的客户端也无需更改配置。Nacos 的各个节点应该部署到多个不同服务器，做好容灾和隔离工作。
## 八、Feign远程调用
### 1、Feign简介
我们以前利用RestTemplate发起远程调用的代码
存在下面的问题：
* 代码可读性差，编程体验不统一
* 参数复杂URL难以维护
Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign
其作用就是帮助我们**优雅的实现 http 请求的发送**，解决上面提到的问题。
### 2、Feign使用
**1、在服务消费者【order-service】引入依赖**
~~~ xml
org.springframework.cloud
spring-cloud-starter-openfeign
~~~
**2、在服务消费者【order-service】启动类上添加注解开启Feign**
**3、在服务消费者【order-service】中新建一个接口，内容如下**
~~~ java
package cn.xydream.order.service;
import cn.xydream.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(value = "userservice")
public interface UserClient {
@GetMapping("/user/{id}")
User queryById(@PathVariable("id") Long id);
}
~~~
这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：
- 服务名称：userservice
- 请求方式：GET
- 请求路径：/user/{id}
- 请求参数：Long id
- 返回值类型：User
这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。
**4、测试**
~~~ java
@Resource
private UserClient userClient;
public Order queryOrderById(Long orderId) {
// 1.查询订单
Order order = orderMapper.findById(orderId);
// 2.利用Feign发送Http请求，查询用户
User user = userClient.queryById(order.getUserId());
// 3.封装user到order
order.setUser(user);
// 4.返回
return order;
}
~~~
### 3、自定义配置
Feign 可以支持很多的自定义配置，如下表所示：
| 类型 | 作用 | 说明 |
| :--------------------- | :--------------- | :----------------------------------------------------- |
| **feign.Logger.Level** | 修改日志级别 | 包含四种不同的级别：NONE、BASIC、HEADERS、FULL |
| feign.codec.Decoder | 响应结果的解析器 | http远程调用的结果做解析，例如解析json字符串为java对象 |
| feign.codec.Encoder | 请求参数编码 | 将请求参数编码，便于通过http请求发送 |
| feign.Contract | 支持的注解格式 | 默认是SpringMVC的注解 |
| feign.Retryer | 失败重试机制 | 请求失败的重试机制，默认是没有，不过会使用Ribbon的重试 |
一般情况下，默认就能满足我们使用，如果要自定义时，只需要创建自定义的 @Bean 覆盖默认 Bean 即可。下面以日志为例来演示如何自定义配置。
#### 3.1 通过配置文件修改Feign日志级别
**基于配置文件修改 feign 的日志级别可以针对单个服务**
~~~ yaml
feign:
client:
config:
userservice: # 针对某个微服务的配置
loggerLevel: FULL # 日志级别
~~~
**也可以针对所有服务**
~~~ yaml
feign:
client:
config:
default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
loggerLevel: FULL # 日志级别
~~~
而日志的级别分为四种：
- NONE：不记录任何日志信息，这是默认值。
- BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
- HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
- FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据
#### 3.2 通过 Java 代码修改日志级别
先声明一个类，然后声明一个 Logger.Level 的对象
~~~ java
public class DefaultFeignConfiguration {
@Bean
public Logger.Level feignLogLevel(){
return Logger.Level.BASIC; // 日志级别为BASIC
}
}
~~~
如果要**全局生效**，将其放到启动类的 `@EnableFeignClients` 这个注解中：
~~~ java
@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)
~~~
如果是**局部生效**，则把它放到对应的 `@FeignClient` 这个注解中
~~~ java
@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)
~~~
### 4、性能优化
Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括
* URLConnection：默认实现，不支持连接池
* Apache HttpClient ：支持连接池
* OKHttp：支持连接池
因此提高Feign的性能主要手段就是使用**连接池**代替默认的URLConnection，
同时，日志级别应该尽量用 basic/none，可以有效提高性能。
**这里我们用Apache的HttpClient来演示：**
1、引入依赖
在服务消费者【order-service】的pom文件中引入Apache的HttpClient依赖
~~~ yaml
feign:
client:
config:
default: # default全局的配置
loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
httpclient:
enabled: true # 开启feign对HttpClient的支持
max-connections: 200 # 最大的连接数
max-connections-per-route: 50 # 每个路径的最大连接数
~~~
接下来，在FeignClientFactoryBean中的loadBalance方法中打断点
Debug方式启动order-service服务，可以看到这里的client，底层就是Apache HttpClient
### 5、最佳实践
所谓最近实践，就是使用过程中总结的经验，最好的一种使用方式。
自习观察可以发现，Feign的客户端与服务提供者的controller代码非常相似。
feign客户端
UserControlle层
以上代码出现大量重复。
#### 5.1 继承方式
一样的代码可以通过继承来共享：
1、定义一个API接口，利用定义方法，并基于SpringMVC注解做声明
2、Feign客户端和Controller都集成改接口
优点
- 简单
- 实现了代码共享
缺点
- 服务提供方、服务消费方紧耦合
- 参数列表中的注解映射并不会继承，因此 Controller 中必须再次声明方法、参数列表、注解
#### 5.2 抽取方式
将 FeignClient 抽取为独立模块，并且把接口有关的 pojo、默认的 Feign 配置都放到这个模块中，提供给所有消费者使用。
例如：将 UserClient、User、Feign 的默认配置都抽取到一个 feign-api 包中，所有微服务引用该依赖包，即可直接使用。
**实现基于抽取的最佳实践**
1、首先创建一个module，命名为feign-api
2、在feign-api中然后引入feign的starter依赖
~~~ xml
org.springframework.cloud
spring-cloud-starter-openfeign
~~~
3、然后，order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中
4、删除order-service中的UserClient、User、DefaultFeignConfiguration等类或接口
5、在order-service的pom文件中中引入feign-api的依赖【这里是引入feign-api.xml的groupId】
~~~ xml
com.xydream.feign
feign-api
1.0
~~~
6、修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包
7、当定义的 FeignClient 不在 SpringBootApplication 的扫描包范围下时，这些 FeignClient 就不能使用。修改 order-service 启动类上的 `@EnableFeignClients` 注解
方式一：指定Feign应该扫描的包
~~~ java
@EnableFeignClients(basePackages = "com.xydream.feign.clients")
~~~
方式二：指定需要加载的Client接口：
~~~ java
@EnableFeignClients(clients = {UserClient.class})
~~~
## 九、Gateway网关
### 1、网关介绍
Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。
Gateway 网关是我们服务的守门神，**所有微服务的统一入口。**
网关的**核心功能特性**：
- 请求路由
- 权限控制
- 限流
架构图
**权限控制**：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。
**路由和负载均衡**：一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。
**限流**：当请求流量过高时，在网关中按照下流的微服务能够接受的速度来放行请求，避免服务压力过大。
在SpringCloud中网关的实现包括两种：
- gateway
- zuul
Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。
### 2、网关使用
**1、创建 SpringBoot 工程 gateway**
**2、引入网关依赖，同时注册nacos**
~~~ xml
org.springframework.cloud
spring-cloud-starter-gateway
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
~~~
**3、 创建 application.yml 文件，编写基础配置和路由规则，内容如下**
~~~ yaml
server:
port: 10010 # 网关端口
spring:
application:
name: gateway # 服务名称
cloud:
nacos:
server-addr: localhost:8848 # nacos地址
gateway:
routes: # 网关路由配置
- id: user-service # 路由id，自定义，只要唯一即可
# uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
uri: lb://userservice # 路由的目标地址 lb就是负载均衡，后面跟服务名称
predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
- Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求
~~~
我们将符合`Path` 规则的一切请求，都代理到 `uri`参数指定的地址。
上面的例子中，我们将 `/user/**` 开头的请求，代理到 `lb://userservice`，其中 lb 是负载均衡(LoadBalance)，根据服务名拉取服务列表，实现负载均衡。
**4、启动网关服务进行测试**
重启网关，访问http://localhost:10010/user/1时，符合`/user/**`规则，请求转发到uri：http://userservice/user/1，得到了结果
### 4、网关路由的流程图
整个访问的流程如下
路由配置包括：
1. 路由id：路由的唯一标示
2. 路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡
3. 路由断言（predicates）：判断路由的规则
4. 路由过滤器（filters）：对请求或响应做处理