本文档写于2023年12月底——2024年1月初

1. 服务拆分、远程调用

1.1 现有项目

假如我们有一个微服务 cloud-demo，结构如下：

cloud-demo是父工程
order-service是订单微服务
user-service是用户微服务

项目要求：

订单微服务和用户微服务都必须有各自的数据库，相互独立
订单服务和用户服务都对外暴露Restful的接口
订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库

接口查询

现在order-service有一个这样的接口，查询订单：

C:\Users\Donnie> curl localhost:8080/order/101
{   
    "id":101,
    "price":699900,
    "name":"Apple 苹果 iPhone 12 ",
    "num":1,
    "userId":1,
    "user":null
}

可以看见现在有了userId但user还是null，我们需要用userId来查询用户user的信息；

而现在user-service提供了这样一个接口：

C:\Users\Donnie>curl localhost:8081/user/1
{
    "id":1,
    "username":"柳岩",
    "address":"湖南省衡阳市"
}

项目需求

修改order-service中的根据id查询订单业务，要求在查询订单的同时，根据订单中包含的userId查询出用户信息，一起返回。

1.2 实现远程调用

到这里，我们的实现方案基本明晰：我们需要在order-service中向user-service发起一个 http 的请求，调用http://localhost:8081/user/{userId}这个接口。

1.2.1 方案一使用 Rest Template

我们在order-service服务中的OrderApplication启动类中，注册RestTemplate实例：

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }

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

然后我们实现远程调用，修改OrderService 类中的 queryOrderById方法

我们再调用 order-service 的接口，可以看到

C:\Users\Donnie>curl localhost:8080/order/101
{
    "id":101,
    "price":699900,
    "name":"Apple 苹果 iPhone 12 ",
    "num":1,
    "userId":1,
    "user":
        {"id":1,
         "username":"柳岩",
         "address":" 湖南省衡阳市"
        }
}

成功！

1.2.2 方案二简单使用 Feign

开始学习该方案之前，请先进行注册中心和负载均衡的学习，否则会报依赖错误，建议了解Nacos再进行学习。

我们以前利用RestTemplate发起远程调用的代码，存在下面的问题：

代码可读性差，编程体验不统一
参数复杂URL难以维护

Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign

其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

Feign替代RestTemplate的过程如下：

引入依赖

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

添加注解

在order-service的启动类添加注解@EnableFeignClients开启Feign的功能：

@EnableFeignClients
@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

编写Feign的客户端

在order-service中新建一个接口，内容如下：

package cn.itcast.order.client;

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：

服务名称：userservice
请求方式：GET
请求路径：/user/{id}
请求参数：Long id
返回值类型：User

这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。

测试：

修改order-service中的OrderService类中的queryOrderById方法，使用Feign客户端代替RestTemplate：

    @Autowired
    private UserClient userClient;
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // TODO 2.查询用户
//        String url = "http://localhost:8081/user/" + order.getUserId();
//        String url = "http://userservice/user/" + order.getUserId();
//        User user = restTemplate.getForObject(url, User.class);
        User user = userClient.findById(order.getUserId());
        // 3.封装 user 信息
        order.setUser(user);
        // 4.返回
        return order;
    }

关于Feign更多内容的学习请浏览第五大点。

1.3 提供者与消费者

在服务调用关系中，会有两个不同的角色：

服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）

服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）

但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。

如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？

对于A调用B的业务而言：A是服务消费者，B是服务提供者
对于B调用C的业务而言：B是服务消费者，C是服务提供者

因此，服务B既可以是服务提供者，也可以是服务消费者。

1.4 多实例部署

假如我们的服务提供者user-service要部署多个实例，如图：

配置方法很简单，找到EditConfigurations：

其中，改端口号操作是在VM Options中输入：-Dserver.port=8082

启动后，可以在控制台查看端口。

1.5 设置服务名

在开始接下来的注册中心学习前，我们需要在项目中配置服务名称，以便注册中心等服务识别：

在 order-service 的 application.yml 文件中添加：

spring:
  application:
      name: orderservice

在 user-service 的 application.yml 文件中添加：

spring:
  application:
      name: userservice

2. 注册中心

假如我们的服务提供者user-service已经部署了多个实例（如何部署见1.4），如图：

现在有几个问题：

消费者 order-service 如何知道提供者 user-service 的ip地址和端口？
消费者 order-service 该调用哪一个提供者 user-service 实例？
消费者 order-service 如何得知哪一个提供者 user-service 已经挂了？

