Enseñarle cómo construir un proyecto SpringCloud (9) Integrar llamadas de interfaz de servicio OpenFeign

Continúe actualizando, ¡bienvenido a darle me gusta y seguir!

1. Introducción a OpenFeign

¿Qué es fingir?

    Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单。它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用支持负载均衡。

¿Qué puede hacer Fingir?

    Feign旨在使编写Java Http客户端变得更容易。前面在使用Ribbon+RestTemplate时，利用RestTemplate对http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发过程中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以,Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它，（以前是Dao接口上面标准Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可）即可完成对服务提供方的接口绑定，简化了Spring  Cloud Ribbon时，自动封装服务调用客户端的开发量。

    **Feign集成了Ribbon，利用Ribbon维护了Payment的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign值需要定义服务绑定接口且一声明式的方法，优雅而简单的实现了服务调用。**

La diferencia entre Fingir y OpenFeign

inserte la descripción de la imagen aquí

2. Openfeign implementa balanceo de carga

Cree un nuevo módulo llamado cloud-consumer-feign-order y modifique el archivo pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>mcroservice</artifactId>
        <groupId>com.study.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
 
    <artifactId>cloud-consumer-feign-order</artifactId>
    <description>订单消费者之feign</description>
 
    <dependencies>
        <!--openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--hystrix-->
        <!--eureka client-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.study.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 
</project>

Cree un nuevo archivo de configuración application.yml

server:
  port: 80
#eureka集群
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

Nueva clase de inicio principal

package com.buba.springcloud;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
 
@SpringBootApplication
@EnableFeignClients//激活Feign的注解  需要加到主启动类上
public class OrderFeignMain {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(OrderFeignMain.class,args);
    }
}

Crear una nueva clase de negocios es copiar la interfaz de negocios del servicio de nuestro productor y usarla directamente

package com.buba.springcloud.service;
 
import com.buba.springcloud.pojo.CommonResult;
 
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
 
 
@ComponentScan
@FeignClient(value ="mcroservice-payment")//使用Feign
public interface PaymentService {
    
    
    @GetMapping("/payment/get/{id}")
    public CommonResult queryById(@PathVariable("id") Long id);
  
}

Crear una nueva capa de control Controlador

package com.buba.springcloud.controller;
 
 
import com.buba.springcloud.pojo.CommonResult;
import com.buba.springcloud.pojo.Payment;
import com.buba.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@Slf4j
public class OrderFeignController {
    
    
    @Autowired
    private PaymentService paymentService;
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
    
    
        CommonResult result = paymentService.queryById(id);
        return result;
    }
   
}

Luego inicie eureka7001 y 7002 ahora, y luego inicie el servicio de servidor 8001 y 8002, primero pruebe usted mismo para ver si el inicio es exitoso. Inicie el servicio de productor 80 configurado con OpenFeign, acceda a la ruta http://localhost/consumer/payment/get/1y vea si hay una función de saldo de asignación.
inserte la descripción de la imagen aquí

En resumen, Openfeign es la interfaz de llamada de microservicio + la anotación @FeignClient, como se muestra a continuación:
inserte la descripción de la imagen aquí

3. Openfeign implementa control de tiempo de espera

Dado que nuestros servicios se dividen en productores y consumidores, cuando nuestro servicio al consumidor llama al servicio del productor, tarda mucho tiempo en responder y se agota el tiempo de conexión. Si no hay respuesta durante mucho tiempo, los resultados serán extremadamente deficientes. al usuario Experiencia, en este momento podemos configurar la implementación del tiempo de espera, por ejemplo, cuando nuestro servicio al consumidor llama al servicio del productor, podemos configurar que si no hay respuesta durante más de 2 segundos al acceder al servicio del productor, un aviso se le dará al usuario y se agotó el tiempo de conexión, visite más tarde. Tanto el servicio al productor como el servicio al consumidor deben establecer regulaciones.

Luego, el siguiente código demuestra la configuración del tiempo de espera, lo que facilita la comprensión y el aprendizaje intuitivo. Escribimos una interfaz para el servicio cuyo puerto productor es 8001, dejamos que el programa se detenga durante 3 segundos y establecemos deliberadamente el tiempo de espera para demostrar la situación de error, como se muestra en la siguiente figura:

//模拟业务接口延时3秒
@GetMapping("/payment/feign/timeout")
public String PaymentFeignTimeOut() throws InterruptedException {
    
    
     TimeUnit.SECONDS.sleep(3);
     return serverPort;
}

Agregue una interfaz de tiempo de espera en la capa comercial de servicio al consumidor, como se muestra en la siguiente figura:

package com.buba.springcloud.service;
 
