SpringBoot26 RestTemplate、WebClient

时间：2018-08-20 22:34:18 阅读：370 评论：0 收藏：0 [点我收藏+]

1 RestTemplate

　　RestTemplate是在客户端访问 Restful 服务的一个核心类；RestTemplate通过提供回调方法和允许配置信息转换器来实现个性化定制RestTemplate的功能，通过RestTemplate可以封装请求对象，也可以对响应对象进行解析。

技术分享图片

　　技巧01：RestTemplate默认使用JDK提供的包去建立HTTP连接，当然，开发者也可以使用诸如 Apache HttpComponents, Netty, and OkHttp 去建立HTTP连接。

　　技巧02：RestTemplate内部默认使用HttpMessageConverter来实现HTTTP messages 和 POJO 之间的转换，可以通过RestTemplate的成员方法 setMessageConverters(java.util.List<org.springframework.http.converter.HttpMessageConverter<?>>). 去修改默认的转换器。

　　技巧03：RestTemplate内部默认使用SimpleClientHttpRequestFactory and DefaultResponseErrorHandler 去创建HTTP连接和处理HTTP错误，可以通过HttpAccessor.setRequestFactory(org.springframework.http.client.ClientHttpRequestFactory) and setErrorHandler(org.springframework.web.client.ResponseErrorHandler)去做相应的修改。.

　　1.1 RestTemplate中方法概览

　　　　RestTemplate为每种HTTP请求都实现了相关的请求封装方法

　　　　技巧01：这些方法的命名是有讲究的，方法名的第一部分表示HTTP请求类型，方法名的第二部分表示响应类型

　　　　　　例如：getForObject 表示执行GET请求并将响应转化成一个Object类型的对象　　

　　　　技巧02：利用RestTemplate封装客户端发送HTTP请求时，如果出现异常就会抛出 RestClientException 类型的异常；可以通过在创建RestTemplate对象的时候指定一个ResponseErrorHandler类型的异常处理类来处理这个异常

　　　　技巧02：exchange 和 excute 这两个方法是通用的HTTP请求方法，而且这两个方法还支持额外的HTTP请求类型【PS: 前提是使用的HTTP连接包也支持这些额外的HTTP请求类型】

技术分享图片

　　　　技巧03：每种方法都有3个重载方法，其中两个接收String类型的请求路径和响应类型、参数；另外一个接收URI类型的请求路径和响应类型。

技术分享图片

　　　　技巧04：使用String类型的请求路径时，RestTemplate会自动进行一次编码，所以为了避免重复编码问题最好使用URI类型的请求路径

　　　　　　例如：restTemplate.getForObject("http://example.com/hotel list") becomes"http://example.com/hotel%20list"

　　　　技巧05：URI 和URL 知识点扫盲

　　　　　　参考博文01　　参考博文02

技术分享图片

　　　　技巧06：利用接收URI参数的RestTemplate.getForObject方法发送Get请求

技术分享图片

　　1.2 常用构造器

　　　　技巧01：利用无参构造器创建RestTemplate实例时，什么都是使用默认的【即：使用HttpMessageConverter来实现HTTTP messages 和 POJO 之间的转换、使用SimpleClientHttpRequestFactory and DefaultResponseErrorHandler 去创建HTTP连接和处理HTTP错误】

　　　　技巧02：利用 RestTemplate(ClientHttpRequestFactory requestFactory) 创建RestTemplate实例时使用自定义的requestFactory去创建HTTP连接

　　　　技巧03：利用 RestTemplate(java.util.List<HttpMessageConverter<?>> messageConverters) 创建RestTemplate实例时使用自定义的转换器列表实现HTTTP messages 和 POJO 之间的转换

技术分享图片

　　1.3 GET相关方法

　　　　技巧01：本博文使用的是SpringBoot项目，利用了一个配置文件来将RestTemplate注入的容器中

package cn.xiangxu.test_demo.common.config;

import cn.xiangxu.test_demo.domain.domain_do.Student;
import cn.xiangxu.test_demo.utils.proxy.JdkProxy;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.Nullable;
import org.springframework.web.client.RestTemplate;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author 王杨帅
 * @create 2018-08-18 13:07
 * @desc 创建Bean的配置类
 **/
@Configuration
public class BeanConfig {

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


}

BeanConfig.java

　　　　模拟后台代码：点击获取

package cn.xiangxu.rest_server.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

/**
 * @author 王杨帅
 * @create 2018-08-18 21:56
 * @desc 模拟get请求的服务端
 **/
@RestController
@RequestMapping(value = "/get")
@Slf4j
public class GetServerConroller {

