1.微服务

①架构对比

分布式架构虽然降低了服务耦合，但是服务拆分时也有很多问题需要思考：

• 服务拆分的粒度如何界定？
• 服务集群地址如何维护？
• 服务的调用关系如何管理？
• 服务健康状态如何感知？

人们需要制定一套行之有效的标准来约束分布式架构。因此微服务来啦！！！

②微服务简介

微服务的架构特征：

• 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
• 自治：团队独立、技术独立、数据独立，独立部署和交付
• 面向服务：服务提供统一标准的接口，与语言和技术无关
• 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。因此微服务是一种经过良好架构设计的分布式架构方案 。

微服务架构

但方案该怎么落地？选用什么样的技术栈？其中在Java领域最引人注目的就是SpringCloud提供的方案了。

③微服务方案

目前国内使用最广泛的微服务方案：Dubbo、SpringCloud、SpringCloudAlibaba

方案对比

⑤案例引入

下方的讲解都基于此案例进行，请提前搭建好此项目。项目cloud-demo 密码:1399

搭建方式：1.使用IDEA 打开 cloud-demo项目 2.创建两个数据库cloud_order和cloud_user 3.将提供的cloud-order.sql和cloud-user.sql导入对应库中 4.修改项目中数据库密码

项目结构：

cloud-demo  # 父工程，管理依赖
├── order-service # 订单微服务，负责订单相关业务
└── user-service  # 用户微服务，负责用户相关业务

项目特征：

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

基础概念：

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

• 服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
  
• 服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）
  
• 服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。
  

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

2.服务远程调用①

①RestTemplate

要实现上方需求，我们需要在order-service中向user-service发起一个http的请求，调用http://localhost:8081/user/{userId}接口。

步骤如下：

• 注册一个RestTemplate的实例到Spring容器
• 修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User
• 将查询的User填充到Order对象，一起返回

步骤一：注册RestTemplate

