盘点 Java Code 中 Apache HttpClient、OkHttp、Retrofi、Spring RestTemplate、Jersey/JAX-RS 发送请求，以及他们的xxxUtils

Apache HttpClient：这是一个广泛使用的 HTTP 客户端库，提供了更高级和灵活的功能。它提供了易用的 API 来发送各种类型的 HTTP 请求，并支持设置请求头部、处理响应等

OkHttp：OkHttp 是一个流行的现代化 HTTP 客户端库，具有高效和简洁的 API。它提供了线程安全的连接管理、缓存、自动重试等功能。

Retrofit：Retrofit 是基于 OkHttp 的一个网络请求框架，它通过注解和动态代码生成来简化 HTTP 请求的创建和处理。

Spring RestTemplate：如果你的项目使用了 Spring 框架，Spring RestTemplate 提供了一种方便的方式发送 HTTP 请求，并集成了一些常用的功能和特性

Jersey/JAX-RS：Jersey 是 JAX-RS（Java API for RESTful Web Services）的实现，它提供了基于注解的方式来定义和发送 RESTful 风格的 HTTP 请求。

废话不多说直接上手撸：

API 操作步骤：

1. 导入相关依赖  2. 创建他们各自的实例  3. 创建 他们各自的 HttpRequestBase

4. 设置请求头部  5. 执行请求  6. 处理响应  7. 关闭资源     

1. 以下是 Apache HttpClient 工具类示例，用于发送 POST 请求

import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;

import java.io.IOException;

public class HttpClientUtils {

    // 发送 POST 请求的方法
    public static String sendHttpPostRequest(String url, String requestBody, String contentType) throws IOException {
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        HttpClient httpClient = httpClientBuilder.build();

        HttpPost httpPost = new HttpPost(url);
        StringEntity stringEntity = new StringEntity(requestBody, ContentType.parse(contentType));
        httpPost.setEntity(stringEntity);

        HttpResponse httpResponse = httpClient.execute(httpPost);
        int statusCode = httpResponse.getStatusLine().getStatusCode();

        // 处理响应
        if (statusCode == 200) {
            return EntityUtils.toString(httpResponse.getEntity(), "UTF-8");
        } else {
            throw new IOException("请求失败，状态码: " + statusCode);
        }
    }

    // 主函数示例
    public static void main(String[] args) throws IOException {
        String url = "http://example.com/api";
        String requestBody = "{\"key1\":\"value1\", \"key2\":\"value2\"}";
        String contentType = "application/json";

        String response = sendHttpPostRequest(url, requestBody, contentType);
        System.out.println("响应: " + response);
    }
}

在上述示例中，sendHttpPostRequest方法接受请求的 URL、请求体和内容类型作为参数。它创建了 HttpClient 对象，并设置了 POST 请求和请求体。然后执行请求，并根据响应的状态码处理结果。如果状态码为 200，表示请求成功，返回响应的字符串内容。否则，抛出 IOException 异常。

在main方法中，你可以提供实际的 URL、请求体和内容类型来进行测试。

请注意，这只是一个简单的工具类示例，可能需要根据你的具体需求进行更多的错误处理、配置和扩展。此外，确保在使用 HttpClient 时正确处理资源的释放和关闭。

还要注意，根据你的具体环境和项目设置，可能需要引入 Apache HttpClient 的相关依赖，并在构建工具（如 Maven）中进行配置。

2. 以下是一个使用 OkHttp 发送 POST 请求的工具类示例：

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.io.IOException;

public class OkHttpUtils {

    // 发送 POST 请求的方法
    public static String sendPostRequest(String url, String requestBody) throws IOException {
        OkHttpClient client = new OkHttpClient();

        // 创建 POST 请求
        Request request = new Request.Builder()
               .url(url)
               .post(RequestBody.create(ContentType.parse("application/json"), requestBody))
               .build();

        // 执行请求
        Response response = client.newCall(request).execute();

        // 检查响应状态码
        if (response.isSuccessful()) {
            return response.body().string();
        } else {
            throw new IOException("请求失败，状态码: " + response.code());
        }
    }

    // 主函数示例
    public static void main(String[] args) throws IOException {
        String url = "http://example.com/api";
        String requestBody = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

        String response = sendPostRequest(url, requestBody);
        System.out.println("响应: " + response);
    }
}

在上述示例中，sendPostRequest方法接受请求的 URL 和请求体作为参数。它创建了一个 OkHttpClient 对象，并使用RequestBuilder 创建了一个 POST 请求。然后通过client.newCall(request).execute()执行请求，并根据响应的状态码处理结果。如果响应成功，返回响应体的字符串内容。否则，抛出 IOException 异常。

在main方法中，你可以提供实际的 URL 和请求体来进行测试。

请确保已将 OkHttp 库添加到项目的依赖管理中。根据你使用的构建工具（如 Maven 或 Gradle），可以在相应的配置文件中添加对 OkHttp 的依赖。