    /**
     * 不带参数的get请求
     * @return
     */
    @GetMapping(value = "/get01")
    public String get01() {
        String result = "【get01】连接模拟的get服务端成功";
        log.info(result);
        return result;
    }

    /**
     * 带有请求参数的get请求
     * 笔记：
     *  1 get请求参数类型：
     *      》 url中？后面的请求参数，格式以 key=value 的形式传递；后台需要用@RequestParam注解
     *          如果前端的 key 和 后台方法的参数名称一致时可以不用@RequestParam注解【因为@RequestParam注解时默认的参数注解】
     *      》 url中的路径参数
     *          需要配合@RequestMapping和@PathVariable一起使用
     * @param username 请求参数
     * @return
     */
    @GetMapping(value = "/get02")
    public String get02(  @RequestParam(value = "name", required = false, defaultValue = "王杨帅") String username) {
        String result = "【get02】获取到的请求参数为：name = " + username;
        log.info(result);
        return result;
    }

    /**
     * 带有路径参数的get请求
     * @param userId
     * @return
     */
    @GetMapping(value = "/get03/{id}")
    public String get03(
            @PathVariable(value = "id") Integer userId
    ) {
        String result = "【get03】获取到的路径参数为：userId = " + userId;
        log.info(result);
        return result;
    }

    /**
     * 既有路径参数又有请求参数的get请求
     * 笔记：
     *  1 @PathVariable和@RequestParam都可以设定是否必传【默认必传】
     *  2 @PathVariable不可以设定默认值，@RequestParam可以设定默认值【默认值就是不传入的时候代替的值】
     *  3 @PathVariable如果设置必传为true，前端不传入时就会报错【技巧：开启必传】
     *  4 @RequestParam如果设置必传为true，前端不传入还是也会报错【技巧：关闭必传，开启默认值】
     *  5 @PathVariable可以设置正则表达式【详情参见：https://www.cnblogs.com/NeverCtrl-C/p/8185576.html】
     * @param userId
     * @param username
     * @return
     */
    @GetMapping(value = "/get04/{id}")
    public String get04(
            @PathVariable(value = "id") Integer userId,
            @RequestParam(value = "name", required = false, defaultValue = "王杨帅") String username
    ) {
        String result = "【get04】获取到的路径参数为：userId = " + userId + " 获取到的请求参数为：" + username;
        log.info(result);
        return result;
    }

}

远程Restful服务

　　　　模拟前端请求：点击获取

package cn.xiangxu.test_demo.controller;

import cn.xiangxu.test_demo.TestDemoApplicationTests;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;

@Component
@Slf4j
public class GetClientControllerTest extends TestDemoApplicationTests {

    @Autowired
    private RestTemplate restTemplate;

    @Test
    public void testDemo() throws Exception {
        System.out.println("Hello Boy");


    }