@MapperScan("cn.xxxx.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

步骤二：实现远程调用

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate 
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.远程查询user
        // 2.1 url地址
        String url = "http://localhost:8081/user/" + order.getUserId();
        // 2.2 发起调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

3.服务注册发现

①Eureka

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

思考几个问题：

• order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
• 有多个user-service实例地址，order-service调用时该如何选择？
• order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

❶Eureka原理分析

这些问题都需要利用SpringCloud中的注册中心来解决，其中最广为人知的注册中心就是Eureka，其结构如下：

问题1：order-service如何得知user-service实例地址？

• user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
• eureka-server保存服务名称到服务实例地址列表的映射关系
• order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取

问题2：order-service如何从多个user-service实例中选择具体的实例？

• order-service从实例列表中利用负载均衡算法选中一个实例地址
• 并向该实例地址发起远程调用

问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

• user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
• 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
• order-service拉取服务时，就能将故障实例排除了

使用步骤

❷搭建eureka-server

步骤一：创建eureka-server模块

在cloud-demo父工程下，创建一个maven子模块 eureka-server

步骤二：引入eureka依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

步骤三：编写启动类

编写一个启动类，添加@EnableEurekaServer注解，开启eureka的注册中心功能

@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

步骤四：编写配置文件

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url: 
      defaultZone: http://127.0.0.1:10086/eureka

步骤五：启动服务

启动微服务，然后在浏览器访问：http://127.0.0.1:10086，看到Web页面表示成功了

❸服务注册

下面，我们将user-service注册到eureka-server中去。

步骤一：引入依赖

在user-service的pom文件中，引入eureka-client依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

步骤二：配置文件

在user-service中，修改application.yml文件，添加服务名称、eureka地址：

spring:
  application:
    name: userservice
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

步骤三：启动多个user-service实例

为了演示一个服务有多个实例的场景，可以通过SpringBoot的启动配置，再启动一个user-service。

查看eureka-server管理页面：

❹服务发现

下面，我们将order-service的逻辑修改：实现向eureka-server拉取user-service的信息，即服务发现。

步骤一：引入依赖

服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致。

在order-service的pom文件中，引入eureka-client依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

步骤二：配置文件

服务发现也需要知道eureka地址，在order-service中，修改application.yml文件，添加服务名称、eureka地址：

spring:
  application:
    name: orderservice
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

步骤三：服务拉取和负载均衡

最后，我们要去eureka-server中拉取user-service服务的实例列表，并且实现负载均衡。

在order-service的OrderApplication中，给RestTemplate这个Bean添加一个@LoadBalanced注解：

@MapperScan("cn.xxxx.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    @Bean
    @LoadBalanced //添加注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

修改order-service服务中的OrderService类中的queryOrderById方法。修改访问的url路径，用服务名代替ip、端口：

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate 
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.远程查询user
        // 2.1 url地址
                //String url = "http://localhost:8081/user/" + order.getUserId();
        String url = "http://userservice/user/" + order.getUserId();
        // 2.2 发起调用
        User user = restTemplate.getForObject(url, User.class);
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

spring会自动帮助我们从eureka-server端，根据userservice这个服务名称，获取实例列表，而后完成负载均衡。

❺总结

• 1.搭建EurekaServer

• 引入eureka-server依赖
  
• 添加@EnableEurekaServer注解
  
• 在application.yml中配置eureka地址
  

• 2.服务注册

• 引入eureka-client依赖
• 在application.yml中配置eureka地址

• 3.服务发现

• 引入eureka-client依赖
• 在application.yml中配置eureka地址
• 给RestTemplate添加@LoadBalanced注解
• 用服务提供者的服务名称远程调用

②Nacos

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

❶安装

下载地址：https://github.com/alibaba/nacos

下载后解压即可，目录说明：

- log           nacos生成日志说明
- bin           nacos服务相关脚本目录，
- conf          nacos的配置文件目录
- target        nacos的启动依赖目录
- data          nacos自带apache-derby数据库，data存放数据内容

# 启动命令 单体启动
sh startup.sh -m standalone
# 关闭命令
sh shutdown.sh

在浏览器输入地址即可访问：http://127.0.0.1:8848/nacos，默认的账号和密码都是nacos

如果你打不开这个网页 ！多半是版本问题。

❷服务注册/发现

步骤一：引入依赖

在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>

注意：不要忘了注释掉eureka的依赖。

步骤二：配置nacos地址

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

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

注意：不要忘了注释掉eureka的地址

步骤三：重启

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

❸集群配置

⓵分级存储模型

一个服务可以有多个实例，例如我们的user-service，假如这些实例分布于全国各地的不同机房

Nacos就将同一机房内的实例划分为一个集群。也就是说，user-service是服务，一个服务可以包含多个集群，如杭州、上海、北京，每个集群下可以有多个实例，形成分级模型，如图：

①一级是服务，例如user-service；②二级是集群，例如杭州或上海；③三级是实例，例如杭州机房的某台部署

微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内实例不可用时，才访问其它集群。例如：杭州机房内的order-service应该优先访问同机房的user-service。

⓶给user-service配置集群

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

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

重启两个user-service实例后，我们可以在nacos控制台看到下面结果：

我们再次复制一个user-service启动配置UserApplication3，复制方式参考【上方搭建eureka-server步骤三】

添加VM属性：

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

启动UserApplication3后再次查看nacos控制台：

⓷同集群优先的负载均衡

负载均衡默认规则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 # 负载均衡规则

NacosRule负载均衡策略

• ①优先选择同集群服务实例列表
  
• ②本地集群找不到提供者，才去其它集群寻找，并且会报警告
  
• ③确定了可用实例列表后，再采用随机负载均衡挑选实例
  

❹权重配置

实际部署中会出现这样的场景：服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。

因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重：

注意：如果权重修改为0，则该实例永远不会被访问，使用场景：进行实例的平滑更新

❺环境隔离

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

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

步骤一：创建namespace

默认情况下，所有service、group、data都在同一个namespace，名为public

就能在页面看到一个新的namespace：

步骤二：给微服务配置namespace

给微服务配置namespace只能通过修改配置来实现。例如，修改order-service的application.yml文件：

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

重启order-service后，访问控制台，可以看到下面的结果：

此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错：

③Nacos与Eureka区别

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

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

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

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

Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差异：

4.负载均衡-Ribbon

①负载均衡原理

SpringCloud底层利用Ribbon来实现负载均衡功能

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

显然有人帮我们根据service名称，获取到了服务实例的ip和端口。它就是LoadBalancerInterceptor，这个类会在对RestTemplate的请求进行拦截，然后从Eureka根据服务id获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务id。我们进行源码跟踪：

❶LoadBalancerIntercepor

可以看到这里的intercept方法，拦截了用户的HttpRequest请求，然后做了几件事：

• request.getURI()：获取请求uri，本例中就是 http://user-service/user/8
• originalUri.getHost()：获取uri路径的主机名，其实就是服务id，user-service
• this.loadBalancer.execute()：处理服务id，和用户请求。

这里的this.loadBalancer是LoadBalancerClient类型，我们继续跟入execute方法：

❷LoadBalancerClient

• getLoadBalancer(serviceId)：根据服务id获取ILoadBalancer，而ILoadBalancer会拿着服务id去eureka中获取服务列表并保存起来。
• getServer(loadBalancer)：利用内置的负载均衡算法，从服务列表中选择一个。本例中，可以看到获取了8082端口的服务

放行后，再次访问并跟踪，发现获取的是8081，果然实现了负载均衡。

❸负载均衡策略IRule

在刚才的代码中，可以看到获取服务使通过一个getServer方法来做负载均衡:

我们继续跟入：

继续跟踪源码chooseServer方法，发现这么一段代码：

这里的rule默认值是一个RoundRobinRule，看类的介绍：

这不就是轮询的意思嘛。到这里，整个负载均衡的流程我们就清楚了。

❹总结

Ribbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：

基本流程如下：

• 1.拦截我们的RestTemplate请求http://userservice/user/1
• 2.RibbonLoadBalancerClient会从请求url中获取服务名称，也就是userservice
• 3.DynamicServerListLoadBalancer根据userservice到eureka拉取服务列表
• 4.eureka-server返回列表，localhost:8081、localhost:8082
• 5.IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
• 6.RibbonLoadBalancerClient修改请求地址，用localhost:8081替代userservice，得到http://localhost:8081/user/1，发起真实请求

②负载均衡策略

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

不同规则的含义如下：

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

自定义负载均衡策略

通过定义IRule实现可以修改负载均衡规则，有两种方式：

• 1.全局配置：在order-service中的OrderApplication类中，定义一个新的IRule

@Bean
public IRule randomRule(){
    return new RandomRule();
}

• 2.单个配置：在order-service的application.yml文件中，添加新的配置也可以修改规则：

userservice: # 给某个微服务配置负载均衡规则，这里是userservice服务
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

注意，一般用默认的负载均衡规则，不做修改。

③饥饿加载

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

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

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

5.服务远程调用②

②OpenFeign

前面利用RestTemplate发起远程调用的代码

String url = "http://localhost:8081/user/" + order.getUserId();
User user = restTemplate.getForObject(url, User.class);

存在下面的问题：

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

OpenFeign是一个声明式的http客户端，其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

❶使用

步骤一：引入依赖

在order-service服务的pom文件中引入openfeign的依赖

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

使用 openfeign 依赖 ribbon，但是最新版的 openfeign 移除了ribbon ，因此如果单独使用openfeign需要引入ribbon，并进行配置。如果配合 eureka 或 nacos 则不用

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

# 这个userservice是加了@FeignClient注解的类的name
userservice:
  ribbon:
    # 服务提供者的地址，不是服务注册中心的地址
    listOfServers: http://localhost:8081

步骤二：添加注解

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

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

步骤三：编写Feign的客户端

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

@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：

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private UserClient userClient 
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用Feign发起http请求，查询用户
        User user = userClient.findById(order.getUserId());
        // 3.存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

实现过程

总结

使用Feign的步骤：

• ① 引入依赖
  
• ② 添加@EnableFeignClients注解
  
• ③ 编写FeignClient接口
  
• ④ 使用FeignClient中定义的方法代替RestTemplate
  

❷配置

Feign可以支持很多的自定义配置，如下表所示：

日志的级别分为四种：

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

一般情况下，默认值就能满足我们使用，如果要自定义时，可以通过修改配置文件或者创建自定义@Bean覆盖默认Bean

修改配置文件方式

• 针对单个服务：

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

• 针对所有服务：

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

自定义Bean覆盖

也可以基于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)

❸优化

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

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

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。这里我们用Apache的HttpClient来演示。

步骤一：引入依赖

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

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

步骤二：配置连接池

在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的客户端与服务提供者的controller代码非常相似：

有没有一种办法简化这种重复的代码编写呢？

方案一：继承方式

一样的代码可以通过继承来共享：

• 1.定义一个API接口，利用定义方法，并基于SpringMVC注解做声明。
• 2.Feign客户端和Controller都集成该接口

优点：

• 简单
• 实现了代码共享

缺点：

• 服务提供方、服务消费方紧耦合
  
• 参数列表中的注解映射并不会继承，因此Controller中必须再次声明方法、参数列表、注解
  

方案二：抽取方式

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

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

步骤一：抽取

首先创建一个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项目中

步骤二：在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中的包

步骤三：重启测试

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

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

步骤四：解决扫描包问题

方式一：指定Feign应该扫描的包：

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

方式二：指定需要加载的Client接口：

@EnableFeignClients(clients = {UserClient.class})

6.统一配置管理

①Nacos

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

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

❶统一配置管理

步骤一：在nacos中添加配置文件

步骤二：从微服务拉取配置

微服务要拉取nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动。

但如果尚未读取application.yml，又如何得知nacos地址呢？

因此spring引入了一种新的配置文件：bootstrap.yaml文件，会在application.yml之前被读取，流程如下：

1.引入Nacos的配置管理客户端依赖

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

2.在userservice的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml：

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配置

@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));
    }
}

