SpringCloudRibbon与OpenFeign详解如何实现服务调用

第SpringCloudRibbon与OpenFeign详解如何实现服务调用目录Ribbon初识RibbonRibbon是什么Ribbon能干什么使用Ribbon实现负载均衡RestTemplate三步走负载均衡算法轮询算法OpenFeign初识OpenFeign什么是OpenFeign如何使用OpenFeignOpenFeign超时控制OpenFeign日志打印

Ribbon

初识Ribbon

Ribbon是什么

Ribbon是Netflix发布的开源项目，主要功能是提供对客户端进行负载均衡算法的一套工具，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出LoadBalancer（简称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:2025/7/17

@Configuration

publicclassApplicationContextConfig{

@Bean

@LoadBalanced

publicRestTemplategetRestTemplate(){

returnnewRestTemplate();

}

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

@RestController

@Slf4j

@RequestMapping("consumer")

@Api("消费者的订单管理类")

publicclassOrderController{

//先注入RestTemplate对象

@Resource

privateRestTemplaterestTemplate;

//使用API实现负载均衡

@ApiOperation(value="创建一条支付记录",tags=ApiVersionConstant.v1_0)

@PostMapping(value="/payment/create",produces={"application/json;charset=UTF-8"})

publicCommonResultIntegercreate(@RequestBodyPaymentpayment){

returnrestTemplate.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"})

publicCommonResultPaymentgetPayment(@PathVariable("id")Integerid){

returnrestTemplate.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"})

publicCommonResultPaymentgetPaymentEntity(@PathVariable("id")Integerid){

ResponseEntityCommonResultentity=restTemplate.getForEntity(UrlConstant.CLUSTER_PAYMENT_URL+"/payment/get/"+id,CommonResult.class);

if(entity.getStatusCode().is2xxSuccessful()){

returnentity.getBody();

}else{

returnnewCommonResult(444,"操作失败");

@ApiOperation(value="创建一条支付记录Entity",tags=ApiVersionConstant.v1_0)

@PostMapping(value="/payment/createEntity",produces={"application/json;charset=UTF-8"})

publicCommonResultIntegercreateEntity(@RequestBodyPaymentpayment){

returnrestTemplate.postForEntity(UrlConstant.CLUSTER_PAYMENT_URL+"/payment/create",payment,CommonResult.class)

.getBody();

}

负载均衡算法

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

IRule实现算法切换

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

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

@Configuration

publicclassMySelfRule{

@Bean

publicIRulemyRule(){

//修改轮询算法为随机算法

returnnewRandomRule();

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

@SpringBootApplication

@EnableEurekaClient

@RibbonClient(name="CLOUD-PAYMENT-SERVICE",configuration=MySelfRule.class)

publicclassOrderMain80{

publicstaticvoidmain(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

groupIdorg.springframework.cloud/groupId

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

publicclassOrderFeignMain80{

publicstaticvoidmain(String[]args){

SpringApplication.run(OrderFeignMain80.class,args);

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

@Component

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

publicinterfacePaymentFeignService{

@GetMapping(value="/payment/get/{id}",produces={"application/json;charset=UTF-8"})

CommonResultPaymentgetPaymentById(@PathVariable("id")Integerid);

第五步：controller层调用service接口

@RestController

@RequestMapping("consumer")

publicclassOrderFeignController{

@Autowired

privatePaymentFeignServicepaymentFeignService;

@GetMapping(value="/payment/get/{id}",produces={"application/json;charset=UTF-8"})

publicCommonResultPaymentgetPaymentById(@PathVariable("id")Integerid){

returnpaymentFeignService.getPaymentById(id);

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

OpenFeign超时控制

使用OpenFeign调用服务接口，默认等待时间为1秒，超时就会直接报