    /**
     * 请求无参数的get请求
     * @return
     */
    @Test
    public void get01() throws Exception {
        String forObject = restTemplate.getForObject(
                "http://127.0.0.1:8080/get/get01",
                String.class
        );
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有请求参数的get请求：利用占位符进行请求参数传递
     * @return
     */
    @Test
    public void get0201() throws Exception {
        String forObject = restTemplate.getForObject(
                "http://127.0.0.1:8080/get/get02?name={1}",
                String.class,
                "三少"
        );
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有请求参数的get请求：利用Map进行请求参数传递
     * @return
     */
    @Test
    public void get0202() throws Exception {
        Map<String, Object> params = new HashMap<>();
        params.put("name", "warrior");
        String forObject = restTemplate.getForObject(
                "http://127.0.0.1:8080/get/get02?name={name}",
                String.class,
                params
        );
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有路径参数的get请求：
     * @return
     */
    @Test
    public void get03() throws Exception {
        String forObject = restTemplate.getForObject(
                "http://127.0.0.1:8080/get/get03/88888888",
                String.class);
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求既有路径参数又有请求参数逇get请求
     * @return
     */
    @Test
    public void get04() throws Exception {
        String forObject = restTemplate.getForObject(
                "http://127.0.0.1:8080/get/get04/99999?name={1}",
                String.class,
                "fury"
        );
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求无参数的get请求
     * @return
     */
    @Test
    public void get01_e() throws Exception {
        ResponseEntity<String> forObject = restTemplate.getForEntity(
                "http://127.0.0.1:8080/get/get01",
                String.class
        );
        log.info("状态码：" + forObject.getStatusCode());
        log.info("状态值：" + forObject.getStatusCodeValue());
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有请求参数的get请求：利用占位符进行请求参数传递
     * @return
     */
    @Test
    public void get0201_e() throws Exception {
        ResponseEntity<String> forObject = restTemplate.getForEntity(
                "http://127.0.0.1:8080/get/get02?name={1}",
                String.class,
                "三少"
        );
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有请求参数的get请求：利用Map进行请求参数传递
     * @return
     */
    @Test
    public void get0202_e() throws Exception {
        Map<String, Object> params = new HashMap<>();
        params.put("name", "warrior");
        ResponseEntity<String> forObject = restTemplate.getForEntity(
                "http://127.0.0.1:8080/get/get02?name={name}",
                String.class,
                (Map<String, ?>) params);
        log.info("响应数据为：" + forObject);
    }

    /**
     * 请求有路径参数的get请求：
     * @return
     */
    @Test
    public void get03_e() throws Exception {
        ResponseEntity<String> forObject = restTemplate.getForEntity(
                "http://127.0.0.1:8080/get/get03/888888",
                String.class
        );
        log.info("响应数据为：" + forObject);
    }

    @Test
    public void get04_e() throws Exception {
    }

    /**
     * 请求既有路径参数又有请求参数逇get请求
     * @return
     */
    @Test
    public void test01() throws Exception {
        ResponseEntity<String> forObject = restTemplate.getForEntity(
                "http://127.0.0.1:8080/get/get04/99999?name={1}",
                String.class,
                "fury"
        );
        log.info("响应数据为：" + forObject);
    }

}

模拟客户端

　　　　1.3.1 public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)

　　　　　　1》远程服务代码【不带请求参数的】

技术分享图片

　　　　　　1》模拟客户端代码【不带请求参数的】

技术分享图片

　　　　　　2》远程服务代码【带请求参数的】

　　　　　　　　技巧01：HTTP请求中url路径？后面的参数就是请求参数格式以 key=value 的形式传递；后台需要用@RequestParam注解，如果前端的 key 和后台方法的参数名称一致时可以不用@RequestParam注解【因为@RequestParam注解时默认的参数注解】

　　　　　　　　技巧02：对于请求参数，最好在服务端利用@RequestParam注解设置该请求参数为非必传参数并设定默认值

技术分享图片

　　　　　　2》模拟客户端代码【带请求参数的】

技术分享图片

　　　　　　3》远程服务代码【带路径参数的】

　　　　　　　　技巧01：HTTP请求的路径可以成为路径参数，前提是服务端进行路径配置【即：需要配合@RequestMapping和@PathVariable一起使用】

　　　　　　　　技巧02：由于路径参数不能设置默认是，所以在后台通过@PathVariable将路径参数设置成必传可以减少出错率

　　　　　　　　技巧03：@PathVariable可以设置正则表达式【详情参见：https://www.cnblogs.com/NeverCtrl-C/p/8185576.html】

技术分享图片

　　　　　　3》模拟客户端代码【带路径参数的】

技术分享图片

　　　　　　4》远程服务代码【带路径参数和请求参数的】

　　　　　　　　技巧01： @PathVariable和@RequestParam都可以设定是否必传【默认必传】
　　　　　　　　技巧02：@PathVariable不可以设定默认值，@RequestParam可以设定默认值【默认值就是不传入的时候代替的值】
　　　　　　　　技巧03： @PathVariable如果设置必传为true，前端不传入时就会报错【技巧：开启必传】
　　　　　　　　技巧04：@RequestParam如果设置必传为true，前端不传入还是也会报错【技巧：关闭必传，开启默认值】
　　　　　　　　技巧05：@PathVariable可以设置正则表达式【详情参见：https://www.cnblogs.com/NeverCtrl-C/p/8185576.html】

技术分享图片

　　　　　　4》模拟客户端代码【带路径参数和请求参数的】

技术分享图片

　　　　1.3.2 public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)

　　　　　　1》远程服务代码【带请求参数的】

技术分享图片

　　　　　　1》模拟客户端代码【带请求参数的】

技术分享图片

　　　　1.3.3 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)

　　　　　　技巧01：getForObject 和 getForEntity 的区别：后者可以获取到更多的响应信息，前者这可以获取到响应体的数据

　　　　　　1》远程服务代码【不带请求参数的】

技术分享图片

　　　　　　1》模拟客户端代码【不带请求参数的】

技术分享图片

　　　　　　2》远程服务代码【带请求参数的】

技术分享图片

　　　　　　2》模拟客户端代码【带请求参数的】

技术分享图片

　　　　　　3》远程服务代码【带路径参数的】

技术分享图片

　　　　　　3》模拟客户端代码【带路径参数的】

技术分享图片

　　　　　　4》远程服务代码【带路径参数和请求参数的】

技术分享图片

　　　　　　4》模拟客户端代码【带路径参数和请求参数的】

技术分享图片

　　　　1.3.4 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)

　　　　　　1》远程服务代码【带请求参数的】

技术分享图片

　　　　　　1》模拟客户端代码【带请求参数的】

技术分享图片

　　1.4 POST

　　　　服务端源代码：点击前往

package cn.xiangxu.rest_server.controller;

import cn.xiangxu.rest_server.domain.Student;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

/**
 * @author 王杨帅
 * @create 2018-08-19 9:41
 * @desc 模拟post服务端接口
 **/
@RestController
@RequestMapping(value = "/post")
@Slf4j
public class PostServerController {

    /**
     * 模拟只有请求体参数的post请求
     * @param student 请求体参数
     * @return
     */
    @PostMapping(value = "/post01")
    public Student post01(
            @RequestBody Student student
    ) {
        log.info("【post01】获取到的请求体参数为：" + student);
        student.setName("服务端修改");
        return student;

    }

    /**
     * 模拟既有请求体参数又有请求参数的post请求
     * @param student 请求体参数
     * @param infoMsg 请求参数
     * @return
     */
    @PostMapping(value = "/post02")
    public String post02(
            @RequestBody Student student,
            @RequestParam(value = "info", required = false, defaultValue = "默认请求参数") String infoMsg
    ) {
        String result = "【post02】-方法体参数为：student -> " + student + " 请求参数为：infoMsg -> " + infoMsg;
        log.info(result);
        return result;
    }

    /**
     * 模拟既有请求体参数又有请求参数和路径参数的post请求
     * @param student 请求体参数
     * @param infoMsg 请求参数
     * @param userId 路径参数
     * @return
     */
    @PostMapping(value = "/post03/{id}")
    public String post03(
            @RequestBody Student student,
            @RequestParam(value = "info", required = false, defaultValue = "默认请求参数") String infoMsg,
            @PathVariable(value = "id", required = false) Integer userId
    ) {

        String result = "【psot03】-获取到的请求体参数为：student -> " + student + "\n" +
                "请求参数为：infoMsg -> " + infoMsg + "\n" +
                "路径参数为：userId -> " + userId;

        log.info(result);

        return result;

    }

    @GetMapping(value = "/connect")
    public String connect() {
        String result = "【post】-前后端连接测试成功";
        log.info(result);
        return result;
    }

}

View Code

　　　　模拟客户端代码：点击前往

package cn.xiangxu.test_demo.controller;

import cn.xiangxu.test_demo.TestDemoApplicationTests;
import cn.xiangxu.test_demo.domain.domain_do.Student;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

import static org.junit.Assert.*;

@Component
@Slf4j
public class PostClientControllerTest extends TestDemoApplicationTests {

    @Autowired
    private RestTemplate restTemplate;

    @Test
    public void connect() throws Exception {
    }

    /**
     * 模拟只有请求体参数的post请求
     * @return
     */
    @Test
    public void post01() throws Exception {
        Student student = Student.builder()
                .name("warrior")
                .age(24)
                .build();

        Student postForObject = restTemplate.postForObject(
                "http://127.0.0.1:8080/post/post01",
                student,
                Student.class
        );

        System.out.println(postForObject);
    }

    /**
     * 模拟既有请求体参数又有请求参数的POST请求【方式01】
     * @return
     */
    @Test
    public void post0201() throws Exception {
        Student student = Student.builder()
                .name("王杨帅")
                .address("渝足")
                .build();
        String forObject = restTemplate.postForObject(
                "http://127.0.0.1:8080/post/post02?info={1}",
                student,
                String.class,
                "模拟前端"
        );
        log.info("响应数据?：" + forObject);
    }

    /**
     * 模拟既有请求体参数又有请求参数的POST请求【方式02】
     * @return
     */
    @Test
    public void post0202() throws Exception {
        Student student = Student.builder()
                .name("warrior")
                .address("大足")
                .build();

        Map<String, Object> param = new HashMap<>();
        param.put("info", "模拟前端");

        String forObject = restTemplate.postForObject(
                "http://127.0.0.1:8080/post/post02?info={info}",
                student,
                String.class,
                param
        );

        log.info("响应数据?：" + forObject);
    }

    /**
     * 模拟既有请求体参数又有请求参数和路径参数的POST请求
     * @return
     */
    @Test
    public void post03() throws Exception {
        Student student = Student.builder()
                .name("fury")
                .address("合川")
                .build();

        String forObject = restTemplate.postForObject(
                "http://127.0.0.1:8080/post/post03/8888?info={1}",
                student,
                String.class,
                "模拟请求参数"

        );

        log.info("响应数据为：" + forObject);
    }

        /*
    下面是利用另外一个方法实现get请求:
        笔记：
            1 getForObject 和 getForEntity 的区别：后者可以获取到更多的响应信息，前者这可以获取到响应体的数据
     */

    /**
     * 模拟只有请求体参数的post请求
     * @return
     */
    @Test
    public void post01_e() throws Exception {
        Student student = Student.builder()
                .name("王杨帅")
                .address("渝足")
                .build();

        ResponseEntity<Student> forObject = restTemplate.postForEntity(
                "http://127.0.0.1:8080/post/post01",
                student,
                Student.class
        );

        log.info("响应数据为：" + forObject.getBody());
    }

    /**
     * 模拟既有请求体参数又有请求参数的POST请求【方式01】
     * @return
     */
    @Test
    public void post0201_e() throws Exception {
        Student student = Student.builder()
                .name("王杨帅")
                .address("渝足")
                .build();
        ResponseEntity<String> forObject = restTemplate.postForEntity(
                "http://127.0.0.1:8080/post/post02?info={1}",
                student,
                String.class,
                "模拟前端"
        );

        log.info("响应数据为：" + forObject.getBody());
    }

    /**
     * 模拟既有请求体参数又有请求参数的POST请求【方式02】
     * @return
     */
    @Test
    public void post0202_e() throws Exception {
        Student student = Student.builder()
                .name("warrior")
                .address("大足")
                .build();

        Map<String, Object> param = new HashMap<>();
        param.put("info", "模拟前端");

        ResponseEntity<String> forObject = restTemplate.postForEntity(
                "http://127.0.0.1:8080/post/post02?info={info}",
                student,
                String.class,
                param
        );

        log.info("响应数据为：" + forObject.getBody());
    }

    /**
     * 模拟既有请求体参数又有请求参数和路径参数的POST请求
     * @return
     */
    @Test
    public void post03_e() throws Exception {
        Student student = Student.builder()
                .name("fury")
                .address("合川")
                .build();

        ResponseEntity<String> forObject = restTemplate.postForEntity(
                "http://127.0.0.1:8080/post/post03/8888?info={1}",
                student,
                String.class,
                "模拟请求参数"

        );

        log.info("响应数据为：" + forObject.getBody());
    }

    /**
     * 请求体封装【利用HttpEntity可以自定义请求体和请求头】
     */
    @Test
    public void test01() throws Exception {
        Student student = Student.builder()
                .name("bob")
                .address("成都")
                .build();

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);

        HttpEntity<Student> studentHttpEntity = new HttpEntity<>(student, headers);

        String forObject = restTemplate.postForObject(
                "http://127.0.0.1:8080/post/post02?info={1}",
                studentHttpEntity,
                String.class,
                "模拟前端"
        );

        log.info(forObject);

    }

}

View Code

　　　　1.4.1 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables)

　　　　　　参数解释：

　　　　　　　　url -> String类型的请求路径

　　　　　　　　request -> 请求体对象

　　　　　　　　responseType -> 响应数据类型

　　　　　　　　uriVariables -> 请求参数

　　　　1.4.2 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables)