访问页面http://127.0.0.1:8081/user/now即可看到时间

总结：将配置交给Nacos管理的步骤

• ①在Nacos中添加配置文件
  
• ②在微服务中引入nacos的config依赖
  
• ③在微服务中添加bootstrap.yml，配置nacos地址、当前环境、服务名称、文件后缀名。
  

❷配置热更新

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

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

方式一：通过 Spring Cloud 原生注解 @RefreshScope 实现配置自动更新

@RefreshScope //添加注解
@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));
    }
}

方式二：使用@ConfigurationProperties注解代替@Value注解

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

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

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

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private PatternProperties patternProperties;
    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
    }
}

❸配置共享

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

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

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

例如：在nacos配置3个文件：userservice-dev.yaml、userservice-test.yaml、userservice.yaml

UserApplication(8081)使用的profile是dev，UserApplication2(8082)使用的profile是test，运行后不管是dev，还是test环境，都读取到了userservice.yaml中属性的值。

但是当nacos和服务本地同时出现相同属性时，优先级有高低之分：userservice-dev.yaml > userservice.yaml > application.yml

多服务共享配置

不同微服务之间可以共享配置文件，通过下面的两种方式来指定

方式一：

spring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev #开发环境，这里是dev
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
        shared-configs: # 多微服务间共享的配置列表
         - dataId: common.yaml # 要共享的配置文件id

