微服务（三）——远程调用_微服务远程调用

---

前言

微服务都是独立部署的，要实现一个业务可能需要多个服务之间的通信，所以远程调用必不可少，本文将提供三种远程调用的方案：jodd-http、RestTemplate、Feign。

在此说一下 springboot父子 工程的搭建流程：

• 先创建一个springboot项目，然后删掉不必要的文件，如下图：
  

• 然后创建子项目，新建模块，选择 maven 工程
  

注意：

• 父工程中已经导入的依赖，子工程会集成，无需再次导入
• 父工程可以用 <dependencyManagement> 来进行依赖版本管理，如下：
  当父工程规定好 spring-cloud 的版本号之后，子工程引入该依赖或其旗下依赖，都会根据父工程的版本号来引入

      <properties>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
          <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
          <java.version>1.8</java.version>
          <spring.cloud-version>2021.0.5</spring.cloud-version>
      </properties>
  
      <dependencyManagement>
          <dependencies>
              <!--spring-cloud-->
              <dependency>
                  <groupId>org.springframework.cloud</groupId>
                  <artifactId>spring-cloud-dependencies</artifactId>
                  <version>${spring.cloud-version}</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
              <!--spring-cloud-alibaba-->
              <dependency>
                  <groupId>com.alibaba.cloud</groupId>
                  <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                  <version>2.2.6.RELEASE</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
          </dependencies>
      </dependencyManagement>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27

---

1. RestTemplate

前期准备：