　　　　　　参数解释：

　　　　　　　　url -> String类型的请求路径

　　　　　　　　request -> 请求体对象

　　　　　　　　responseType -> 响应数据类型

　　　　　　　　uriVariables -> 请求参数

　　　　1.4.3 public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType)

　　　　　　参数解释：

　　　　　　　　url -> URI类型的请求路径

　　　　　　　　request -> 请求体对象

　　　　　　　　responseType -> 响应数据类型

　　　　1.4.4 请求体对象说明

　　　　　　技巧01：请求体对象（@Nullable Object request）可以直接传一个实体，服务端利用@RequestBody接收这个实体即可

　　　　　　技巧02：请求体对象（@Nullable Object request）也可以传入一个 HttpEntity 的实例，服务端的代码不变；创建 HttpEntity 实例时可以设定请求体数据和请求头数据（详情请参见 HttpEntity 的相关构造函数）

技术分享图片

　　1.5 其他请求和GET、POST类似

　　　　待更新......

2 WebClient

　　WebClient 是一个非阻塞、响应式的HTTP客户端，它以响应式被压流的方式执行HTTP请求；WebClient默认使用 Reactor Netty 作为HTTP连接器，当然也可以通过ClientHttpConnector修改其它的HTTP连接器。

　　技巧01：使用WebClient需要进入Spring5的相关依赖，如果使用的是SpringBoot项目的话直接引入下面的依赖就可以啦

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.reactive.function.client;

