HttpClient类简介

HttpClient 类是 Java Development Kit (JDK) 自 JDK 11 起引入的一个新的 HTTP 客户端 API，它旨在简化和改进发出 HTTP 请求以及处理响应的方式。这个 API 提供了对同步和异步非阻塞请求的支持，并且内置了对 HTTP/2 和 WebSocket 的支持。以下是关于 HttpClient 类的一些关键点：

主要特点

HTTP/1.1 和 HTTP/2 支持：

HttpClient 支持 HTTP/1.1 和 HTTP/2 协议。它能够自动选择合适的版本来与服务器通信。

WebSocket 支持：

除了传统的 HTTP 请求，HttpClient 还提供了对 WebSocket 协议的支持，允许建立持久连接并进行双向通信。

同步和异步操作：

你可以使用同步方法（如 send()）来发送请求并等待响应，也可以使用异步方法（如 sendAsync()），这些方法返回一个 CompletableFuture<HttpResponse>，可以在完成时执行回调或链式调用其他操作。

流式传输：

HttpClient 支持流式传输大文件或数据，这对于上传或下载大量数据特别有用。

请求体发布器（BodyPublisher）：

对于有请求体的请求（例如 POST 或 PUT），可以使用 HttpRequest.BodyPublishers 来创建 BodyPublisher 实例，这使得提供请求体内容变得简单。

响应处理器（BodyHandler 和 BodySubscriber）：

可以指定如何处理响应体，例如将其作为字符串、字节缓冲区或流来处理。

SSL/TLS 和代理支持：

内置支持 SSL/TLS 加密和通过 HTTP/HTTPS 代理发送请求。

重定向和认证：

内置支持自动处理 HTTP 重定向和基本认证。

可配置性和灵活性：

HttpClient 是高度可配置的，可以通过 HttpClient.Builder 设置各种选项，如超时时间、连接池大小等。

使用

yml

yml
http:
  algo: http://127.0.0.1:3001 
  timeout: 60 #秒

HttpParam

java

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class HttpParam {

    private static long timeout;
    private static String algo; // 非静态字段

    @Value("${http.timeout}")
    public void setTimeout(long timeout) {
        HttpParam.timeout = timeout;
    }


    @Value("${http.algo}")
    public void setAlgo(String algo) {
        HttpParam.algo = algo;
    }

    public static long getTimeout() {
        return timeout;
    }

    public static String getAlgo() {
        return algo;
    }
}

InterfaceEnum

java

import com.hw.platform.param.HttpParam;

public enum AlgoInterfaceEnum {

    // 枚举实例
    启动关闭模型( "/product/dictFault/list","GET"),
    状态类开始检测("/product/dictFault/list","POST");

    // 成员变量
    private final String url;
    private final String restful;


    // 私有构造函数
    AlgoInterfaceEnum(String url,String restful) {
        this.url = url;
        this.restful = restful;
    }

    // Getter 方法
    public String getUrl() {
        return HttpParam.getAlgo()+url;
    }

    public String getRestful(){
        return restful;
    }

}

HttpUtils

java

import com.hw.core.common.enums.CommonResponseEnum;
import com.hw.core.util.JsonUtils;
import com.hw.core.util.StringUtils;
import com.hw.platform.param.HttpParam;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
public class HttpUtils {
    private static long timeout;
    static {
        timeout= HttpParam.getTimeout();
    }
    public static Map<String, Object> sendHttp(Map<String,String> map,String url,String restful ){
        if ("GET".equals(restful)){
            return sendHttpGet(map,url);
        }else if ("POST".equals(restful)){
            return sendHttpPost(map,url);
        }
        throw new RuntimeException(CommonResponseEnum.NOT_NET_CONNECT.getMessage());
    }

    public static Map<String, Object>  sendHttpPost(Map<String,String> map,String url) {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .connectTimeout(Duration.ofSeconds(timeout))
                .build();

        String json = JsonUtils.toJsonString(map);

        URI uri= null;
        try {
            uri = URI.create(url);
        } catch (Exception e) {
            CommonResponseEnum.BAD_NET_URL.assertTrue(true);
        }
        HttpRequest request = HttpRequest.newBuilder()
                .uri(uri)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(json, StandardCharsets.UTF_8))
                .build();
        log.info("url:"+request.uri());
        log.info("reqData:"+json);
        HttpResponse<String> response = null;
        try {
            response = client.send(request, HttpResponse.BodyHandlers.ofString());
            log.info("Status code: " + response.statusCode());
            log.info("Response body: " + response.body());
            if (response.statusCode()==404){
                CommonResponseEnum.BAD_NET_CONNECT.assertTrue(true);
            }
        } catch (IOException e) {
            CommonResponseEnum.BAD_NET_CONNECT.assertTrue(true);
        } catch (InterruptedException e) {
            CommonResponseEnum.NET_DISCONNECT.assertTrue(true);
        }
        return JsonUtils.jsonToMap(response.body());
    }

    public static Map<String, Object>  sendHttpGet(Map<String,String> map,String url) {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1)
                .connectTimeout(Duration.ofSeconds(timeout))
                .build();

        AtomicInteger i= new AtomicInteger();
        StringBuilder strb= new StringBuilder(url);
        map.forEach((k,v)->{
            if (i.get() ==0){
                strb.append("?");
            }else {
                strb.append("&");
            }
            strb.append(k).append("=");
            if (StringUtils.isNotBlank(v)){
                strb.append(v);
            }
            i.getAndIncrement();
        });

        URI uri= null;
        try {
            log.info("url:"+strb);
            uri = URI.create(strb.toString());
        } catch (Exception e) {
            CommonResponseEnum.BAD_NET_URL.assertTrue(true);
        }

        HttpRequest request = HttpRequest.newBuilder()
                .uri(uri)
                .GET()
                .build();

        HttpResponse<String> response = null;
        try {
            response = client.send(request, HttpResponse.BodyHandlers.ofString());
            log.info("Status code: " + response.statusCode());
            log.info("Response body: " + response.body());
            if (response.statusCode()==404){
                CommonResponseEnum.BAD_NET_CONNECT.assertTrue(true);
            }
        } catch (IOException e) {
            CommonResponseEnum.BAD_NET_CONNECT.assertTrue(true);
        } catch (InterruptedException e) {
            CommonResponseEnum.NET_DISCONNECT.assertTrue(true);
        }
        return JsonUtils.jsonToMap(response.body());
    }
}

controller

java
    @Operation(summary = "test")
    @SaIgnore
    @GetMapping("test")
    public ApiResult<List<Object>> test(@RequestParam String name) {
        Map<String,String> map=new HashMap<>();
        map.put("name",name);

        Map<String,Object> result= HttpUtils.sendHttp(map, AlgoInterfaceEnum.启动关闭模型.getUrl(),AlgoInterfaceEnum.启动关闭模型.getRestful());
        return ApiResult.success(ListUtil.toList(result.get("obj")));
    }

目录