Baidu Daniel le enseña cómo integrar springboot para integrar llamadas fingidas entre servicios desde cero

Este artículo presenta principalmente el método de aprendizaje de springboot para integrar llamadas fingidas entre servicios desde cero. Este artículo lo presenta en muy detalle, lo que tiene un cierto valor de referencia para el estudio o el trabajo de todos. Los amigos que lo necesiten pueden consultar

En el mundo de Internet, donde los microservicios son rampantes, las llamadas entre servicios parecen muy comunes. Además de usar llamadas tradicionales de interfaz http, ¿existe un método más elegante y conveniente?

La respuesta es sí, ¡fingir proporciona una forma ligera!

Si sus servicios están registrados en un registro, como nacos, entonces la llamada será muy fácil, solo una anotación, traiga el nombre del servicio que necesita ser llamado y fingir + nacos lo ayudará a hacer el resto.

Si no hay un centro de registro, no hay necesidad de preocuparse, fingir puede utilizar el tradicional

ip: puerto

Manera de llamar ~

A continuación, practiquémoslo

Springboot integra fingir para
introducir dependencias. Tenga en cuenta aquí que spring-cloud.version debe coincidir con la versión spring-boot. Mi versión spring-boot es 2.1.3, por lo que spring-cloud elige la versión Greenwich.SR2.

La correspondencia de la versión aproximada es la siguiente

Para obtener más detalles, visite https://start.spring.io/actuator/info para
consultas.

<properties>
  <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
</properties>
 
<dependencyManagement>
  <dependencies>
   <!--SpringCloud依赖 -->
   <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>${
    
    spring-cloud.version}</version>
    <type>pom</type>
    <scope>import</scope>
   </dependency>
  </dependencies>
 </dependencyManagement>
 
 <dependencies>
  <!--openfeign跨服务调用-->
  <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>
  <!--openfeign底层使用ApacheHttpClient调用-->
  <dependency>
   <groupId>io.github.openfeign</groupId>
   <artifactId>feign-httpclient</artifactId>
  </dependency>
 </dependencies>

Luego vamos a la clase de inicio del proyecto y agregamos una anotación.

Finalmente, agregue la configuración de Fingir

server.port=9999
#******************openfeign配置，参数采用的是默认的配置，可根据实际情况调整***********************
#启用ApacheHttpClient。默认就是true，使用HttpClientConnectionManager管理连接复用
feign.httpclient.enabled=true
#连接池的最大连接数，默认200
feign.httpclient.max-connections=200
#每个路由(服务器)分配的组最大连接数，默认50
feign.httpclient.max-connections-per-route=50
#连接最大存活时间，默认900秒
feign.httpclient.time-to-live=900
#连接最大存活时间单位秒
feign.httpclient.time-to-live-unit=seconds
#FeignAcceptGzipEncodingInterceptor拦截器被激活，会在header中添加Accept-Encoding：gzip,deflate,表明服务端在返回值时可以使用如下两个方式压缩返回结果
feign.compression.response.enabled=true
#FeignContentGzipEncodingInterceptor拦截器被激活，会在header中添加Content-Encoding：gzip,deflate,表明body中的参数是使用这两个方式的压缩
feign.compression.request.enabled=true
#content-length大于2048就进行请求参数的gzip压缩
feign.compression.request.minRequestSize=2048
 
#开启断路器
feign.hystrix.enabled=true
#断路器的隔离策略，默认就是线程池，SEMAPHORE模式下，就是主线程调用的远程的服务，即同步的
hystrix.command.default.execution.isolation.strategy=THREAD
#断路器超时设置
hystrix.command.default.execution.timeout.enabled=true
#总体请求在45秒还是无法得到响应，建议触发熔断（ribbon每个请求读取15秒超时，两个实例重试就是30秒，openfeign外层默认会进行一次调用，4次重试）
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=45000
#断路器的线程池存在一个问题，在队列满了以后，不会再去创建新的线程直到maximumSize
#核心线程池大小
hystrix.threadpool.default.coreSize=10
#最大线程池大小
hystrix.threadpool.default.maximumSize=10
#超过这个空闲时间,多于coreSize数量的线程会被回收，1分钟
hystrix.threadpool.default.keepAliveTimeMinutes=1
#队列的大小，默认为-1，即没有队列
hystrix.threadpool.default.maxQueueSize=200
#队列任务达到此阈值后，就开始拒绝；实际使用此参数进行队列是否满的判断
hystrix.threadpool.default.queueSizeRejectionThreshold=180
 