import java.net.URI;
import java.nio.charset.Charset;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import org.reactivestreams.Publisher;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ClientHttpRequest;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.util.UriBuilder;
import org.springframework.web.util.UriBuilderFactory;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface WebClient {
    WebClient.RequestHeadersUriSpec<?> get();

    WebClient.RequestHeadersUriSpec<?> head();

    WebClient.RequestBodyUriSpec post();

    WebClient.RequestBodyUriSpec put();

    WebClient.RequestBodyUriSpec patch();

    WebClient.RequestHeadersUriSpec<?> delete();

    WebClient.RequestHeadersUriSpec<?> options();

    WebClient.RequestBodyUriSpec method(HttpMethod var1);

    WebClient.Builder mutate();

    static WebClient create() {
        return (new DefaultWebClientBuilder()).build();
    }

    static WebClient create(String baseUrl) {
        return (new DefaultWebClientBuilder()).baseUrl(baseUrl).build();
    }

    static WebClient.Builder builder() {
        return new DefaultWebClientBuilder();
    }

    public interface RequestBodyUriSpec extends WebClient.RequestBodySpec, WebClient.RequestHeadersUriSpec<WebClient.RequestBodySpec> {
    }

    public interface RequestHeadersUriSpec<S extends WebClient.RequestHeadersSpec<S>> extends WebClient.UriSpec<S>, WebClient.RequestHeadersSpec<S> {
    }

    public interface ResponseSpec {
        WebClient.ResponseSpec onStatus(Predicate<HttpStatus> var1, Function<ClientResponse, Mono<? extends Throwable>> var2);

        <T> Mono<T> bodyToMono(Class<T> var1);

        <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> var1);

        <T> Flux<T> bodyToFlux(Class<T> var1);

        <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> var1);
    }

    public interface RequestBodySpec extends WebClient.RequestHeadersSpec<WebClient.RequestBodySpec> {
        WebClient.RequestBodySpec contentLength(long var1);

        WebClient.RequestBodySpec contentType(MediaType var1);

        WebClient.RequestHeadersSpec<?> body(BodyInserter<?, ? super ClientHttpRequest> var1);

        <T, P extends Publisher<T>> WebClient.RequestHeadersSpec<?> body(P var1, Class<T> var2);

        <T, P extends Publisher<T>> WebClient.RequestHeadersSpec<?> body(P var1, ParameterizedTypeReference<T> var2);

        WebClient.RequestHeadersSpec<?> syncBody(Object var1);
    }

    public interface RequestHeadersSpec<S extends WebClient.RequestHeadersSpec<S>> {
        S accept(MediaType... var1);

        S acceptCharset(Charset... var1);

        S cookie(String var1, String var2);

        S cookies(Consumer<MultiValueMap<String, String>> var1);

        S ifModifiedSince(ZonedDateTime var1);

        S ifNoneMatch(String... var1);

        S header(String var1, String... var2);

        S headers(Consumer<HttpHeaders> var1);

        S attribute(String var1, Object var2);

        S attributes(Consumer<Map<String, Object>> var1);

        WebClient.ResponseSpec retrieve();

        Mono<ClientResponse> exchange();
    }

    public interface UriSpec<S extends WebClient.RequestHeadersSpec<?>> {
        S uri(URI var1);

        S uri(String var1, Object... var2);

        S uri(String var1, Map<String, ?> var2);

        S uri(Function<UriBuilder, URI> var1);
    }

    public interface Builder {
        WebClient.Builder baseUrl(String var1);

        WebClient.Builder defaultUriVariables(Map<String, ?> var1);

        WebClient.Builder uriBuilderFactory(UriBuilderFactory var1);

        WebClient.Builder defaultHeader(String var1, String... var2);

        WebClient.Builder defaultHeaders(Consumer<HttpHeaders> var1);

        WebClient.Builder defaultCookie(String var1, String... var2);

        WebClient.Builder defaultCookies(Consumer<MultiValueMap<String, String>> var1);

        WebClient.Builder clientConnector(ClientHttpConnector var1);

        WebClient.Builder filter(ExchangeFilterFunction var1);

        WebClient.Builder filters(Consumer<List<ExchangeFilterFunction>> var1);

        WebClient.Builder exchangeFunction(ExchangeFunction var1);

        WebClient.Builder exchangeStrategies(ExchangeStrategies var1);

        WebClient.Builder clone();

        WebClient.Builder apply(Consumer<WebClient.Builder> var1);

        WebClient build();
    }
}

