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

叁歲伎倆 2023-09-25 14:17 44阅读 0赞

#### 目录 ####

*  前言
 *  1. RestTemplate
 *   *  1. 导入依赖
     *  2. 代码
     *  3. 常用方法
 *  2. jodd-http
 *   *  1. 引入依赖
     *  2. 代码
     *  3. 测试
 *  3. Feign
 *   *  1. 引入依赖
     *  2. 使用过程
     *  3. 自定义配置
     *  4. 优化

--------------------

## 前言 ##

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

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

*  先创建一个springboot项目，然后删掉不必要的文件，如下图：  
    ![3c4f8bb4973746de9384e37933a7a1fc.png][]
 *  然后创建子项目，新建模块，选择 maven 工程  
    ![4792ecfd548041b9ade4da151492c74e.png][]![e4b1e94129ae4d11a4cc64f45f58fa29.png][]![0a4613ac29a14a6f8b62ae41e0f69bef.png][]

**注意：**

* 父工程中已经导入的依赖，子工程会集成，无需再次导入
 * 父工程可以用 *<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>
 
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>${spring.cloud-version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 
 <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. RestTemplate ##

前期准备：

*  搭建好工程：  
    ![c266198063ca4338845b9d51530e137b.png][]  
    *remote\_service* 是模拟远程服务的一个模块，其 *controller* 代码如下：
    
        @RequestMapping("/remote")
        @RestController
        public class RemoteController {
              
            @GetMapping("/{name}")
            public String sayHello(@PathVariable("name") String name) {
              
                return name.toUpperCase() + " 发起了请求，并请求成功";
            }
        }

### 1. 导入依赖 ###

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

### 2. 代码 ###

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

@Bean
        public RestTemplate restTemplate() {
        
            return new RestTemplate();
        }

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

**测试：** 请求成功。  
![626dbcfca13545cf81f1faa57dd04bf3.png][]  
![15c9af0573f44e8893ffbdc5aa773416.png][]

### 3. 常用方法 ###

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

<table> 
 <thead> 
 <tr> 
 <th align="left">方法</th> 
 <th align="left">请求</th> 
 <th align="left">说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">getForEntity</td> 
 <td align="left">GET</td> 
 <td align="left">常用：public &lt;T&gt; ResponseEntity&lt;T&gt; getForEntity(地址, 返回类型)</td> 
 </tr> 
 <tr> 
 <td align="left">getForObject</td> 
 <td align="left">GET</td> 
 <td align="left">常用：public &lt;T&gt; T getForObject(地址, 返回类型) 对getForEntity函数的进一步封装，只关注返回的消息体的内容，对其他信息都不关注</td> 
 </tr> 
 <tr> 
 <td align="left">postForEntity</td> 
 <td align="left">POST</td> 
 <td align="left">常用：public &lt;T&gt; ResponseEntity&lt;T&gt; postForEntity(地址, 上传的参数(可为空)，返回类型)</td> 
 </tr> 
 <tr> 
 <td align="left">postForObject</td> 
 <td align="left">POST</td> 
 <td align="left">常用：public &lt;T&gt; ResponseEntity&lt;T&gt; postForObject(地址, 上传的参数(可为空)，返回类型) 对postForEntity函数的进一步封装，只关注返回的消息体的内容，对其他信息都不关注</td> 
 </tr> 
 <tr> 
 <td align="left">postForLocation</td> 
 <td align="left">POST</td> 
 <td align="left">常用：public URI postForLocation(地址, 上传的参数(可为空)) 返回新资源所在的 url</td> 
 </tr> 
 <tr> 
 <td align="left">put</td> 
 <td align="left">PUT</td> 
 <td align="left">常用：public void put(地址, 上传的参数(可为空))</td> 
 </tr> 
 <tr> 
 <td align="left">delete</td> 
 <td align="left">DELETE</td> 
 <td align="left">常用：public void delete(地址, 上传的参数)</td> 
 </tr> 
 </tbody> 
</table>

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

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

## 2. jodd-http ##

### 1. 引入依赖 ###

需要导入两个依赖：

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

<dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>fastjson</artifactId>
 <version>1.2.83</version>
 </dependency>
 
 <dependency>
 <groupId>org.jodd</groupId>
 <artifactId>jodd-http</artifactId>
 <version>3.7.1</version>
 </dependency>

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

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

### 3. 测试 ###

![41bcdddc850d4703806b6ff3f6c3fbcf.png][] ![ae1ba70dc9c046a59737d7ec9894f97d.png][]

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

## 3. Feign ##

Feign是一个声明式的http客户端：点击图片跳转。  
[![6a2e0451ddef46aeb71536cf463c3556.png][]][6a2e0451ddef46aeb71536cf463c3556.png 1]

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

### 1. 引入依赖 ###

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

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

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2021.0.5</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>

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

>  *  springboot 与 springcloud 的版本对应关系  
>     *点击图片跳转*  
>     [![e8261922dc0e49dab27192cd837d6528.png][]][e8261922dc0e49dab27192cd837d6528.png 1][![33ebab6ac67d44f4844173a55bdc9809.png][] ][33ebab6ac67d44f4844173a55bdc9809.png_]

然后导入 *Feign* 依赖：

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
 <version>3.1.2</version>
 </dependency>

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

**解决方案：** [https://blog.csdn.net/qq\_43788878/article/details/115764008][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);
        }
    
    这个客户端主要是基于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;
            }
        }

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