• 搭建好工程：
  
  remote_service 是模拟远程服务的一个模块，其 controller 代码如下：

  @RequestMapping("/remote")
  @RestController
  public class RemoteController {
      @GetMapping("/{name}")
      public String sayHello(@PathVariable("name") String name) {
          return name.toUpperCase() + " 发起了请求，并请求成功";
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8

1. 导入依赖

RestTemplate 是spring自带的远程调用工具，所以只要有 spring 的依赖，都可以直接使用（随便导入一个 spring-boot-dependencies 或者 spring-boot-starter-web 都行）。

2. 代码

在使用 RestTemplate 之前，需要先在容器中注册。将下述代码写在一个配置类（@Configuration）中，或者直接写在 启动类（main）中都可以。

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
1
2
3
4

controller 代码：

@RequestMapping("/rest")
@org.springframework.web.bind.annotation.RestController
public class RestController {
    private static final String NAME = "rest_template";

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    public String sayHello() {
        String url = "http://127.0.0.1:8088/remote/" + NAME;
        String msg = restTemplate.getForObject(url, String.class);
        return msg;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试： 请求成功。

3. 常用方法

RestTemplate 的使用比较简单，这里再简单说一下它的常用方法：

在这里补充一下 Restful 的 HTTP动词 ：

• GET（SELECT）：从服务器取出资源（一项或多项）
• POST（CREATE）：在服务器新建一个资源
• PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）
• PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）
• DELETE（DELETE）：从服务器删除资源

2. jodd-http

1. 引入依赖

需要导入两个依赖：

• fastjson：用于 json 数据 与 接收类型 的转化
• jodd-http：用于发起 http 请求

        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
        <!-- jodd-http -->
        <dependency>
            <groupId>org.jodd</groupId>
            <artifactId>jodd-http</artifactId>
            <version>3.7.1</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12

2. 代码

工具类：

import com.alibaba.fastjson.JSONObject;
import jodd.http.HttpRequest;
import jodd.http.HttpResponse;

import java.nio.charset.StandardCharsets;
import java.util.Map;

public class HttpUtil {

    public static String post(String url, Map<String, Object> map) {
        HttpResponse res = HttpRequest.post(url).connectionTimeout(90000).timeout(90000)
                .contentType("application/json", "UTF-8")
                .bodyText(JSONObject.toJSONString(map), "application/json", "UTF-8")
                .send();
        res.charset("utf-8");
        return res.bodyText();
    }

    public static String post(String url, String jsonStr) {
        HttpResponse resp = HttpRequest.post(url).connectionTimeout(60000).timeout(60000)
                .contentType("application/json", StandardCharsets.UTF_8.toString())
                .bodyText(jsonStr ,"application/json", "UTF-8")
                .send();
        resp.charset(StandardCharsets.UTF_8.toString());
        return resp.bodyText();
    }

    public static String get(String url, Map<String, String> params) {
        HttpRequest request = HttpRequest.get(url);
        if (params != null) {
            request.query(params);
        }
        HttpResponse response = request.send();
        return response.bodyText();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Controller：

@RequestMapping("/jodd")
@RestController
public class JoddController {
    private static final String NAME = "jodd_http";

    @GetMapping
    public String sayHello() {
        String url = "http://127.0.0.1:8088/remote/" + NAME;
        String msg = HttpUtil.get(url, new HashMap<>());
        return msg;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

3. 测试

注意： 这个我在之前的文章中讲过，点击跳转 ，这里就不再多说。

3. Feign

Feign是一个声明式的http客户端：点击图片跳转。

鉴于前面的两种方法，对于参数复杂URL难以维护，所以建议使用 Feign 。

1. 引入依赖

Feign 是基于 springcloud 来发起远程请求的，需要与 nacos 等注册中心搭配使用，点击跳转注册中心文章。

要引入 Feign 依赖，就需要先引入 springcloud 的依赖：

        <!--spring-cloud-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
1
2
3
4
5
6
7
8

注意： 引入 springcloud 依赖的时候，需要注意 springboot 的版本。

• springboot 与 springcloud 的版本对应关系
  点击图片跳转
  

然后导入 Feign 依赖：

        <!--Feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>3.1.2</version>
        </dependency>
1
2
3
4
5
6

注意： 启动项目报错： No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-loadbalancer?

解决方案： https://blog.csdn.net/qq_43788878/article/details/115764008

2. 使用过程

1. 在启动类上添加一个 @EnableFeignClients

2. 编写 Feign 接口

   @Component
   //@FeignClient:微服务客户端注解,value:指定微服务的名字,这样就可以使Feign客户端直接找到对应的微服务
   @FeignClient(value = "remote")
   public interface MyFeignClient {
   
       @GetMapping("/remote/{name}")
       String sayHello(@PathVariable("name") String name);
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9

   这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：

   • 服务名称：remote
   • 请求方式：GET
   • 请求路径：/remote/{name}
   • 请求参数：String name
   • 返回值类型：String

   这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。

3. controller

   @RestController("/feign")
   public class FeignController {
       private static final String NAME = "feign";
   
       @Resource
       private MyFeignClient feignClient;
   
       @GetMapping
       public String sayHello() {
           String msg = feignClient.sayHello(NAME);
           return msg;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

以上就是 Feign 的使用步骤，因为懒得去搭建注册中心，所以就不测试了。

3. 自定义配置

Feign可以支持很多的自定义配置，如下表所示：

一般情况，直接使用默认配置就OK了。

自定义配置的方法：

• 方法一：修改配置文件

  feign:  
    client:
      config: 
        remote: # 针对某个微服务的配置，这里也可以使用 default（全局配置），针对所有微服务
          loggerLevel: FULL #  日志级别 
  1
  2
  3
  4
  5

  日志的四种级别：

  • NONE：不记录任何日志信息，这是默认值
  • BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
  • HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
  • FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据

• 方式二：Java代码
  先声明一个类，然后声明一个Logger.Level的对象

  public class DefaultFeignConfiguration  {
      @Bean
      public Logger.Level feignLogLevel(){
          return Logger.Level.FULL; // 日志级别为BASIC
      }
  }
  1
  2
  3
  4
  5
  6

  启动类添加注解（全局配置，针对所有微服务）：

  @EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)
  1

  添加到自定义 FeignClient 接口中（针对某一微服务）：

  @FeignClient(value = "remote", configuration = DefaultFeignConfiguration .class)
  1

4. 优化

• 日志级别尽量用basic
• 使用连接池，这是提高 Feign 性能的主要手段：
  Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

  • URLConnection：默认实现，不支持连接池

  • Apache HttpClient ：支持连接池

  • OKHttp：支持连接池

优化演示：

• 引入 feign-httpclient 依赖（带连接池的客户端）

  <dependency>
      <groupId>io.github.openfeign</groupId>
      <artifactId>feign-httpclient</artifactId>
  </dependency>
  1
  2
  3
  4

• 配置连接池和日志

  feign:
    client:
      config:
        default: # default全局的配置
          loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
    httpclient:
      enabled: true # 开启feign对HttpClient的支持
      max-connections: 200 # 最大的连接数
      max-connections-per-route: 50 # 每个路径的最大连接数
  1
  2
  3
  4
  5
  6
  7
  8
  9