这些问题都需要利用 Spring Cloud 中的注册中心来解决，常用的注册中心有 Eureka ，Nacos等

2.1 Eureka

2.1.1 Eureka 的结构

eureka-server ：注册中心，顾名思义也是Eureka服务端，这是一个独立的微服务
eureka-client：相对注册中心的客户端，囊括服务消费者（如order-service）和服务提供者（如多个user-service）

Eureka 的基本功能分为 4 + 1 步：

注册服务信息：提供者user-service服务实例启动后，将自己的信息注册给 eureka-server； eureka-server 保存服务名称到服务实例地址列表的映射关系。
拉取服务：order-service 根据服务名称，拉取实例地址列表。
负载均衡：order-service从实例列表中利用负载均衡算法选中一个实例地址
远程调用：order-service向上一步选中的该实例地址进行远程调用
心跳续约：user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳；当超过一定时间没有发送心跳时，eureka-server 会认为微服务实例故障，将该实例从服务列表中剔除；order-service拉取服务时，就能将故障实例排除了

**2.1.2* 部署 Eureka 的大体步骤**

我们在实际部署 Eureka 的过程中，大体上分为下面几步：

搭建服务端eureka-server：
- 新创建一个子模块eureka-server；
- 引入eureka-server依赖；
- 编写启动类（注意添加注解@EnableEurekaServer）；
- 编写配置文件application.yml，填入端口号以及客户端 URL
提供者服务注册：将多个提供者实例注册到服务端eureka-server 中
- 每一个提供者实例都引入 eureka-client 依赖
- 编写配置文件application.yml，填入服务名称userservice以及客户端 URL
- 启动提供者实例，可以在 eureka-server 管理页面看到这些提供者实例。
消费者服务发现：将消费者的逻辑修改，向服务端eureka-server拉取信息
- 提供者实例都引入 eureka-client 依赖
- 编写配置文件application.yml，填入服务名称orderservice以及客户端 URL
- 实现服务拉取和负载均衡，添加注解@LoadBalanced；修改访问的url路径，用服务名代替ip、端口；

这里就不实际部署了，大概理解流程就够，因为下面介绍的才是重量级：

2.2 Nacos

初次接触Nacos，可以将它想象成Eureka的超集。它也是一个注册中心，有着服务端和客户端，结构也十分相似。

Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件。相比Eureka功能更加丰富，在国内受欢迎程度较高。

本人使用的Nacos为2.3.0版本。

2.2 只讲 Nacos 作为注册中心的部分。

2.2.1 Nacos 的结构

2.2.2 Nacos 详细配置

1）配置服务端（安装Nacos）

Nacos的服务端无需在项目中加依赖，而是直接下载安装。

在github上找到release包并安装。
安装好后，修改 nacos\bin\startup.cmd 文件：

set JAVA_HOME="D:\ProgramFiles\Java\jdk-11.0.17"
# 添加上面这一行，配置JAVA_HOME环境
if not exist "%JAVA_HOME%\bin\java.exe" echo Please set the JAVA_HOME variable in your environment, We need java(x64)! jdk8 or later is better! & EXIT /B 1
set "JAVA=%JAVA_HOME%\bin\java.exe"

写个脚本文件 or 命令行

D:\ProgramFiles\nacos\bin\startup.cmd -m standalone

启动！

"nacos is starting with standalone"
         ,--.
       ,--.'|
   ,--,:  : |                                           Nacos 2.3.0
,`--.'`|  ' :                       ,---.               Running in stand alone mode, All function modules
|   :  :  | |                      '   ,'\   .--.--.    Port: 8848
:   |   \ | :  ,--.--.     ,---.  /   /   | /  /    '   Pid: 11144
|   : '  '; | /       \   /     \.   ; ,. :|  :  /`./   Console: http://10.236.38.138:8848/nacos/index.html
'   ' ;.    ;.--.  .-. | /    / ''   | |: :|  :  ;_
|   | | \   | \__\/: . ..    ' / '   | .; : \  \    `.      https://nacos.io
'   : |  ; .' ," .--.; |'   ; :__|   :    |  `----.   \
|   | '`--'  /  /  ,.  |'   | '.'|\   \  /  /  /`--'  /
'   : |     ;  :   .'   \   :    : `----'  '--'.     /
;   |.'     |  ,     .-./\   \  /            `--'---'
'---'        `--`---'     `----'
2023-12-20 15:49:50,553 INFO Tomcat initialized with port(s): 8848 (http)
2023-12-20 15:49:50,966 INFO Root WebApplicationContext: initialization completed in 3554 ms
# 中间有一堆，省略了
2023-12-20 15:49:57,216 INFO Tomcat started on port(s): 8848 (http) with context path '/nacos'
2023-12-20 15:49:57,265 INFO Nacos started successfully in stand alone mode. use embedded storage
2023-12-20 15:50:07,035 INFO Initializing Servlet 'dispatcherServlet'
2023-12-20 15:50:07,036 INFO Completed initialization in 1 ms

