[Java知识库]【spring cloud】(三)服务调用——Ribbon、OpenFeign

??各位小伙伴们大家好，欢迎来到这个小扎扎的spring cloud专栏，在这个系列专栏中我对B站尚硅谷阳哥的spring cloud教程进行一个总结，鉴于 看到就是学到、学到就是赚到 精神，这波依然是血赚 ┗|｀O′|┛

💡服务调用知识点速览

---

• 🍑 Ribbon
• • 🍏 初识Ribbon
  • • 🥭 Ribbon是什么？
    • 🥭 Ribbon能干什么？
  • 🍏 使用Ribbon实现负载均衡
  • • 🥭 RestTemplate三步走
    • 🥭 负载均衡算法
• 🍑 OpenFeign
• • 🍏 初识OpenFeign
  • • 🥭 什么是OpenFeign？
    • 🥭 如何使用OpenFeign？
  • 🍏 OpenFeign超时控制
  • 🍏 OpenFeign日志打印

🍑 Ribbon

🍏 初识Ribbon

🥭 Ribbon是什么？

??Ribbon是Netflix发布的开源项目，主要功能是提供对客户端进行负载均衡算法的一套工具，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随即连接等）去连接这些机器。我们也可以使用Ribbon实现自定义的负载均衡算法。

🥭 Ribbon能干什么？

??前面提到说Ribbon的作用就是向客户端提供负载均衡算法的工具，那么什么是负载均衡呢？负载均衡就是将用户发来的请求通过算法均摊到多个服务上，从而达到系统的HA(高可用性)

??其中，负载均衡又可分为本地负载均衡(进程内LB)和服务端负载均衡(集中式LB)，服务端负载均衡以Nginx为例，用户的所有请求都会交给Nginx，由其决定请求将被转发到哪个服务器；Ribbon是本地负载均衡，在调用接口的时候从 eureka 注册中心服务器端上获取服务注册信息列表缓存到本地，从而可以在本地实现RPC远程调用服务

🍏 使用Ribbon实现负载均衡

??实际上Ribbon可以简单的理解为负载均衡算法 + RestTemplate的调用，也就是说想要使用Ribbon实现负载均衡，就可以通过这两个技术加以实现。

🥭 RestTemplate三步走

??第一步： 引入Ribbon场景启动器依赖，但是之前使用eureka的时候我们在pom文件中导入过netflix-eureka-server的依赖，其中就默认引入了ribbon的场景启动器依赖（netflix-eureka-client也会默认导入），如果再引一次也可以，但是真没那必要。
??第二步： 使用配置文件开启 RestTemplate

/**
 * @ClassName: ApplicationContextConfig
 * @Description: 程序配置类，用于开启RestTemplate服务，以供后面使用
 * @author: chenhao
 * @date: 2022/7/17
 */
@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {

        return new RestTemplate();
    }
}

??第三步： 使用RestTemplate的API实现负载均衡，RestTemplate的API根据请求方式的不同可以被分为get和post，根据返回类型又可以分为Object(响应体转化成的json串)和Entity(响应的重要信息，包括响应头、状态码、响应体等，可以使用对应的get方法获取到值)，所以说最主要的四个API是getForObject、postForObject、getForEntity、postForEntity，这里我把四种API的使用方法都向大家介绍一下

@RestController
@Slf4j
@RequestMapping("consumer")
@Api("消费者的订单管理类")
public class OrderController {
	// 先注入RestTemplate对象
    @Resource
    private RestTemplate restTemplate;

	// 使用API实现负载均衡
    @ApiOperation(value = "创建一条支付记录", tags = ApiVersionConstant.v1_0)
    @PostMapping(value = "/payment/create", produces = {"application/json;charset=UTF-8"})
    public CommonResult<Integer> create(@RequestBody Payment payment) {
        return restTemplate.postForObject(UrlConstant.CLUSTER_PAYMENT_URL + "/payment/create", payment, CommonResult.class);
    }