WebClient源码

　　2.1 创建WebClient实例的方式

　　　　技巧01：从WebClient的源码中可以看出，WebClient接口提供了三个静态方法来创建WebClient实例

技术分享图片

　　　　2.1.1 利用create()创建

　　　　　　该方法不接受任何参数，返回类型是WebClient

　　　　　　技巧01：由于利用create()创建的WebClient对象没有设定baseURL，所以 uri("http://127.0.0.1:8080/get/get01") 返回的结果就是最终需要请求的远程服务器的URL；这里的 uri("http://127.0.0.1:8080/get/get01")相当于重写baseURL。

技术分享图片

　　　　2.2.2 利用create(String baseUrl)创建

　　　　　　该方法接收一个String类型的对象作为baseUrl，直接返回WebClient对象

　　　　　　技巧01：由于利用create(String baseUrl)创建的WebClient对象时已经设定了baseURL，所以 uri("/get01") 会将返回的结果和baseUrl进行拼接组成最终需要远程请求的资源RUL

技术分享图片

　　　　2.2.3 利用builder创建【推荐使用】

　　　　　　该方法不接受任何参数，返回的是 WebClient.Builder

　　　　　　技巧01：由于返回的不是WebClient类型而是WebClient.Builder，我们可以通过返回的 WebClient.Builder 设置一些配置参数（例如：baseUrl等），然后在调用build就可以返回WebClient对象了【WebClient.Builder先关知识点请继续往下看】