进入Nacos，能进入则配置成功；http://127.0.0.1:8848/nacos

2）配置客户端

Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。

引入依赖

在cloud-demo父工程的pom文件中的<dependencyManagement>中引入SpringCloudAlibaba的依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.6.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：

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

配置nacos地址

在user-service和order-service的application.yml中添加nacos地址：

spring:
  cloud:
    nacos:
      server-addr: localhost:8848

注意：如果yml中没有设置服务名，请回到1.5设置服务名，否则nacos无法查到

重启

重启微服务后，登录nacos管理页面，可以看到微服务信息：

如果你不幸运，刷了很多遍都没刷出来，很有可能你没有点击左上角的public

3）发送请求

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.查询用户 (使用Nacos)
//        String url = "http://localhost:8081/user/" + order.getUserId();
        String url = "http://userservice/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        // 3.封装 user 信息
        order.setUser(user);
        // 4.返回
        return order;
    }

那么我们发出的请求明明是http://userservice/user/1，怎么变成了http://localhost:8081的呢？请先阅读3.1~3.2 客户端负载均衡。

2.2.3 服务分级存储模型：集群

以下内容请先阅读完 3.1 ~ 3.2 再回来阅读

一个服务可以有多个实例，例如我们的user-service，可以有:

127.0.0.1:8081
127.0.0.1:8082
127.0.0.1:8083

假如这些实例分布于全国各地的不同机房，例如：

127.0.0.1:8081，在上海机房
127.0.0.1:8082，在上海机房
127.0.0.1:8083，在杭州机房

Nacos就将同一机房内的实例划分为一个集群。

也就是说，user-service是服务，一个服务可以包含多个集群，如杭州、上海，每个集群下可以有多个实例，形成分级模型，如图：

微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。

1）配置集群

方式一：修改application.yml文件

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 集群名称

方式二：IDEA添加启动配置时，添加属性。在VM Options中输入：

-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH

类似 1.4 多实例部署

在控制台中，可以看到user service有2个集群、3个实例：

点进userservice的详情，可以看到这两个集群：

2）同集群优先的负载均衡

默认的ZoneAvoidanceRule并不能实现根据同集群优先来实现负载均衡。

因此Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例。

给order-service配置集群信息

修改order-service的application.yml文件，添加集群配置：

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 集群名称

修改负载均衡规则

修改order-service的application.yml文件，修改负载均衡规则：

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

3）实例与实验

按上述方法配置，并按照3.2的方法进行测试，可以发现：

如果8081、8082、8083都健康：只有8081、8082被请求到，8083没有反应。

停掉8081，留8082、8083：只有8082被请求到，8083没有反应。

把8081、8082都停掉，同集群的都挂掉了：这时8083才有反应，是跨集群请求

2.2.4 权重配置

实际部署中会出现这样的场景：

服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。

但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。

因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。

在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重。

注意：如果权重修改为0，则该实例永远不会被访问

实验：调整8082的权重为0.3，多次请求，可以对比请求次数，很明显8082要比8081请求次数少。

**2.2.5* 环境隔离**

Nacos提供了namespace来实现环境隔离功能。

nacos中可以有多个namespace
namespace下可以有group、service等
不同namespace之间相互隔离，例如不同namespace的服务互相不可见

1）创建namespace

2）给微服务配置namespace

例如，修改order-service的application.yml文件：

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID

如果namespace不同，控制台会直接报错 No instances available

**2.2.6* 非临时实例**

Nacos的服务实例分为两种l类型：

临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。

配置一个服务实例为永久实例：

spring:
  cloud:
    nacos:
      discovery:
        ephemeral: false # 设置为非临时实例

3. 客户端负载均衡

在2.1.2 Eureka中，我们添加了@LoadBalanced注解，即可实现负载均衡功能，这是什么原理呢？

3.1 负载均衡原理

SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。

那么我们发出的请求明明是http://userservice/user/1，怎么变成了http://localhost:8081的呢？

基本流程如下：

拦截我们的 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 ，发起真实请求

3.2 负载均衡策略

负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：

ZoneAvoidanceRule：以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。

