首页 > 编程语言 > 详细

SpringBoot26 RestTemplate、WebClient

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

标签:列表   nth   restful服务   占位符   autowire   eval   sna   pid   lan   

 

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

标签:列表   nth   restful服务   占位符   autowire   eval   sna   pid   lan   

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

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号