#负载均衡配置
#读取超时15秒，与原RestTemplate保持一致
ribbon.ReadTimeout=15000
#连接超时15秒，与原RestTemplate保持一致
ribbon.ConnectTimeout=15000
##每台服务器最多重试次数，但是首次调用不包括在内
ribbon.MaxAutoRetries=0
##最多重试多少台服务器，与实际实例数保持一致（不包括首台）
ribbon.MaxAutoRetriesNextServer=1
#是否所有操作都重试,
# false：get请求中，连接超时，读取超时都会重试，其他请求(put,post)连接超时重试，读取超时不重试。
# true：get请求中，连接超时，读取超时都会重试，其他请求(put,post)连接超时重试，读取超时重试。
#对于请求(put,post)要做好接口的幂等性
ribbon.OkToRetryOnAllOperations=true
spring-boot整合feign完成, 接下来我们编写测试代码

Servicios de código de prueba
dos

• sb-alibaba-nacos (servicio de llamadas, 127.0.0.1:8081), proporciona la interfaz getInfoById
• sb-fingir (servicio de llamadas, 127.0.0.1:9999), proporciona la interfaz de prueba getInfoById
• Interfaz de prueba proporcionada por sb-alibaba-nacos

@GetMapping(value = "getInfoById")
 public String getInfoById(@RequestParam(value = "id") Long Id) {
    
    
  return "example-service return :" + Id;
 }

Para el código relacionado con sb-fingir,
creamos un nuevo paquete fingir para poner todas las clases que involucran llamadas entre servicios

ExampleControllerFeignClient.java:

`package` `com.mrcoder.sbfeign.feign;`

`import` `feign.hystrix.FallbackFactory;`

`import` `org.slf4j.Logger;`

`import` `org.slf4j.LoggerFactory;`

`import` `org.springframework.cloud.openfeign.FeignClient;`

`import` `org.springframework.stereotype.Component;`

`import` `org.springframework.web.bind.annotation.GetMapping;`

`import` `org.springframework.web.bind.annotation.RequestParam;`

`@FeignClient``(name =` `"sb-alibaba-nacos"``, url =` `"[http://127.0.0.1:8081/](http://127.0.0.1:8081/)"``, fallbackFactory = ExampleControllerFeignClient.ExampleControllerFeignClientFallbackFactory.``class``)`

`public` `interface` `ExampleControllerFeignClient {
    
    `

`@GetMapping``(value =` `"getInfoById"``)`

`String getInfoById(``@RequestParam``(value =` `"id"``) Long Id);`

`/**`

`* 服务降级内部类`

`*/`

`@Component`

`class` `ExampleControllerFeignClientFallbackFactory` `implements` `FallbackFactory<ExampleControllerFeignClient> {
    
    `

`private` `Logger logger = LoggerFactory.getLogger(ExampleControllerFeignClientFallbackFactory.``class``);`

`@Override`

`public` `ExampleControllerFeignClient create(Throwable cause) {
    
    `

`return` `new` `ExampleControllerFeignClient() {
    
    `

`@Override`

`public` `String getInfoById(Long signingLogId) {
    
    `

`logger.error(``"跨服务调用失败， 原因是:"` `+ cause.getMessage());`

`return` `"失败， 原因是:"` `+ cause.getMessage();`

`}`

`};`

`}`

`}`

`}`

El código clave es

`@FeignClient``(name =` `"sb-alibaba-nacos"``, url =` `"[http://127.0.0.1:8081/](http://127.0.0.1:8081/)"``, fallbackFactory = ExampleControllerFeignClient.ExampleControllerFeignClientFallbackFactory.``class``)`

• name es el nombre del servicio del destinatario de la llamada (si no ha configurado el registro del servicio, puede escribirlo casualmente)
• url es la dirección del destinatario (si el centro de registro del servicio está configurado, ¡se puede omitir !, ¡pero ambos servicios deben estar registrados !, ¡para que pueda encontrarlo!)
• fallbackFactory es la clase de procesamiento especificada cuando falla la llamada.
  Finalmente, escribimos un método de prueba

package com.mrcoder.sbfeign.controller;
 
import com.mrcoder.sbfeign.feign.ExampleControllerFeignClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
@CrossOrigin
@RestController
public class TestController {
    
    
 
 @Autowired
 private ExampleControllerFeignClient exampleControllerFeignClient;
 
 @RequestMapping(value = "getInfoById", method = RequestMethod.GET)
 public String test(@RequestParam(value = "id") Long Id) {
    
    
  return exampleControllerFeignClient.getInfoById(Id);
 }
}

Abrir dos servicios sb-alibaba-nacos, sb-feign

Entonces visite el método de prueba de sb-fingir

http: // localhost: 9999 / getInfoById? id = 22

aparecer

sb-alibaba-nacos return :22

Llamada exitosa entre servicios ~

Hasta ahora, se presenta este artículo sobre cómo aprender Springboot para integrar llamadas fingidas entre servicios desde cero. Para obtener más información relacionada con la integración de Springboot, fingir llamadas entre servicios, siga al editor o agregue QQ1411943564 para recibir