关于java:因为Spring翻车被鄙视美团大佬公开分享解决方法网友我服了

52次阅读

共计 6626 个字符,预计需要花费 17 分钟才能阅读完成。

今日分享开始啦,请大家多多指教~

RestTemplate 采纳 Java Servlet API,因而是阻塞式同步调用。相同,WebClient 是异步的,期待响应的同时不会阻塞正在执行的线程。只有在响应后果准备就绪时,才会发动告诉。

RestTemplate 依然有用武之地。非阻塞模式在某些场景下比阻塞办法占用系统资源要少得多,这时 WebClient 是一种更好的抉择。

一、WebClient

非阻塞式客户端。WebClient 应用 Spring Reactive Framework 所提供的异步非阻塞解决方案。

当 RestTemplate 为每个事件(HTTP 申请)创立一个新的线程时,WebClient 将为每个事件创立相似于“工作”。幕后,Reactive 框架将对这些“工作”进行排队,并仅在适当的响应可用时执行它们。

Reactive 框架应用事件驱动的体系结构。它提供了通过 Reactive Streams API 组合异步逻辑的办法。因而,与同步 / 阻塞办法相比,Reactive 能够应用更少的线程和系统资源来解决更多的逻辑。WebClient 是 Spring WebFlux 库的一部分。因而,咱们还能够应用晦涩的函数式 API 编写客户端代码,并将响应类型(Mono 和 Flux)作为申明来进行组合。

1. 依赖

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

2. 创立

    @Test
    void webclient01Create(){WebClient webClient = WebClient.create();
        Mono<String> mono = webClient
                .get() //get 申请
                .uri(BASE_URI + "/test/get01")
                .retrieve() // 获取响应体
                .bodyToMono(String.class); // 格式化响应数据
        log.info("{}",mono.block());
    }
    @Test
    void webclient02Create(){WebClient webClient = WebClient.create(BASE_URI);
        Mono<String> mono = webClient
                .get()
                .uri("/test/get01")// uri 会主动拼接
                .retrieve()
                .bodyToMono(String.class);
        log.info("{}",mono.block());
    }
    @Test
    void webclient03Builder(){WebClient webClient = WebClient.builder()
                .baseUrl(BASE_URI)
                .build();
        Mono<String> mono = webClient
                .get()
                .uri("/test/get01")
                .retrieve()
                .bodyToMono(String.class);
        log.info("{}",mono.block());
    }

3. 应用

    @Test
    void webclient04(){WebClient webClient = WebClient.builder()
                .baseUrl(BASE_URI)
                .build();
        Mono<String> mono = webClient
                .get()
                .uri(uriBuilder -> uriBuilder
                    .path("/test/get02")
                    .queryParam("pageSize",10)
                    .queryParam("pageNum",1)
                    .build())
                .retrieve()
                .bodyToMono(String.class);
        log.info("{}",mono.block());
    }
    @Test
    void webclient05(){WebClient webClient = WebClient.builder()
                .baseUrl(BASE_URI)
                .build();
        User user = User.builder().id("0000").password("0000").build();
        Mono<User> userMono = webClient
                .post()
                .uri(uriBuilder -> uriBuilder.path("/test/post01").build())
                .contentType(MediaType.APPLICATION_JSON)
                .body(Mono.just(user),User.class)
//                .header()
                .retrieve()
                .bodyToMono(User.class);
        log.info("{}",userMono.block());
    }

二、RestTemplate

阻塞式客户端。RestTemplate 应用了基于每个申请对应一个线程模型(thread-per-request)的 Java Servlet API。这意味着,直到 Web 客户端收到响应之前,线程都将始终被阻塞上来。而阻塞代码带来的问题则是,每个线程都耗费了肯定的内存和 CPU 周期。这些线程将耗尽线程池或占用所有可用内存。因为频繁的 CPU 上下文(线程)切换,咱们还会遇到性能降落的问题。

1. 小技巧

办法名的第一局部示意 HTTP 申请类型,办法名的第二局部示意响应类型。例如:getForObject 示意执行 GET 申请并将响应转化成一个 Object 类型的对象。

利用 RestTemplate 封装客户端发送 HTTP 申请时,如果出现异常就会抛出 RestClientException 类型的异样;能够通过在创立 RestTemplate 对象的时候指定一个 ResponseErrorHandler 类型的异样解决类来解决这个异样

exchange 和 excute 这两个办法是通用的 HTTP 申请办法,而且这两个办法还反对额定的 HTTP 申请类型

RestTemplate 默认应用 JDK 提供的包去建设 HTTP 连贯,当然,开发者也能够应用诸如 Apache HttpComponents, Netty, and OkHttp 去建设 HTTP 连

RestTemplate 外部默认应用 HttpMessageConverter 来实现 HTTTP messages 和 POJO 之间的转换,能够通过 RestTemplate 的成员办法 tMessageConverters(java.util.List<org.springframework.http.converter.HttpMessageConverter<?>>). 去批改默认的转换器

RestTemplate 外部默认应用 SimpleClientHttpRequestFactory 创立 HTTP 连贯能够通过 HttpAccessor.setRequestFactory(org.springframework.http.client.ClientHttpRequestFactory) 去做相应的批改

每种办法都有 3 个重载办法,其中两个接管 String 类型的申请门路和响应类型、参数;另外一个接管 URI 类型的申请门路和响应类型

应用 String 类型的申请门路时,RestTemplate 会主动进行一次编码,所以为了防止反复编码问题最好应用 URI 类型的申请门路