import com.buba.springcloud.pojo.CommonResult;
 
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
 
 
@ComponentScan
@FeignClient(value ="mcroservice-payment")//使用Feign，使用哪个微服务
public interface PaymentService {
    
    
    //调用生产者微服务名称为mcroservice-payment下边的接口
    @GetMapping("/payment/get/{id}")
    public CommonResult queryById(@PathVariable("id") Long id);
    //调用生产者微服务名称为mcroservice-payment下边的模拟超时的接口
    @GetMapping("/payment/feign/timeout")
    public String PaymentFeignTimeOut() throws InterruptedException;
 
}

Agregue una interfaz de tiempo de espera en la capa de control de servicios del consumidor, como se muestra en la siguiente figura:

package com.buba.springcloud.controller;
 
 
import com.buba.springcloud.pojo.CommonResult;
import com.buba.springcloud.pojo.Payment;
import com.buba.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@Slf4j
public class OrderFeignController {
    
    
    @Autowired
    private PaymentService paymentService;
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
    
    
        CommonResult result = paymentService.queryById(id);
        return result;
    }
    @GetMapping("/consumer/feign/timeout")
    public String PaymentFeignTimeOut() throws InterruptedException{
    
    
        return paymentService.PaymentFeignTimeOut();
    }
}

Primero, realicemos una autoprueba del microservicio y la interfaz de acceso del productor cuyo puerto es 8001 http://localhost:8001/payment/feign/timeout, como se muestra en la siguiente figura:
inserte la descripción de la imagen aquí

Después de pasar la autocomprobación para acceder al servicio del consumidor, la interfaz es http://localhost/consumer/feign/timeout, y aparecerá la siguiente interfaz de error, indicándonos que se agotó el tiempo de espera del acceso a la interfaz.
inserte la descripción de la imagen aquí

El motivo es que Openfeign espera 1 segundo de forma predeterminada e informará un error después de que se exceda. Sin embargo, nuestro servicio de productor necesita procesar negocios complejos y el tiempo de procesamiento superará 1 segundo, por lo que debemos modificar el tiempo de espera predeterminado de Openfeign. Debe configurarse en el archivo yml del servicio al consumidor. Debido a que Fingir integra la cinta, debe configurar la cinta relacionada. Como se muestra abajo:

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
 
# 设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  # 指的是建立连接所用的时间,适用于网络状态正常的情况下,两端连接所用的时间，设置等待5000为5秒时间
  ReadTimeout: 5000
  # 指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000

Reiniciamos el servicio al consumidor y visitamos ttp://localhost/consumer/feign/timeout nuevamente, y aparecerá la siguiente interfaz de éxito:

inserte la descripción de la imagen aquí

4. Openfeign implementa la impresión de registros

Openfeign proporciona una función de impresión de registros. Por ejemplo, cuando nuestro servicio al consumidor llama al servicio del productor y llama a la interfaz, es posible que necesitemos información más detallada, como el encabezado de información, el código de estado, la hora, la interfaz, etc. Puede usar la función de impresión de registro de Openfeign y podemos ajustar el nivel de registro a través de la configuración para comprender los detalles de la solicitud Http en Feign. Eso es para monitorear y generar el estado de la llamada de la interfaz Fingir.

Hay cuatro tipos de registradores:

NINGUNO: De manera predeterminada, no se muestran registros.

BÁSICO: Solo registra el método de solicitud, URL, estado de respuesta y tiempo de ejecución.

ENCABEZADOS: Además de la información definida en BASIC, hay información sobre solicitudes y respuestas.

COMPLETO: Además de la información definida en BÁSICO, hay cuerpo de solicitud y respuesta y metadatos.

¡Establezca el nivel de registro registrando el bean!

Empezamos a configurar el log bean, creamos un nuevo archivo de configuración FeignConfig, recuerda agregar @Configuration

package com.buba.springcloud.config;
 
import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class FeignConfig
{
    
    
    /**
     * feignClient配置日志级别
     *
     * @return
     */
    @Bean
    public Logger.Level feignLoggerLevel() {
    
    
        // 请求和响应的头信息,请求和响应的正文及元数据
        return Logger.Level.FULL;
    }
}

En el archivo yml, debe abrir el cliente Fingir del registro y escribir el nombre de clase completamente calificado de la clase comercial PaymentService.

logging:
  level:
      # feign日志以什么级别监控哪个接口
    com.buba.springcloud.service.PaymentService: debug

Reinicie el servicio del consumidor, acceda a la interfaz y observe la información de registro impresa en la consola.
inserte la descripción de la imagen aquí

OpenFeign ha aprendido aquí, ¡es tan fácil!

inserte la descripción de la imagen aquí

En el próximo artículo, ¡continuemos con Hystrix y sigamos animando al pato!