    @ApiOperation(value = "根据ID查询支付记录", tags = ApiVersionConstant.v1_0)
    @GetMapping(value = "/payment/get/{id}", produces = {"application/json;charset=UTF-8"})
    public CommonResult<Payment> getPayment(@PathVariable("id") Integer id) {
        return restTemplate.getForObject(UrlConstant.CLUSTER_PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }

    @ApiOperation(value = "根据ID查询支付记录Entity", tags = ApiVersionConstant.v1_0)
    @GetMapping(value = "/payment/getForEntity/{id}", produces = {"application/json;charset=UTF-8"})
    public CommonResult<Payment> getPaymentEntity(@PathVariable("id") Integer id) {
        ResponseEntity<CommonResult> entity = restTemplate.getForEntity(UrlConstant.CLUSTER_PAYMENT_URL + "/payment/get/" + id, CommonResult.class);

        if (entity.getStatusCode().is2xxSuccessful()) {
            return entity.getBody();
        } else {
            return new CommonResult<>(444, "操作失败");
        }
    }
    
    @ApiOperation(value = "创建一条支付记录Entity", tags = ApiVersionConstant.v1_0)
    @PostMapping(value = "/payment/createEntity", produces = {"application/json;charset=UTF-8"})
    public CommonResult<Integer> createEntity(@RequestBody Payment payment) {
        return restTemplate.postForEntity(UrlConstant.CLUSTER_PAYMENT_URL + "/payment/create", payment, CommonResult.class)
                .getBody();
    }
}

🥭 负载均衡算法

??经过我们上面的尝试，不难发现使用RestTemplate实现的负载均衡算法是轮询机制，实际上IRule中不仅仅只提供了一种算法
IRule实现算法切换

??第一步： 新建一个package，在官方文档中声明了IRule的配置类不能放到@ComponentScan注解所能扫描到的当前包以及子包下，否则自定义的配置类就会被Ribbon的所有客户端所共享，以至于失去客户端定制化的可能性。主程序入口上的@SpringBootApplication注解是复合注解，其中就包含@ComponentScan注解，而且是直接扫描主程序入口所在的当前包以及子包，也就是说配置类必须放到主程序入口之外的包下，于是需要新建一个package

??第二步： 在新建的包中新建一个MySelfRule规则类，用于设置轮询算法，如果不设置的话就默认为轮询

@Configuration
public class MySelfRule {
    @Bean
    public IRule myRule() {
        // 修改轮询算法为随机算法
        return new RandomRule();
    }
}

??第三步： 主启动类上使用@RibbonClient(name = “CLOUD-PAYMENT-SERVICE”, configuration = MySelfRule.class)注解，用于指定应用服务和自定义算法规则的配置类

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

轮询算法

??所谓的轮询算法就是根据所有的服务，依次将请求均摊到所有的服务依次访问，它的算法实现就是用RestTemplate接收到的请求数量对服务器集群的数量进行取模运算，余数就是服务在服务列表中对应的索引位置，所以说可以实现轮询。但是如果中途服务器关掉的话接收到的请求数量就会从1重新计数

🍑 OpenFeign

🍏 初识OpenFeign

🥭 什么是OpenFeign？

??openFeign是要声明式的web服务客户端，或叫做声明式REST客户端，它让编写web服务客户端变得简单。它将提供者的restful服务伪装成接口进行消费，消费者只需要通过feign接口+注解就可以直接调用提供者的服务接口，也就是可以实现接口对接口的调用，而无需像ribbon一样通过restTemplate方式对提供者的服务进行调用

??值得注意的一点是，openFeign内置了负载均衡器-Ribbon，所以说openfeign也可以使用负载均衡算法

🥭 如何使用OpenFeign？

??第一步： 引入相关依赖

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

??第二步： 配置配置文件，只是基本配置和注册，没有OpenFeign独有的配置

server:
  port: 80


eureka:
  client:
    register-with-eureka: false
    service-url:
      #服务端的地址，服务端为集群版，向所有的模块都注册
      defaultZone: http://localhost:7001/eureka,
                   http://localhost:7002/eureka,
                   http://localhost:7003/eureka

??第三步： 主启动类开启OpenFeign客户端

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

??第四步： 之前使用ribbon是直接在controller里调用payment服务的controller，但是openfeign则是通过service调用，于是第三步就是创建一个service接口用于调用payment服务的接口

@Component
@FeignClient(value = "CLOUD-PAYMENT-SERVICE") // 用于指定服务名，可在eureka或者服务的配置文件中查看
public interface PaymentFeignService {

    @GetMapping(value = "/payment/get/{id}", produces = {"application/json;charset=UTF-8"})
    CommonResult<Payment> getPaymentById(@PathVariable("id") Integer id);
}

??第五步： controller层调用service接口

@RestController
@RequestMapping("consumer")
public class OrderFeignController {

    @Autowired
    private PaymentFeignService paymentFeignService;

    @GetMapping(value = "/payment/get/{id}", produces = {"application/json;charset=UTF-8"})
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Integer id) {
        return paymentFeignService.getPaymentById(id);
    }
}

??如此操作也可实现order服务对payment服务的调用，而且由于OpenFeign默认引入Ribbon，去进行order服务访问的时候，后端会默认轮询名为是“CLOUD-PAYMENT-SERVICE”的微服务，也就是两个payment服务

🍏 OpenFeign超时控制

??使用OpenFeign调用服务接口，默认等待时间为1秒，超时就会直接报错。如果有些服务的调用确实会花费超过1s的时间，就需要我们在服务调用方(也就是order服务)的配置文件中进行配置
??由于OpenFeign的超时控制由其底层的ribbon实现，于是配置文件中的超时控制也由ribbon进行配置

#设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  #指的是建立连接所用的时间，适用于网络状况正常的情况下, 两端连接所用的时间
  ReadTimeout: 5000
  #指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000

🍏 OpenFeign日志打印

??OpenFeign提供了日志打印的功能，我们可以通过日志的打印监控接口的调用情况，从而了解接口调用时HTTP请求的具体细节，具体的使用分
??第一步： 使用配置类配置日志级别

@Configuration
public class FeignConfig {
    /**
     * 日志级别
     * NONE：默认的，不显示任何日志
     * BASIC：仅记录请求方法、URL、响应状态码以及执行时间
     * HEADERS：请求方法、URL、响应状态码、执行时间、请求和响应的头信息
     * FULL：请求方法、URL、响应状态码、执行时间、请求和响应的头信息、正文以及元数据
     */
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

??第二步： 配置文件开启日志打印，并指定监控的接口和级别

logging:
  level:
    # feign日志以 debug 级别监控 com.atguigu.springcloud.service.PaymentFeignService 接口
    com.xiaochen.springcloud.service.PaymentFeignService: debug

打印出来的日志如下：