Vous apprendre à construire un projet SpringCloud (9) Intégrer les appels d'interface de service OpenFeign

Continuez à mettre à jour, bienvenue à aimer et à suivre!

1. Introduction à OpenFeign

C'est quoi Feindre ?

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

Que peut faire Feign ?

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

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

La différence entre Feign et OpenFeign

insérez la description de l'image ici

2. Openfeign implémente l'équilibrage de charge

Créez un nouveau module nommé cloud-consumer-feign-order et modifiez le fichier 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>

Créer un nouveau fichier de configuration 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

Nouvelle classe de démarrage principale

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

Créer une nouvelle classe métier c'est copier l'interface métier du service de notre producteur et l'utiliser directement

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

Créer un nouveau contrôleur de couche de contrôle

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

Ensuite, démarrez eureka7001 et 7002 maintenant, puis démarrez le service serveur 8001 et 8002, testez-vous d'abord pour voir si le démarrage est réussi. Démarrez le service producteur 80 configuré avec OpenFeign, accédez au chemin http://localhost/consumer/payment/get/1, et voyez s'il existe une fonction d'équilibrage des affectations.
insérez la description de l'image ici

Pour résumer, Openfeign est l'interface d'appel du microservice + l'annotation @FeignClient, comme indiqué ci-dessous :
insérez la description de l'image ici

3. Openfeign implémente le contrôle du délai d'attente

Étant donné que nos services sont divisés en producteurs et consommateurs, lorsque notre service consommateur appelle le service producteur, il faut beaucoup de temps pour répondre et le délai de connexion se produira. S'il n'y a pas de réponse pendant une longue période, cela entraînera des résultats extrêmement mauvais. à l'utilisateur. Expérience, à ce moment, nous pouvons définir la mise en œuvre du délai d'attente. Par exemple, lorsque notre service client appelle le service producteur, nous pouvons définir que s'il n'y a pas de réponse pendant plus de 2 secondes lors de l'accès au service producteur, une invite sera donnée à l'utilisateur. La connexion a expiré, veuillez visiter plus tard. Tant le service producteur que le service consommateur doivent établir des réglementations.

Ensuite, le code suivant illustre le paramètre de délai d'attente, ce qui facilite la compréhension et l'apprentissage intuitif. Nous écrivons une interface pour le service dont le port producteur est 8001, laissons le programme s'arrêter pendant 3 secondes et définissons délibérément le délai d'attente pour illustrer la situation d'erreur, comme illustré dans la figure suivante :

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

Ajoutez une interface de délai d'attente dans la couche métier du service client, comme illustré dans la figure ci-dessous :

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

Ajoutez une interface de délai d'attente au niveau de la couche de contrôle du service client, comme illustré dans la figure ci-dessous :

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

Commençons par auto-tester le microservice et l'interface d'accès du producteur dont le port est 8001 http://localhost:8001/payment/feign/timeout, comme le montre la figure ci-dessous :
insérez la description de l'image ici

Après avoir passé l'auto-test pour accéder au service du consommateur, l'interface est http://localhost/consumer/feign/timeout, et l'interface d'erreur suivante apparaîtra, nous indiquant que l'accès à l'interface a expiré.
insérez la description de l'image ici

La raison en est qu'Openfeign attend 1 seconde par défaut et signalera une erreur après le dépassement. Cependant, notre service producteur doit traiter des affaires complexes, et le temps de traitement dépassera 1 seconde, nous devons donc modifier le temps d'attente par défaut d'Openfeign. Il doit être défini dans le fichier yml du service consommateur. Étant donné que Feign intègre le ruban, vous devez définir le ruban associé. Comme indiqué ci-dessous:

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

Nous redémarrons le service client et visitons à nouveau ttp://localhost/consumer/feign/timeout, et l'interface de réussite suivante apparaît :

insérez la description de l'image ici

4. Openfeign implémente l'impression de journaux

Openfeign fournit une fonction d'impression de journal. Par exemple, lorsque notre service consommateur appelle le service producteur et appelle l'interface, nous pouvons avoir besoin d'informations plus détaillées, telles que l'en-tête d'information, le code d'état, l'heure, l'interface, etc. Vous pouvez utiliser la fonction d'impression de journal Openfeign, et nous pouvons ajuster le niveau de journal via la configuration pour comprendre les détails de la requête Http dans Feign. C'est pour surveiller et sortir l'état d'appel de l'interface Feign.

Il existe quatre types d'enregistreurs :

AUCUN : par défaut, aucun journal n'est affiché.

BASIC : enregistrez uniquement la méthode de requête, l'URL, l'état de la réponse et l'heure d'exécution.

HEADERS : En plus des informations définies en BASIC, il existe des informations sur les demandes et les réponses.

FULL : en plus des informations définies dans BASIC, il existe des corps et des métadonnées de requête et de réponse.

Définissez le niveau de journalisation en enregistrant le bean !

Commencer à configurer le bean log, on crée un nouveau fichier de configuration FeignConfig, n'oubliez pas d'ajouter @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;
    }
}

Dans le fichier yml, vous devez ouvrir le client Feign du journal et écrire le nom de classe complet de la classe métier PaymentService

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

Redémarrez le service client, accédez à l'interface et consultez les informations de journal imprimées sur la console.
insérez la description de l'image ici

OpenFeign a appris ici, c'est si facile !

insérez la description de l'image ici

Dans le prochain article, continuons Hystrix et continuons à encourager le canard !