默认的实现就是ZoneAvoidanceRule，是一种轮询方案。

也可以自定义负载均衡策略，但一般用默认的负载均衡规则，不做修改。

实例：Nacos内置Ribbon实现轮询

现在项目中，有一个消费者，三个提供者：

我们在RestTemplate上加一个负载均衡注解 @LoadBalanced ：

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

为了模拟“轮询，我们调用 order-service 中的接口的时候，故意请求了两次：

    @GetMapping("{orderId}")
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
        // 根据id查询订单并返回
        orderService.queryOrderById(orderId);
        return orderService.queryOrderById(orderId);
    }

测试接口，控制台成功返回：

C:\Users\Donnie>curl localhost:8080/order/101
{"id":101,"price":699900,"name":"Apple 苹果 iPhone 12 ","num":1,"userId":1,"user":{"id":1,"username":"柳岩","address":" 湖南省衡阳市"}}

然后再查看Springboot的控制台，注意时间点。

这是8081的控制台：

这是8082的控制台：

可以看出在同一时间点上，先后请求了8081、8082；

再请求一次，Nacos给我们请求了8082、8083（截图类似，不再列出）；

也就是说实现了轮询的负载均衡。

**3.3* 饥饿加载**

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。

而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true
    clients: userservice

4. 配置管理

当微服务部署的实例越来越多，达到数十、数百时，逐个修改微服务配置就会让人抓狂，而且很容易出错。我们需要一种统一配置管理方案，可以集中管理所有实例的配置。

Nacos除了可以做注册中心，同样可以做配置管理来使用。

4.1 统一配置管理

4.1.1 原理分析

Nacos一方面可以将配置集中管理，另一方可以在配置变更时，及时通知微服务，实现配置的热更新。

注意：项目的核心配置，需要热更新的配置才有放到nacos管理的必要。基本不会变更的一些配置还是保存在微服务本地比较好。

微服务需要先在bootstrap.yaml文件中读取nacos的地址，将nacos的配置与本地的application.yaml合并，再读取合并后的yaml文件，实现nacos更新配置：

4.1.2 在nacos添加配置文件

打开 http://localhost:8848/nacos/ ，进入图形化界面，选择配置列表，在public 命名空间里创建配置。

然后在弹出的表单中填写配置信息：（假如我们要对user-service进行配置）

4.1.3 从微服务拉取配置

我们以下针对的都是user-service微服务：

引入nacos-config依赖

<!--nacos配置管理依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

添加bootstrap.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。

读取nacos配置

@Value 注解：可以读取本地配置文件中的数据，如：

@Slf4j
@RestController
@RequestMapping("/value")
public class Controller {

    @Value("${spring.datasource.url}")
    private String url;

    @GetMapping("getUrl")
    public String getUrl(){
        return url;
    }
}

调接口，返回的就是数据库地址

C:\Users\Donnie>curl localhost:8081/value/getUrl
jdbc:mysql://localhost:3306/cloud_user?useSSL=false

同样的，@Value在微服务拉取配置文件后，也能读取nacos中的配置文件：

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Value("${pattern.dateformat}")
    private String dateformat;
    
    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }
    // ...略
}

现在我们测一下接口

C:\Users\Donnie>curl localhost:8081/user/now
2023-12-29 17:13:42

4.2 配置热更新

我们最终的目的，是修改nacos中的配置后，微服务中无需重启即可让配置生效，也就是配置热更新。

要实现配置热更新，可以使用两种方式：

4.2.1 方式一

在@Value注入的变量所在类上添加注解@RefreshScope：

@Slf4j
@RestController
@RequestMapping("/user")
@RefreshScope
public class UserController {

    @Value("${pattern.dateformat}")
    private String dateformat;
	
    // ...其他代码
}

实现：我们在项目启动的时候，登上nacos服务端，修改配置：

无需将项目重新启动，再次调用接口：

C:\Users\Donnie>curl localhost:8081/user/now
2023-12-29 17:13:42
C:\Users\Donnie>curl localhost:8081/user/now
12-29-23 17:32:01

4.2.2 方式二

使用@ConfigurationProperties注解代替@Value注解。

在user-service服务中，添加一个类，读取patterrn.dateformat属性：

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}

加上注解@ConfigurationProperties 之后，这里变量 dateformat 的值就是yaml文件中 pattern.dateformat中的值。（我们也可以通过这个注解构造一个yaml配置文件格式）