getForObject 和 getForEntity 的区别:后者能够获取到更多的响应信息,前者这能够获取到响应体的数据

2. 示例

应用 @Configuration 提前注入的 RestTemplate

2.1GET

不带申请参数的 GET 申请

服务端代码

客户端测试代码

带申请参数的 GET 申请

服务端代码

    /*
     * 带申请参数的 get 申请
     * @param pageSize
     * @param pageNum
     * @return String
     */
    @GetMapping("/get02")
    public String get02(@RequestParam Integer pageSize, @RequestParam Integer pageNum) {return "get02() ok, 申请参数为:" + pageSize + "/" + pageNum;
    }

客户端测试代码

带门路参数的 GET 申请

服务端代码

    /*
     * 带门路参数的 get 申请
     * @param id
     * @return String
     */
    @GetMapping("/get03/{id}")
    public String get03(@PathVariable("id") String id) {return "get03() ok, 门路参数为:" + id;
    }

客户端测试代码

带有申请参数和门路参数的 GET 申请

服务端代码

    /*
     * 带有申请参数和门路参数的 get 申请
     * @param score
     * @param id
     * @return String
     */
    @GetMapping("/get04/{id}")
    public String get04(@RequestParam String score, @PathVariable("id") String id) {return "get04() ok, 申请参数为:" + score + ",门路参数为:" + id;
    }

客户端测试代码

带申请参数的 GET 申请,Map 传递

服务端代码

    /*
     * 带申请参数的 get 申请
     * @param pageSize
     * @param pageNum
     * @return String
     */
    @GetMapping("/get02")
    public String get02(@RequestParam Integer pageSize, @RequestParam Integer pageNum) {return "get02() ok, 申请参数为:" + pageSize + "/" + pageNum;
    }

客户端测试代码

    @Test
    void get05(){Map<String,Object> params = new HashMap<>();
        params.put("pageSize",10);
        params.put("pageNum",1);
        String uri = BASE_URI +"/test/get02?pageSize={pageSize}&pageNum={pageNum}";
        String result = restTemplate.getForObject(uri,String.class,params);
        log.info("{}",result);
    }

不带申请参数的 GET 申请返回 ResponseEntity

能够获取到残缺的响应信息

服务端代码

    /*
     *  不带参数的 get 申请
     * @return String
     */
    @GetMapping("/get01")
    public String get01() {return "get01() ok";
    }

客户端测试代码

    @Test
    void get06(){
        String uri = BASE_URI + "/test/get01";
        ResponseEntity<String> result = restTemplate.getForEntity(uri,String.class);
        log.info("{}",result);
    }

携带申请参数的 GET 申请,返回 List<Entity>

服务器端代码

客户端测试代码

    @Test
    void get07(){String uri = BASE_URI + "/test/get05?pageSize={1}&pageNum={2}";
        ResponseEntity<List> result = restTemplate.getForEntity(uri,List.class,10,1);
        log.info("{}", result);
    }

自定义申请头的 GET 申请

服务端代码

客户端测试代码

@Test
    void get08(){String uri = BASE_URI + "/test/get05?pageSize={1}&pageNum={2}";
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.add("token", UUID.randomUUID().toString());
        ResponseEntity<List> result = restTemplate.exchange(
                uri,
                HttpMethod.GET,
                new HttpEntity<>(httpHeaders),
                List.class,
                10,1
        );
        log.info("{}",result);
    }

2.2 POST

没有申请参数只有申请体的 POST 申请

服务端代码

    /*
     * 只有申请体的 POST 申请
     * @param user
     */
    @PostMapping("/post01")
    public User post01(@RequestBody User user){log.info("申请体:{}",user.toString());
        return user;
    }

客户端测试代码

含有申请体、申请参数、门路参数的 POST 申请

服务端代码

    /*
     * 带有申请体参数、申请参数、门路参数的 POST 申请
     * @param user
     * @param status
     * @param type
     * @return String
     */
    @PostMapping("/post02/{type}")
    public String post02(@RequestBody User user,
                         @RequestParam("status") Integer status,
                         @PathVariable("type") String type) {return "requestBody:" + user.toString() + ",requestParam:" + status + ",
      pathVariable:"+ type +"";
    }

客户端测试代码

    @Test
    void post02() {String uri = BASE_URI + "/test/post02/++++/?status={1}";
        String result = restTemplate.postForObject(
                uri,
                User.builder().id("***").password("....").build(),
                String.class,
                0
        );
        log.info("{}",result);
    }

应用 HttpEntity 自定义申请体和申请头发起 POST 申请

服务端代码

    /*
     * 带有申请体参数、申请参数、门路参数的 POST 申请
     * @param user
     * @param status
     * @param type
     * @return String
     */
    @PostMapping("/post02/{type}")
    public String post02(@RequestBody User user,
                         @RequestParam("status") Integer status,
                         @PathVariable("type") String type) {return "requestBody:" + user.toString() + ",requestParam:" + status + ",
      pathVariable:"+ type +"";
    }

客户端测试代码

    @Test
    void post03(){String uri =   BASE_URI + "/test/post02/788787/?status={1}";
        User user = User.builder().id("6666").password("7777").build();
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<User> httpEntity = new HttpEntity<>(user,httpHeaders);
        String result = restTemplate.postForObject(uri,httpEntity,String.class,0);
        log.info("{}",result);
    }

小结

在 Web 利用中咱们须要对其余服务进行 HTTP 调用。WebClient 和 RestTemplate 是两个由 Spring 提供的客户端工具。

今日份分享已完结,请大家多多包涵和指导!

正文完
 0