Baidu Daniel ensina como integrar springboot para integrar chamadas de serviço cruzado fingidas do zero

Este artigo apresenta principalmente o método de aprendizagem do springboot para integrar chamadas de serviço cruzado fingidas do zero. Este artigo apresenta a você em detalhes, o que tem um certo valor de referência para o estudo ou trabalho de todos. Amigos que precisam podem consultar

No mundo da Internet, onde os microsserviços são crescentes, as chamadas entre serviços parecem muito comuns. Além de usar chamadas de interface http tradicionais, existe um método mais elegante e conveniente?

A resposta é sim, fingir fornece um caminho leve!

Se os seus serviços estiverem cadastrados em um cartório, como o nacos, então a ligação será muito fácil, basta fazer uma anotação, trazer o nome do serviço que precisa ser chamado, e feign + nacos vai te ajudar com o resto.

Se não houver centro de registro, não há necessidade de se preocupar, fingir pode usar o tradicional

ip: porta

Que jeito de ligar ~

A seguir, vamos praticar

Springboot integra fingir para
introduzir dependências. Observe aqui que spring-cloud.version deve corresponder à versão spring-boot. Minha versão spring-boot é 2.1.3, então spring-cloud escolhe a versão Greenwich.SR2.

A correspondência aproximada da versão é a seguinte

Para mais detalhes, acesse 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>

Em seguida, vamos para a classe de inicialização do projeto e adicionamos uma anotação

Finalmente, adicione a configuração Feign

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完成, 接下来我们编写测试代码

Código de teste
dois serviços

• sb-alibaba-nacos (serviço callee, 127.0.0.1:8081), fornece interface getInfoById
• sb-feign (serviço do chamador, 127.0.0.1:9999), fornece interface de teste getInfoById
• Interface de teste fornecida por sb-alibaba-nacos

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

Para o código relacionado ao sb-feign,
criamos um novo feign de pacote para colocar todas as classes que envolvem chamadas de serviço cruzado

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

`}`

`};`

`}`

`}`

`}`

O código-chave é

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

• name é o nome do serviço do receptor (se você não configurou o registro do serviço, pode escrevê-lo casualmente)
• url é o endereço do receptor (se o centro de registro de serviço estiver configurado, ele pode ser omitido !, mas ambos os serviços devem ser registrados !, para que você possa encontrá-lo!)
• fallbackFactory é a classe de processamento especificada quando a chamada falha.
  Por fim, escrevemos um método de teste

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

Abra dois serviços sb-alibaba-nacos, sb-feign

Em seguida, visite o método de teste do sb-feign

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

aparecer

sb-alibaba-nacos return :22

Chamada de serviço cruzado bem-sucedida ~

Até agora, este artigo sobre como aprender springboot para integrar chamadas de serviço cruzado fingidas do zero foi apresentado. Para mais integração do springboot relacionado a chamadas de serviço cruzado, siga o editor ou adicione QQ1411943564 para receber