在UserController中使用这个类代替@Value。

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private PatternProperties patternProperties;

    @GetMapping("now")
    public String now(){
        return LocalDateTime.now()
            .format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
    }

    // 略
}

**4.3* 配置共享**

其实微服务启动时，会去nacos读取多个配置文件，例如：

[spring.application.name]-[spring.profiles.active].yaml，例如：userservice-dev.yaml
[spring.application.name].yaml，例如：userservice.yaml

而[spring.application.name].yaml不包含环境，因此可以被多个环境共享。

下面我们通过案例来测试配置共享

4.3.1 添加一个环境共享配置

我们在nacos中添加一个userservice.yaml文件：

4.3.2 在user-service中读取共享配置

在user-service服务中，修改PatternProperties类，读取新添加的属性：

在user-service服务中，修改UserController，添加一个方法：

4.3.3 运行两个UserApplication，使用不同的profile

修改UserApplication2这个启动项，改变其profile值：

这样，UserApplication(8081)使用的profile是dev，UserApplication2(8082)使用的profile是test。

启动UserApplication和UserApplication2。

启动UserApplication和UserApplication2

访问http://localhost:8081/user/prop，结果：

访问http://localhost:8082/user/prop，结果：

可以看出来，不管是dev，还是test环境，都读取到了envSharedValue这个属性的值。

4.3.4 配置共享的优先级

当nacos、服务本地同时出现相同属性时，优先级有高低之分：

**5. *Feign优化**

**5.1* Feign自定义配置**

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即可。

下面以日志为例来演示如何自定义配置。

5.1.1 配置文件方式

基于配置文件修改feign的日志级别可以针对单个服务：

feign:  
  client:
    config: 
      userservice: # 针对某个微服务的配置
        loggerLevel: FULL #  日志级别

也可以针对所有服务：

feign:  
  client:
    config: 
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

而日志的级别分为四种：

NONE：不记录任何日志信息，这是默认值。
BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

5.1.2 Java代码方式（推荐）

也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：

public class DefaultFeignConfiguration  {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

如果要全局生效，将其放到启动类的@EnableFeignClients这个注解中：

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)

如果是局部生效，则把它放到对应的@FeignClient这个注解中：

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)

**5.2 *Feign 使用优化**

Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

•URLConnection：默认实现，不支持连接池

•Apache HttpClient ：支持连接池

•OKHttp：支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。

这里我们用Apache的HttpClient来演示。

1）引入依赖

在order-service的pom文件中引入Apache的HttpClient依赖：

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

2）配置连接池

在order-service的application.yml中添加配置：

feign:
  client:
    config:
      default: # default全局的配置
        loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
  httpclient:
    enabled: true # 开启feign对HttpClient的支持
    max-connections: 200 # 最大的连接数
    max-connections-per-route: 50 # 每个路径的最大连接数

总结，Feign的优化：

1.日志级别尽量用basic

2.使用HttpClient或OKHttp代替URLConnection

① 引入feign-httpClient依赖

② 配置文件开启httpClient功能，设置连接池参数

**5.3 *Feign最佳实践**

所谓最近实践，就是使用过程中总结的经验，最好的一种使用方式。

观察可以发现，Feign的客户端与服务提供者的controller代码非常相似：

feign客户端：

@FeignClient("userservice")
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

UserController：

    // 这里合并了@RequestMapping的("/user")
	@GetMapping("/user/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }

我们可以用一种抽取方式简化这种重复的编写：

将Feign的Client抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。

例如，将UserClient、User、Feign的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。

我后来看了下文档……感觉也没最佳到哪去啊？不就是换了个地方……真没看懂哪里好了，而且换配置文件贼麻烦估计还要统一配置管理，以后看看能不能用上吧。

1）抽取

首先创建一个module，命名为feign-api：

在feign-api中然后引入feign的starter依赖

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

然后，order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中

2）在order-service中使用feign-api

首先，删除order-service中的UserClient、User、DefaultFeignConfiguration等类或接口。

在order-service的pom文件中中引入feign-api的依赖：

<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包

3）重启测试

重启后，发现服务报错了。

这是因为UserClient现在在cn.itcast.feign.clients包下，

而order-service的@EnableFeignClients注解是在cn.itcast.order包下，不在同一个包，无法扫描到UserClient。

4）解决扫描包问题

方式一：

指定Feign应该扫描的包：

@EnableFeignClients(basePackages = "cn.itcast.feign.clients")

方式二：

指定需要加载的Client接口：

@EnableFeignClients(clients = {UserClient.class})

下文链接：

http://zxlmdonnie.cn/archives/1710316625408