### 3. 自定义配置 ###

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

<table> 
 <thead> 
 <tr> 
 <th align="left">类型</th> 
 <th align="left">作用</th> 
 <th align="left">说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">feign.Logger.Level</td> 
 <td align="left">修改日志级别</td> 
 <td align="left">包含四种不同的级别：NONE、BASIC、HEADERS、FULL</td> 
 </tr> 
 <tr> 
 <td align="left">feign.codec.Decoder</td> 
 <td align="left">响应结果的解析器</td> 
 <td align="left">http远程调用的结果做解析，例如解析json字符串为java对象</td> 
 </tr> 
 <tr> 
 <td align="left">feign.codec.Encoder</td> 
 <td align="left">请求参数编码</td> 
 <td align="left">将请求参数编码，便于通过http请求发送</td> 
 </tr> 
 <tr> 
 <td align="left">feign. Contract</td> 
 <td align="left">支持的注解格式</td> 
 <td align="left">默认是SpringMVC的注解</td> 
 </tr> 
 <tr> 
 <td align="left">feign. Retryer</td> 
 <td align="left">失败重试机制</td> 
 <td align="left">请求失败的重试机制，默认是没有，不过会使用Ribbon的重试</td> 
 </tr> 
 </tbody> 
</table>

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

**自定义配置的方法：**

*  方法一：修改配置文件
    
        feign:  
          client:
            config: 
              remote: # 针对某个微服务的配置，这里也可以使用 default（全局配置），针对所有微服务
                loggerLevel: FULL #  日志级别
    
    > 日志的四种级别：
    > 
    >  *  NONE：不记录任何日志信息，这是默认值
    >  *  BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
    >  *  HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
    >  *  FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据
 *  方式二：Java代码  
    先声明一个类，然后声明一个Logger.Level的对象
    
        public class DefaultFeignConfiguration  {
              
            @Bean
            public Logger.Level feignLogLevel(){
              
                return Logger.Level.FULL; // 日志级别为BASIC
            }
        }
    
    **启动类添加注解（全局配置，针对所有微服务）：**
    
        @EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)
    
    **添加到自定义 *FeignClient* 接口中（针对某一微服务）：**
    
        @FeignClient(value = "remote", configuration = DefaultFeignConfiguration .class)

### 4. 优化 ###

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

**优化演示：**

* 引入 *feign-httpclient* 依赖（带连接池的客户端）
 
 <dependency>
 <groupId>io.github.openfeign</groupId>
 <artifactId>feign-httpclient</artifactId>
 </dependency>
 * 配置连接池和日志
 
 feign:
 client:
 config:
 default: # default全局的配置
 loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
 httpclient:
 enabled: true # 开启feign对HttpClient的支持
 max-connections: 200 # 最大的连接数
 max-connections-per-route: 50 # 每个路径的最大连接数

[3c4f8bb4973746de9384e37933a7a1fc.png]: https://img-blog.csdnimg.cn/3c4f8bb4973746de9384e37933a7a1fc.png
[4792ecfd548041b9ade4da151492c74e.png]: https://img-blog.csdnimg.cn/4792ecfd548041b9ade4da151492c74e.png
[e4b1e94129ae4d11a4cc64f45f58fa29.png]: https://img-blog.csdnimg.cn/e4b1e94129ae4d11a4cc64f45f58fa29.png
[0a4613ac29a14a6f8b62ae41e0f69bef.png]: https://img-blog.csdnimg.cn/0a4613ac29a14a6f8b62ae41e0f69bef.png
[c266198063ca4338845b9d51530e137b.png]: https://img-blog.csdnimg.cn/c266198063ca4338845b9d51530e137b.png
[626dbcfca13545cf81f1faa57dd04bf3.png]: https://img-blog.csdnimg.cn/626dbcfca13545cf81f1faa57dd04bf3.png
[15c9af0573f44e8893ffbdc5aa773416.png]: https://img-blog.csdnimg.cn/15c9af0573f44e8893ffbdc5aa773416.png
[41bcdddc850d4703806b6ff3f6c3fbcf.png]: https://img-blog.csdnimg.cn/41bcdddc850d4703806b6ff3f6c3fbcf.png
[ae1ba70dc9c046a59737d7ec9894f97d.png]: https://img-blog.csdnimg.cn/ae1ba70dc9c046a59737d7ec9894f97d.png
[Link 1]: https://blog.csdn.net/m0_54355172/article/details/126028044
[6a2e0451ddef46aeb71536cf463c3556.png]: https://img-blog.csdnimg.cn/6a2e0451ddef46aeb71536cf463c3556.png
[6a2e0451ddef46aeb71536cf463c3556.png 1]: https://github.com/OpenFeign/feign
[Link 2]: https://blog.csdn.net/m0_54355172/article/details/128296757
[e8261922dc0e49dab27192cd837d6528.png]: https://img-blog.csdnimg.cn/e8261922dc0e49dab27192cd837d6528.png
[e8261922dc0e49dab27192cd837d6528.png 1]: https://spring.io/projects/spring-cloud#overview
[33ebab6ac67d44f4844173a55bdc9809.png]: https://img-blog.csdnimg.cn/33ebab6ac67d44f4844173a55bdc9809.png
[33ebab6ac67d44f4844173a55bdc9809.png_]: https://spring.io/projects/spring-cloud#learn
[https_blog.csdn.net_qq_43788878_article_details_115764008]: https://blog.csdn.net/qq_43788878/article/details/115764008