• SpringCloud实战教程 黑马商城企业级项目 服务注册和发现 OpenFeign

    3.服务注册和发现

    在上一章我们实现了微服务拆分，并且通过Http请求实现了跨微服务的远程调用。不过这种手动发送Http请求的方式存在一些问题。

    试想一下，假如商品微服务被调用较多，为了应对更高的并发，我们进行了多实例部署，如图：

    此时，每个item-service的实例其IP或端口不同，问题来了：

    • item-service这么多实例，cart-service如何知道每一个实例的地址？
    • http请求要写url地址，cart-service服务到底该调用哪个实例呢？
    • 如果在运行过程中，某一个item-service实例宕机，cart-service依然在调用该怎么办？
    • 如果并发太高，item-service临时多部署了N台实例，cart-service如何知道新实例的地址？

    为了解决上述问题，就必须引入注册中心的概念了，接下来我们就一起来分析下注册中心的原理。

    3.1.注册中心原理

    在微服务远程调用的过程中，包括两个角色：

    • 服务提供者：提供接口供其它微服务访问，比如item-service
    • 服务消费者：调用其它微服务提供的接口，比如cart-service

    在大型微服务项目中，服务提供者的数量会非常多，为了管理这些服务就引入了注册中心的概念。注册中心、服务提供者、服务消费者三者间关系如下：

    流程如下：

    • 服务启动时就会注册自己的服务信息（服务名、IP、端口）到注册中心
    • 调用者可以从注册中心订阅想要的服务，获取服务对应的实例列表（1个服务可能多实例部署）
    • 调用者自己对实例列表负载均衡，挑选一个实例
    • 调用者向该实例发起远程调用

    当服务提供者的实例宕机或者启动新实例时，调用者如何得知呢？

    • 服务提供者会定期向注册中心发送请求，报告自己的健康状态（心跳请求）
    • 当注册中心长时间收不到提供者的心跳时，会认为该实例宕机，将其从服务的实例列表中剔除
    • 当服务有新实例启动时，会发送注册服务请求，其信息会被记录在注册中心的服务实例列表
    • 当注册中心服务列表变更时，会主动通知微服务，更新本地服务列表

    3.2.Nacos注册中心

    目前开源的注册中心框架有很多，国内比较常见的有：

    • Eureka：Netflix公司出品，目前被集成在SpringCloud当中，一般用于Java应用
    • Nacos：Alibaba公司出品，目前被集成在SpringCloudAlibaba中，一般用于Java应用
    • Consul：HashiCorp公司出品，目前集成在SPringCloud中，不限制微服务语言

    以上几种注册中心都遵循SpringCloud中的API规范，因此在业务开发使用上没有太大差异。由于Nacos是国内产品，中文文档比较丰富，而且同时具备配置管理功能（后面会学习），因此在国内使用较多，课堂中我们会Nacos为例来学习。

    官方网站如下：

    什么是 Nacos

    我们基于Docker来部署Nacos的注册中心，首先我们要准备MySQL数据库表，用来存储Nacos的数据。由于是Docker部署，所以大家需要将资料中的SQL文件导入到你Docker中的MySQL容器中：

    最终表结构如下：

    然后，找到课前资料下的nacos文件夹：

    其中的nacos/custom.env文件中，有一个MYSQL_SERVICE_HOST也就是mysql地址，需要修改为你自己的虚拟机IP地址：

    然后，将课前资料中的nacos目录上传至虚拟机的/root目录。

    进入root目录，然后执行下面的docker命令：

    1. docker run -d \
    2. --name nacos2 \
    3. --env-file ./nacos/custom.env \
    4. -p 8848:8848 \
    5. -p 9848:9848 \
    6. -p 9849:9849 \
    7. --restart=always \
    8. nacos/nacos-server:v2.1.0-slim

    启动完成后，访问下面地址：http://192.168.150.101:8848/nacos/，注意将192.168.150.101替换为你自己的虚拟机IP地址。

    首次访问会跳转到登录页，账号密码都是nacos

    3.3.服务注册

    接下来，我们把item-service注册到Nacos，步骤如下：

    • 引入依赖
    • 配置Nacos地址
    • 重启

    3.3.1.添加依赖

    在item-service的pom.xml中添加依赖：

    1. <!--nacos 服务注册发现-->
    2. <dependency>
    3.     <groupId>com.alibaba.cloud</groupId>
    4.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    5. </dependency>

    3.3.2.配置Nacos

    在item-service的application.yml中添加nacos地址配置：

    1. spring:
    2.   application:
    3.     name: item-service # 服务名称
    4.   cloud:
    5.     nacos:
    6.       server-addr: 192.168.150.101 # nacos地址

    3.3.3.启动服务实例

    为了测试一个服务多个实例的情况，我们再配置一个item-service的部署实例：

    然后配置启动项，注意重命名并且配置新的端口，避免冲突：

    重启item-service的两个实例：

    访问nacos控制台，可以发现服务注册成功：

    点击详情，可以查看到item-service服务的两个实例信息：

    3.4.服务发现

    服务的消费者要去nacos订阅服务，这个过程就是服务发现，步骤如下：

    • 引入依赖
    • 配置Nacos地址
    • 发现并调用服务

    3.4.1.引入依赖

    服务发现除了要引入nacos依赖以外，由于还需要负载均衡，因此要引入SpringCloud提供的LoadBalancer依赖。

    我们在cart-service中的pom.xml中添加下面的依赖：

    1. <!--nacos 服务注册发现-->
    2. <dependency>
    3.     <groupId>com.alibaba.cloud</groupId>
    4.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    5. </dependency>

    可以发现，这里Nacos的依赖于服务注册时一致，这个依赖中同时包含了服务注册和发现的功能。因为任何一个微服务都可以调用别人，也可以被别人调用，即可以是调用者，也可以是提供者。

    因此，等一会儿cart-service启动，同样会注册到Nacos

    3.4.2.配置Nacos地址

    在cart-service的application.yml中添加nacos地址配置：

    1. spring:
    2.   cloud:
    3.     nacos:
    4.       server-addr: 192.168.150.101

    3.4.3.发现并调用服务

    接下来，服务调用者cart-service就可以去订阅item-service服务了。不过item-service有多个实例，而真正发起调用时只需要知道一个实例的地址。

    因此，服务调用者必须利用负载均衡的算法，从多个实例中挑选一个去访问。常见的负载均衡算法有：

    • 随机
    • 轮询
    • IP的hash
    • 最近最少访问
    • ...

    这里我们可以选择最简单的随机负载均衡。

    另外，服务发现需要用到一个工具，DiscoveryClient，SpringCloud已经帮我们自动装配，我们可以直接注入使用：

    接下来，我们就可以对原来的远程调用做修改了，之前调用时我们需要写死服务提供者的IP和端口：

    但现在不需要了，我们通过DiscoveryClient发现服务实例列表，然后通过负载均衡算法，选择一个实例去调用：

    经过swagger测试，发现没有任何问题。

    4.OpenFeign

    在上一章，我们利用Nacos实现了服务的治理，利用RestTemplate实现了服务的远程调用。但是远程调用的代码太复杂了：

    而且这种调用方式，与原本的本地方法调用差异太大，编程时的体验也不统一，一会儿远程调用，一会儿本地调用。

    因此，我们必须想办法改变远程调用的开发模式，让远程调用像本地方法调用一样简单。而这就要用到OpenFeign组件了。

    其实远程调用的关键点就在于四个：

    • 请求方式
    • 请求路径
    • 请求参数
    • 返回值类型

    所以，OpenFeign就利用SpringMVC的相关注解来声明上述4个参数，然后基于动态代理帮我们生成远程调用的代码，而无需我们手动再编写，非常方便。

    接下来，我们就通过一个快速入门的案例来体验一下OpenFeign的便捷吧。

    4.1.快速入门

    我们还是以cart-service中的查询我的购物车为例。因此下面的操作都是在cart-service中进行。

    4.1.1.引入依赖

    在cart-service服务的pom.xml中引入OpenFeign的依赖和loadBalancer依赖：

    1.   <!--openFeign-->
    2.   <dependency>
    3.       <groupId>org.springframework.cloud</groupId>
    4.       <artifactId>spring-cloud-starter-openfeign</artifactId>
    5.   </dependency>
    6.   <!--负载均衡器-->
    7.   <dependency>
    8.       <groupId>org.springframework.cloud</groupId>
    9.       <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    10.   </dependency>

    4.1.2.启用OpenFeign

    接下来，我们在cart-service的CartApplication启动类上添加注解，启动OpenFeign功能：

    4.1.3.编写OpenFeign客户端

    在cart-service中，定义一个新的接口，编写Feign客户端：

    其中代码如下：

    1. package com.hmall.cart.client;
    2.  
    3. import com.hmall.cart.domain.dto.ItemDTO;
    4. import org.springframework.cloud.openfeign.FeignClient;
    5. import org.springframework.web.bind.annotation.GetMapping;
    6. import org.springframework.web.bind.annotation.RequestParam;
    7.  
    8. import java.util.List;
    9.  
    10. @FeignClient("item-service")
    11. public interface ItemClient {
    12.  
    13.     @GetMapping("/items")
    14.     List queryItemByIds(@RequestParam("ids") Collection<Long> ids);
    15. }

    这里只需要声明接口，无需实现方法。接口中的几个关键信息：

    • @FeignClient("item-service") ：声明服务名称
    • @GetMapping ：声明请求方式
    • @GetMapping("/items") ：声明请求路径
    • @RequestParam("ids") Collection ids ：声明请求参数
    • List ：返回值类型

    有了上述信息，OpenFeign就可以利用动态代理帮我们实现这个方法，并且向http://item-service/items发送一个GET请求，携带ids为请求参数，并自动将返回值处理为List。

    我们只需要直接调用这个方法，即可实现远程调用了。

    4.1.4.使用FeignClient

    最后，我们在cart-service的com.hmall.cart.service.impl.CartServiceImpl中改造代码，直接调用ItemClient的方法：

    feign替我们完成了服务拉取、负载均衡、发送http请求的所有工作，是不是看起来优雅多了。

    而且，这里我们不再需要RestTemplate了，还省去了RestTemplate的注册。

    4.2.连接池

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

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

    因此我们通常会使用带有连接池的客户端来代替默认的HttpURLConnection。比如，我们使用OK Http.

    4.2.1.引入依赖

    在cart-service的pom.xml中引入依赖：

    1. <!--OK http 的依赖 -->
    2. <dependency>
    3.   <groupId>io.github.openfeign</groupId>
    4.   <artifactId>feign-okhttp</artifactId>
    5. </dependency>

    4.2.2.开启连接池

    在cart-service的application.yml配置文件中开启Feign的连接池功能：

    1. feign:
    2.   okhttp:
    3.     enabled: true # 开启OKHttp功能

    重启服务，连接池就生效了。

    4.2.3.验证

    我们可以打断点验证连接池是否生效，在org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient中的execute方法中打断点：

    Debug方式启动cart-service，请求一次查询我的购物车方法，进入断点：

    可以发现这里底层的实现已经改为OkHttpClient

    4.3.最佳实践

    将来我们要把与下单有关的业务抽取为一个独立微服务:trade-service，不过我们先来看一下hm-service中原本与下单有关的业务逻辑。

    入口在com.hmall.controller.OrderController的createOrder方法，然后调用了IOrderService中的createOrder方法。

    由于下单时前端提交了商品id，为了计算订单总价，需要查询商品信息：

    也就是说，如果拆分了交易微服务（trade-service），它也需要远程调用item-service中的根据id批量查询商品功能。这个需求与cart-service中是一样的。

    因此，我们就需要在trade-service中再次定义ItemClient接口，这不是重复编码吗？ 有什么办法能加避免重复编码呢？

    4.3.1.思路分析

    相信大家都能想到，避免重复编码的办法就是抽取。不过这里有两种抽取思路：

    • 思路1：抽取到微服务之外的公共module
    • 思路2：每个微服务自己抽取一个module

    如图：

    方案1抽取更加简单，工程结构也比较清晰，但缺点是整个项目耦合度偏高。

    方案2抽取相对麻烦，工程结构相对更复杂，但服务之间耦合度降低。

    由于item-service已经创建好，无法继续拆分，因此这里我们采用方案1.

    4.3.2.抽取Feign客户端

    在hmall下定义一个新的module，命名为hm-api

    其依赖如下：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <parent>
    6.         <artifactId>hmall</artifactId>
    7.         <groupId>com.heima</groupId>
    8.         <version>1.0.0</version>
    9.     </parent>
    10.     <modelVersion>4.0.0</modelVersion>
    11.  
    12.     <artifactId>hm-api</artifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>11</maven.compiler.source>
    16.         <maven.compiler.target>11</maven.compiler.target>
    17.     </properties>
    18.  
    19.     <dependencies>
    20.         <!--open feign-->
    21.         <dependency>
    22.             <groupId>org.springframework.cloud</groupId>
    23.             <artifactId>spring-cloud-starter-openfeign</artifactId>
    24.         </dependency>
    25.         <!-- load balancer-->
    26.         <dependency>
    27.             <groupId>org.springframework.cloud</groupId>
    28.             <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    29.         </dependency>
    30.         <!-- swagger 注解依赖 -->
    31.         <dependency>
    32.             <groupId>io.swagger</groupId>
    33.             <artifactId>swagger-annotations</artifactId>
    34.             <version>1.6.6</version>
    35.             <scope>compile</scope>
    36.         </dependency>
    37.     </dependencies>
    38. </project>

    然后把ItemDTO和ItemClient都拷贝过来，最终结构如下：

    现在，任何微服务要调用item-service中的接口，只需要引入hm-api模块依赖即可，无需自己编写Feign客户端了。

    4.3.3.扫描包

    接下来，我们在cart-service的pom.xml中引入hm-api模块：

    1.   <!--feign模块-->
    2.   <dependency>
    3.       <groupId>com.heima</groupId>
    4.       <artifactId>hm-api</artifactId>
    5.       <version>1.0.0</version>
    6.   </dependency>

    删除cart-service中原来的ItemDTO和ItemClient，重启项目，发现报错了：

    这里因为ItemClient现在定义到了com.hmall.api.client包下，而cart-service的启动类定义在com.hmall.cart包下，扫描不到ItemClient，所以报错了。

    解决办法很简单，在cart-service的启动类上添加声明即可，两种方式：

    • 方式1：声明扫描包：

    • 方式2：声明要用的FeignClient

    4.4.日志配置

    OpenFeign只会在FeignClient所在包的日志级别为DEBUG时，才会输出日志。而且其日志级别有4级：

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

    Feign默认的日志级别就是NONE，所以默认我们看不到请求日志。

    4.4.1.定义日志级别

    在hm-api模块下新建一个配置类，定义Feign的日志级别：

    代码如下：

    1. package com.hmall.api.config;
    2.  
    3. import feign.Logger;
    4. import org.springframework.context.annotation.Bean;
    5.  
    6. public class DefaultFeignConfig {
    7.     @Bean
    8.     public Logger.Level feignLogLevel(){
    9.         return Logger.Level.FULL;
    10.     }
    11. }

    4.4.2.配置

    接下来，要让日志级别生效，还需要配置这个类。有两种方式：

    • 局部生效：在某个FeignClient中配置，只对当前FeignClient生效
    @FeignClient(value = "item-service", configuration = DefaultFeignConfig.class)
    • 全局生效：在@EnableFeignClients中配置，针对所有FeignClient生效。
    @EnableFeignClients(defaultConfiguration = DefaultFeignConfig.class)

    日志格式：

    1. 17:35:32:148 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] ---> GET http://item-service/items?ids=100000006163 HTTP/1.1
    2. 17:35:32:148 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] ---> END HTTP (0-byte body)
    3. 17:35:32:278 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] <--- HTTP/1.1 200  (127ms)
    4. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] connection: keep-alive
    5. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] content-type: application/json
    6. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] date: Fri, 26 May 2023 09:35:32 GMT
    7. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] keep-alive: timeout=60
    8. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] transfer-encoding: chunked
    9. 17:35:32:279 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] 
    10. 17:35:32:280 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] [{"id":100000006163,"name":"巴布豆(BOBDOG)柔薄悦动婴儿拉拉裤XXL码80片(15kg以上)","price":67100,"stock":10000,"image":"https://m.360buyimg.com/mobilecms/s720x720_jfs/t23998/350/2363990466/222391/a6e9581d/5b7cba5bN0c18fb4f.jpg!q70.jpg.webp","category":"拉拉裤","brand":"巴布豆","spec":"{}","sold":11,"commentCount":33343434,"isAD":false,"status":2}]
    11. 17:35:32:281 DEBUG 18620 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] <--- END HTTP (369-byte body)

    5.作业

    5.1.拆分微服务

    将hm-service中的其它业务也都拆分为微服务，包括：

    • user-service：用户微服务，包含用户登录、管理等功能
    • trade-service：交易微服务，包含订单相关功能
    • pay-service：支付微服务，包含支付相关功能

    其中交易服务、支付服务、用户服务中的业务都需要知道当前登录用户是谁，目前暂未实现，先将用户id写死。

    思考：如何才能在每个微服务中都拿到用户信息？如何在微服务之间传递用户信息？

    5.2.定义FeignClient

    在上述业务中，包含大量的微服务调用，将被调用的接口全部定义为FeignClient，将其与对应的DTO放在hm-api模块

    5.3.将微服务与前端联调

    课前资料提供了一个hmall-nginx目录，其中包含了Nginx以及我们的前端代码：

    将其拷贝到一个不包含中文、空格、特殊字符的目录，启动后即可访问到页面：

    • 18080是用户端页面
    • 18081是管理端页面

    之前nginx内部会将发向服务端请求全部代理到8080端口，但是现在拆分了N个微服务，8080不可用了。请通过Nginx配置，完成对不同微服务的反向代理。

    认真思考这种方式存在哪些问题，有什么好的解决方案？

    非常感谢您阅读到这里，创作不易！如果这篇文章对您有帮助，希望能留下您的点赞👍 关注💖 收藏 💕评论💬感谢支持！！！

    听说 三连能够给人 带来好运！更有可能年入百w，进入大厂，上岸

  • 相关阅读:
    性能测试-性能瓶颈定位思路（14）
    canal 服务安装
    分享一下微信公众号怎么实现积分商城功能
    神经网络（七）优化与正则化
    包含min函数栈
    031：vue子组件向父组件传递多个参数，父组件2种解析方法
    flutter 加密安全
    【Elasticsearch】结合Postman/ApiPost 快速入门
    axios——503响应超时重复多次请求——技能提升
    从程序员到架构师，如何才能快速成长？
  • 原文地址：https://blog.csdn.net/m0_67184231/article/details/133654370