方式二：

spring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev #开发环境，这里是dev
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
        extends-configs: # 多微服务间共享的配置列表
         - dataId: extend.yaml # 要共享的配置文件id

多种配置的优先级：

❹搭建Nacos集群

⓵初始化数据库

Nacos默认数据存储在内嵌数据库Derby中，不属于生产可用的数据库。官方推荐的最佳实践是使用带有主从的高可用数据库集群。这里我们以单点的数据库为例。

首先新建一个数据库，命名为nacos，而后导入官方提供的SQL：nacos/schema.sql

⓶部署配置nacos

下载nacos后，进入nacos的conf目录，修改配置文件cluster.conf.example，重命名为cluster.conf

然后添加内容：

127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847

然后修改application.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=root

⓷启动nacos集群

将nacos文件夹复制三份，分别命名为：nacos1、nacos2、nacos3；然后分别修改三个文件夹中的application.properties

nacos1:

server.port=8845

nacos2:

server.port=8846

nacos3:

server.port=8847

然后分别启动三个nacos节点：startup.cmd

⓸nginx反向代理

下载nginx后，修改conf/nginx.conf文件，配置如下：

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;
    }
}

而后在浏览器访问：http://localhost/nacos即可。

代码中application.yml文件配置如下：

spring:
  cloud:
    nacos:
      server-addr: localhost:80 # Nacos地址

⓹优化

• 实际部署时，需要给做反向代理的nginx服务器设置一个域名，这样后续如果有服务器迁移，nacos的客户端也无需更改配置
  
• Nacos的各个节点应该部署到多个不同服务器，做好容灾和隔离