技术分享图片

　　　　2.2.4 重写baseURL

　　　　　　》如果在创建WebClient时没有指定baseURL就可以用uri进行重写【前提：uri的参数必须是一个完整的路径】 -> 完全重写

技术分享图片

　　　　　　》即使在创建WebClient的时候指定了baseURL也可以用uri进行重写【前提：uri的参数必须是一个完整的路径】-> 部分重写

技术分享图片

　　　　　　》即使在创建WebClient的时候指定了baseURL也可以用uri进行重写【前提：此时需要用到参数是一个函数式接口的uri方法】 -> 部分重写

　　　　　　　　技巧01：S uri(Function<UriBuilder, URI> var1) -> 这个uri方法接收一个lambda表达式【输入是UriBuilder，输出时RUI对象】

　　　　　　　　技巧02：uri方法返回的URI对象会被转化成远程请求资源的URL

　　　　　　　　技巧03：UriBuilder的replacePath方法是替换端口后面的所有信息【详情参见UriBuilder，其实UriBuilder和URI很像】

技术分享图片

　　　　　　》实战技巧

　　　　　　　　在使用uri时尽量使用S uri(Function<UriBuilder, URI> var1) ，因为这个方法可以设定更多的配置信息【例如：设置端口、设置参数、拼接路径、替换路径、替换参数......】

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.util;

import java.net.URI;
import java.util.Map;
import org.springframework.lang.Nullable;
import org.springframework.util.MultiValueMap;

public interface UriBuilder {
    UriBuilder scheme(@Nullable String var1);

    UriBuilder userInfo(@Nullable String var1);

    UriBuilder host(@Nullable String var1);

    UriBuilder port(int var1);

    UriBuilder port(@Nullable String var1);

    UriBuilder path(String var1);

    UriBuilder replacePath(@Nullable String var1);

    UriBuilder pathSegment(String... var1) throws IllegalArgumentException;

    UriBuilder query(String var1);

    UriBuilder replaceQuery(@Nullable String var1);

    UriBuilder queryParam(String var1, Object... var2);

    UriBuilder queryParams(MultiValueMap<String, String> var1);

    UriBuilder replaceQueryParam(String var1, Object... var2);

    UriBuilder replaceQueryParams(MultiValueMap<String, String> var1);

    UriBuilder fragment(@Nullable String var1);

    URI build(Object... var1);

    URI build(Map<String, ?> var1);
}

UriBuilder.java

技术分享图片　　

　　2.2 WebClient相关接口概览

技术分享图片