这只是一个简单的工具类示例，你可以根据实际需求进行更多的错误处理、配置和扩展。OkHttp 提供了丰富的 API 和功能，例如设置请求头、处理回调、进行异步请求。

3. Retrofit 是一个流行的 Android 网络请求框架，它基于 OkHttp 并提供了更简洁、灵活的 API。以下是一个使用 Retrofit 创建工具类的示例： 

import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {

    // 单例 Retrofit 对象
    private static Retrofit retrofit;

    // 获取 Retrofit 实例的方法
    public static Retrofit getInstance() {
        if (retrofit == null) {
            OkHttpClient httpClient = new OkHttpClient.Builder().build();
            retrofit = new Retrofit.Builder()
                   .baseUrl("http://example.com/")
                   .addConverterFactory(GsonConverterFactory.create())
                   .client(httpClient)
                   .build();
        }
        return retrofit;
    }

    // 创建服务接口的方法
    public <T> T createService(Class<T> serviceClass) {
        return getInstance().create(serviceClass);
    }
}

在上述示例中，RetrofitClient类包含一个单例的 Retrofit 对象。getInstance方法用于获取 Retrofit 实例，并在首次调用时进行初始化。在初始化过程中，设置了基础 URL 和 Gson 转换器。

public class YourApiService {

    // 调用 Retrofit 工具类创建服务实例
    private YourApiServiceInterface yourApiService = RetrofitClient.createService(YourApiServiceInterface.class);

    // 使用服务实例进行网络请求
    public void performNetworkRequest() {
        yourApiService.someMethod("param1", "param2");
    }
}

createService方法用于根据给定的服务接口类创建具体的服务实例。你可以通过传递服务接口类来获取相应的服务对象。

4. 以下是一个使用 Spring RestTemplate 发送 POST 请求的工具类示例：

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class RestTemplateUtils {

    // 发送 POST 请求的方法
    public static ResponseEntity<String> sendHttpPostRequest(String url, Object requestBody) {
        RestTemplate restTemplate = new RestTemplate();

        // 创建 HttpEntity 对象
        HttpEntity<?> httpEntity = new HttpEntity<>(requestBody);

        // 执行 POST 请求
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);

        return response;
    }

    // 主函数示例
    public static void main(String[] args) {
        String url = "http://example.com/api";
        Object requestBody = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

        ResponseEntity<String> response = sendHttpPostRequest(url, requestBody);
        // 处理响应
        if (response.getBody()!= null) {
            System.out.println("响应: " + response.getBody());
        }
    }
}

在上述示例中，sendHttpPostRequest方法接受请求的 URL 和请求体对象作为参数。它使用 RestTemplate 发送 POST 请求，并返回包含响应内容的 ResponseEntity 对象。

在main方法中，你可以提供实际的 URL 和请求体对象来进行测试。

请确保已将 Spring RestTemplate 相关的依赖添加到项目中。通常，在使用 Spring 框架的项目中， RestTemplate 会自动可用。

这只是一个简单的工具类示例，你可以根据实际需求进行更多的错误处理、响应解析和扩展。例如，根据响应的状态码进行不同的处理，或者将响应内容转换为特定的对象。

5. 以下是一个使用 Jersey/JAX-RS 发送 POST 请求的工具类示例：

首先，确保你已经在项目中添加了 Jersey 的相关依赖。以下是一个基本的依赖配置示例：

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Response;

public class JerseyClientUtils {

    // 发送 POST 请求的方法
    public static Response sendHttpPostRequest(String baseUrl, String path, Object entity) {
        Client client = ClientBuilder.newClient();
        Response response = client.target(baseUrl)
               .path(path)
               .request()
               .post(Entity.entity(entity, "application/json"));

        return response;
    }

    // 主函数示例
    public static void main(String[] args) {
        String baseUrl = "http://example.com";
        String path = "/api";
        Object entity = "{\"key1\":\"value1\", \"key2\":\"value2\"}";

        Response response = JerseyClientUtils.sendHttpPostRequest(baseUrl, path, entity);
        // 处理响应
        if (response.getStatus() == 200) {
            // 处理成功的响应
        } else {
            // 处理失败的响应
        }
    }
}

在上述示例中，sendHttpPostRequest方法接受基础 URL、路径和要发送的实体对象作为参数。它使用ClientBuilder.newClient()创建一个Jersey 客户端，并使用client.target()指定请求的目标 URL。然后，通过post(Entity.entity(entity, "application/json"))发送 POST 请求，并返回响应对象。

在main方法中，你可以提供实际的基础 URL、路径和实体对象来进行测试。

请注意，这只是一个简单的工具类示例，可能需要根据你的具体需求进行更多的错误处理、响应解析和扩展。例如，根据响应的状态码进行不同的处理，或者将响应内容转换为特定的对象。

此外，Jersey 提供了丰富的 API 和功能，你可以根据需要进行更复杂的请求设置、头部处理、认证等操作。