　　　　2.2.1 WebClient.Builder

    public interface Builder {
        WebClient.Builder baseUrl(String var1);

        WebClient.Builder defaultUriVariables(Map<String, ?> var1);

        WebClient.Builder uriBuilderFactory(UriBuilderFactory var1);

        WebClient.Builder defaultHeader(String var1, String... var2);

        WebClient.Builder defaultHeaders(Consumer<HttpHeaders> var1);

        WebClient.Builder defaultCookie(String var1, String... var2);

        WebClient.Builder defaultCookies(Consumer<MultiValueMap<String, String>> var1);

        WebClient.Builder clientConnector(ClientHttpConnector var1);

        WebClient.Builder filter(ExchangeFilterFunction var1);

        WebClient.Builder filters(Consumer<List<ExchangeFilterFunction>> var1);

        WebClient.Builder exchangeFunction(ExchangeFunction var1);

        WebClient.Builder exchangeStrategies(ExchangeStrategies var1);

        WebClient.Builder clone();

        WebClient.Builder apply(Consumer<WebClient.Builder> var1);

        WebClient build();
    }

View Code

　　　　　　该接口可用来在创建WebClient实例时修改一些默认的配置，而且灵活性特别大；利用该接口对象可以设置WebClient的cookie、header等信息。

　　　　　　》获取WebClient.Builder对象

　　　　　　　　技巧01：获取WebClient.Builder对象或就可以进行一些配置设置了，配置完成后调用build方法就可以生成WebClient对象啦

WebClient.Builder builder = WebClient.builder();

　　　　2.2.2 `WebClient.RequestBodySpec`

　　　　　　该接口主要用来这顶媒体类型和请求体的【需要请求体类型的HTTP请求需要用到，例如：POST】

　　　　　　技巧01：调用post()后返回的类型是RequestBodyUriSpec

　　　　　　技巧02：uri()方法需要 UriSpec 类型的实例才可以调用，但是 UriSpec 恰恰继承了 RequestBodyUriSpec，uri() 方法返回的类型是RequestHeadersSpec

　　　　　　技巧03：contentType() 方法需要RequestBodySpec类型的实例才可以调用，但是RequestHeadersSpec的父接口是RequestHeadersSpec，contentType() 的返回类型是WebClient.RequestBodySpec

　　　　　　技巧04：body() 方法需要RequestBodySpec类型的实例才可以调用，body() 的返回值类型是WebClient.RequestHeadersSpec

　　　　　　技巧总结：使用WebClient是由严格的调用你顺序的，如下：

　　　　　　　　HTTP请求类型 -> 请求URL -> 请求体类型 -> 请求体

技术分享图片

　　　　2.2.3 其他接口

　　　　　　待更新......2018年8月20日21:20:46

　　2.3 WebClient 请求方法概览

　　　　技术分享图片

　　　　详情信息待更新...... 2018年8月20日21:38:05

技术分享图片

SpringBoot26 RestTemplate、WebClient

原文：https://www.cnblogs.com/NeverCtrl-C/p/9508313.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

SpringBoot26 RestTemplate、WebClient

1 RestTemplate

1.1 RestTemplate中方法概览

1.2 常用构造器

1.3 GET相关方法

模拟前端请求：点击获取

1.3.1 public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)

1.3.2 public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)

1.3.3 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)

1.3.4 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)

1.4 POST

1.4.1 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables)

1.4.2 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables)

1.4.3 public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType)

1.4.4 请求体对象说明

1.5 其他请求和GET、POST类似

2 WebClient

2.1 创建WebClient实例的方式

2.1.1 利用create()创建

2.2.2 利用create(String baseUrl)创建

2.2.3 利用builder创建【推荐使用】

2.2.4 重写baseURL

2.2 WebClient相关接口概览

2.2.1 WebClient.Builder

2.2.2 WebClient.RequestBodySpec

2.2.3 其他接口

2.3 WebClient 请求方法概览

　　1.1 RestTemplate中方法概览

　　1.2 常用构造器

　　1.3 GET相关方法

　　　　模拟前端请求：点击获取

　　　　1.3.1 public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)

　　　　1.3.2 public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)

　　　　1.3.3 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)

　　　　1.3.4 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)

　　1.4 POST

　　　　1.4.1 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables)

　　　　1.4.2 public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables)

　　　　1.4.3 public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType)

　　　　1.4.4 请求体对象说明

　　1.5 其他请求和GET、POST类似

　　2.1 创建WebClient实例的方式

　　　　2.1.1 利用create()创建

　　　　2.2.2 利用create(String baseUrl)创建

　　　　2.2.3 利用builder创建【推荐使用】

　　　　2.2.4 重写baseURL

　　2.2 WebClient相关接口概览

　　　　2.2.1 WebClient.Builder

　　　　2.2.2 `WebClient.RequestBodySpec`

　　　　2.2.3 其他接口

　　2.3 WebClient 请求方法概览