Java中常见的HttpClient调用方式

最新推荐文章于 2024-08-04 10:00:00 发布
最新推荐文章于 2024-08-04 10:00:00 发布
阅读量3.3k 收藏 12
点赞数 4
分类专栏： 面试准备 文章标签： OkHttp3 RestTemplate HttpClient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenwiehuang/article/details/126735175
版权

1. 背景

在Java应用开发中，服务暴露接口的方式分为rpc和http两种方式。优雅的httpClient封装不仅能让程序work得更好，也能在一定程度上有性能优化。Java项目中调用第三方接口的方式有：

  • 通过JDK网络类Java.net.HttpURLConnection
  • 通过common封装HttpClient
  • Springboot提供的RestTemplate.

各种方式的优缺点和适用范式，下面一一道来。

2. HttpClient的封装调用范式

2.1 HttpURLConnection

缺点：不能直接使用池化技术，需要自行处理输入输出流

package com.book.xw.web.util;

import org.springframework.lang.Nullable;
 
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
 

public class HttpClientUtil {
 
    /**
     * http get请求，参数拼接在URL上
     */
    public static String doGet(String httpUrl){
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        StringBuffer result = new StringBuffer();
        try {
            //创建连接
            URL url = new URL(httpUrl);
            connection = (HttpURLConnection) url.openConnection();
            //设置请求方式
            connection.setRequestMethod("GET");
            //设置连接超时时间
            connection.setReadTimeout(15000);
            //开始连接
            connection.connect();
            //获取响应数据
            if (connection.getResponseCode() == 200) {
                //获取返回的数据
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    String temp = null;
                    while (null != (temp = br.readLine())) {
                        result.append(temp);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //关闭远程连接
            connection.disconnect();
        }
        return result.toString();
    }
 
    /**
     * Http post请求
     */
    public static String doPost(String httpUrl, String param) {
        StringBuffer result = new StringBuffer();
        //连接
        HttpURLConnection connection = null;
        OutputStream os = null;
        InputStream is = null;
        BufferedReader br = null;
        try {
            //创建连接对象
            URL url = new URL(httpUrl);
            //创建连接
            connection = (HttpURLConnection) url.openConnection();
            //设置请求方法
            connection.setRequestMethod("POST");
            //设置连接超时时间
            connection.setConnectTimeout(15000);
            //设置读取超时时间
            connection.setReadTimeout(15000);
            //DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
            //设置是否可读取
            connection.setDoOutput(true);
            connection.setDoInput(true);
            //设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("Content-Type","application/json;charset=utf-8");
 
            //拼装参数
            if (null != param && !param.equals("")) {
                //设置参数
                os = connection.getOutputStream();
                //拼装参数
                os.write(param.getBytes("UTF-8"));
            }
            
            //connection.connect();
            //读取响应
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "GBK"));
                    String temp = null;
                    while (null != (temp = br.readLine())) {
                        result.append(temp);
                        result.append("\r\n");
                    }
                }
            }
 
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //关闭连接
            connection.disconnect();
        }
        return result.toString();
    }
}

2.2 apache common封装HttpClient

引入Apache的commons jar包：

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

每次调用会创建一个httpClient对象，并且需要手动释放连接。 

public class HttpClientUtil {
    public static String doGet(String url, String charset) {
        //1.生成HttpClient对象并设置参数
        HttpClient httpClient = new HttpClient();
        //设置Http连接超时为5秒
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
        //2.生成GetMethod对象并设置参数
        GetMethod getMethod = new GetMethod(url);
        //设置get请求超时为5秒
        getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
        //设置请求重试处理，用的是默认的重试处理：请求三次
        getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
        String response = "";
        //3.执行HTTP GET 请求
        try {
            int statusCode = httpClient.executeMethod(getMethod);
            //4.判断访问的状态码
            if (statusCode != HttpStatus.SC_OK) {
                System.err.println("请求出错：" + getMethod.getStatusLine());
            }
            //5.处理HTTP响应内容
            //HTTP响应头部信息，这里简单打印
            Header[] headers = getMethod.getResponseHeaders();
            for(Header h : headers) {
                System.out.println(h.getName() + "---------------" + h.getValue());
            }
            //读取HTTP响应内容，这里简单打印网页内容
            //读取为字节数组
            byte[] responseBody = getMethod.getResponseBody();
            response = new String(responseBody, charset);
            System.out.println("-----------response:" + response);
            //读取为InputStream，在网页内容数据量大时候推荐使用
            //InputStream response = getMethod.getResponseBodyAsStream();
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            //发生网络异常
            System.out.println("发生网络异常!");
        } finally {
            //6.释放连接
            getMethod.releaseConnection();
        }
        return response;
    }
    
    public static String doPost(String url, JSONObject json){
        HttpClient httpClient = new HttpClient();
        PostMethod postMethod = new PostMethod(url);

        postMethod.addRequestHeader("accept", "*/*");
        postMethod.addRequestHeader("connection", "Keep-Alive");
        //设置json格式传送
        postMethod.addRequestHeader("Content-Type", "application/json;charset=GBK");
        //添加请求参数
        postMethod.addParameter("xxx", json.getString("xxx"));

        String res = "";
        try {
            int code = httpClient.executeMethod(postMethod);
            if (code == 200){
                res = postMethod.getResponseBodyAsString();
                System.out.println(res);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            postMethod.releaseConnection();
        }
        return res;
    }
}

2.3 CloseableHttpClient

相比较HttpClient而言，可以使用连接池保持连接，并且过期自动释放。引入jar包

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.2</version>
</dependency>

package com.book.xw.common.util.utils;

import com.alibaba.fastjson.JSON;
import org.apache.http.Header;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

public class HttpCloseableClient {
    // 池化管理
    private static PoolingHttpClientConnectionManager poolConnManager = null;
    // 它是线程安全的，所有的线程都可以使用它一起发送http请求
    private static CloseableHttpClient httpClient;
    static {
        try {
            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
            // 配置同时支持 HTTP 和 HTPPS
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslsf).build();
            // 初始化连接管理器
            poolConnManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            // 同时最多连接数
            poolConnManager.setMaxTotal(640);
            // 设置最大路由
            poolConnManager.setDefaultMaxPerRoute(320);
            // 初始化httpClient
            httpClient = getConnection();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
    }

    public static CloseableHttpClient getConnection() {
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000)
                .setConnectionRequestTimeout(5000).setSocketTimeout(5000).build();
        CloseableHttpClient httpClient = HttpClients.custom()
                // 设置连接池管理
                .setConnectionManager(poolConnManager)
                .setDefaultRequestConfig(config)
                // 设置重试次数
                .setRetryHandler(new DefaultHttpRequestRetryHandler(2, false)).build();
        return httpClient;
    }

    public static String httpGet(String url) {
        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpGet);
            String result = EntityUtils.toString(response.getEntity());
            int code = response.getStatusLine().getStatusCode();
            if (code == HttpStatus.SC_OK) {
                return result;
            } else {
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    public static String post(String uri, Object params, Header... heads) {
        HttpPost httpPost = new HttpPost(uri);
        CloseableHttpResponse response = null;
        try {
            StringEntity paramEntity = new StringEntity(JSON.toJSONString(params));
            paramEntity.setContentEncoding("UTF-8");
            paramEntity.setContentType("application/json");
            httpPost.setEntity(paramEntity);
            if (heads != null) {
                httpPost.setHeaders(heads);
            }
            response = httpClient.execute(httpPost);
            int code = response.getStatusLine().getStatusCode();
            String result = EntityUtils.toString(response.getEntity());
            if (code == HttpStatus.SC_OK) {
                return result;
            } else {
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

 2.4 OkHttp3

pom文件引入依赖包

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.10.0</version>
</dependency>

@Slf4j
public class OkHttpClient {
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
 
    private volatile static okhttp3.OkHttpClient client;
 
    private static final int MAX_IDLE_CONNECTION = Integer
            .parseInt(ConfigManager.get("httpclient.max_idle_connection"));
 
    private static final long KEEP_ALIVE_DURATION = Long
            .parseLong(ConfigManager.get("httpclient.keep_alive_duration"));
 
    private static final long CONNECT_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient.connectTimeout"));
 
    private static final long READ_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient. "));
 
    /**
     * 单例模式(双重检查模式) 
     */
    private static okhttp3.OkHttpClient getInstance() {
        if (client == null) {
            synchronized (okhttp3.OkHttpClient.class) {
                if (client == null) {
                    client = new okhttp3.OkHttpClient.Builder()
                            .connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
                            .readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
                            .connectionPool(new ConnectionPool(MAX_IDLE_CONNECTION, KEEP_ALIVE_DURATION, TimeUnit.MINUTES))
                            .build();
                }
            }
        }
        return client;
    }
 
    public static String doPost(String url, String json) throws IOException {
        RequestBody body = RequestBody.create(JSON, json);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        try {
            Response response = OkHttpClient.getInstance().newCall(request).execute();
            if (response.isSuccessful()) {
                String result = response.body().string();
                log.info("syncPost response = {}, responseBody= {}", response, result);
                return result;
            }
            String result = response.body().string();
            log.info("syncPost response = {}, responseBody= {}", response, result);
            throw new IOException("三方接口返回http状态码为" + response.code());
        } catch (Exception e) {
            log.error("syncPost() url:{} have a ecxeption {}", url, e);
            throw new RuntimeException("syncPost() have a ecxeption {}" + e.getMessage());
        }
    }
 
    public static String doGet(String url, Map<String, Object> headParamsMap) throws IOException {
        Request request;
        final Request.Builder builder = new Request.Builder().url(url);
        try {
            if (!CollectionUtils.isEmpty(headParamsMap)) {
                final Iterator<Map.Entry<String, Object>> iterator = headParamsMap.entrySet()
                        .iterator();
                while (iterator.hasNext()) {
                    final Map.Entry<String, Object> entry = iterator.next();
                    builder.addHeader(entry.getKey(), (String) entry.getValue());
                }
            }
            request = builder.build();
            Response response = OkHttpClient.getInstance().newCall(request).execute();
            String result = response.body().string();
            log.info("syncGet response = {},responseBody= {}", response, result);
            if (!response.isSuccessful()) {
                throw new IOException("三方接口返回http状态码为" + response.code());
            }
            return result;
        } catch (Exception e) {
            log.error("remote interface url:{} have a ecxeption {}", url, e);
            throw new RuntimeException("三方接口返回异常");
        }
    }
 
}

 2.5 RestTemplate

// 先声明bean
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
        return new RestTemplate(factory);
    }
    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}

其余地方直接使用API即可：

image-20220415205801633

西木风落
关注
专栏目录
java 中httpclient_Java中HttpClient的用法
weixin_36081299的博客
02-13 1万+
package study.httpclient;import org.apache.http.HttpEntity;import org.apache.http.NameValuePair;import org.apache.http.ParseException;import org.apache.http.client.ClientProtocolException;import org.a...
JAVA调用HTTP及httpclient的详细说明
11-02
JAVA调用HTTP及httpclient的详细说明,包括HttpClient Post/GetMethod 转码方案汇总,使用httpclient实现http接口调用实例,含具体代码
JAVA --- HttpClient
最新发布
xycxycooo的博客
08-04 489
HttpClient是 Apache Jakarta Common 下的子项目，提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。发送 HTTP 请求接收响应数据为什么要在 Java 程序中发送 HTTP 请求？在现代应用开发中，很多功能（如扫描支付、查看地图、获取验证码、查看天气等）都是通过访问外部服务来实现的。这些服务通常通过 HTTP 协议提供，因此需要在应用程序中发送 HTTP 请求并接收响应数据。
java中HttpClient使用【含例子】
分享技术，分享经验
05-03 2477
但是，如果你在使用Java 11之前的版本，并且想要使用类似的功能，你可能需要引入第三方库的依赖，如Apache HttpClient。通过HttpRequest对象，您可以设置请求的URL、请求方法、请求头、请求体等信息，并构建一个完整的HTTP请求对象，用于发送给服务器。它提供了一种简单且一致的方式来执行HTTP操作，包括同步和异步的请求发送、连接池管理、请求和响应的拦截器等功能。被设计成与Java平台更好地集成，使得开发者能够更轻松地处理HTTP请求和响应，同时减少了对外部库的依赖。
HttpClient使用详解
cihongmo6452的博客
08-01 856
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因...
httpclient使用实例
HF6787966的博客
10-16 590
导读：本文向我们介绍了如何用httpclient发送Http请求，并举例获取我们项目所在git以及sonar上的数据。   内容： Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性，它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性
java httpclient使用
八十岁老将的博客
05-04 204
1、快速使用 CloseableHttpClient client = HttpClients.custom() .setDefaultCookieStore(new BasicCookieStore()).build(); String uuid = UUID.randomUUID().toString().toUpperCase(); String url = "https://passport.baidu.com/v2/api/qrcode?sign=" + uuid + "&lp=p
JAVA利用HttpClient进行HTTPS接口调用的方法
08-29
Java中使用HttpClient进行HTTPS接口调用的方法是通过继承DefaultHttpClient类，忽略证书校验过程。首先，创建一个SSLClient类，继承DefaultHttpClient类，并在构造函数中初始化SSLContext和TrustManager。然后，使用...
httpClient调用wcf
12-14
3. **HttpClient调用**：在Java端，引入HttpClient库及相关依赖（如本例中的`httpclient-4.2.3.jar`等）。使用HttpClient，你可以创建一个`HttpClient`实例，然后构建`HttpGet`或`HttpPost`对象，设置请求URL（对应...
java web中 HttpClient模拟浏览器登录后发起请求
08-30
Java Web 中 HttpClient 模拟浏览器登录后发起请求 Java Web 中 HttpClient 模拟浏览器登录后发起请求是指在 Java Web 应用程序中使用 HttpClient 库模拟浏览器的行为，模拟浏览器登录到服务器，然后发起请求获取...
JAVA利用HttpClient进行HTTPS接口调用
09-14
在这个主题中，我们将深入探讨如何在Java中使用HttpClient来实现HTTPS接口调用。 首先，我们需要理解HTTPS协议。HTTPS是HTTP（超文本传输协议）与SSL/TLS（安全套接层/传输层安全）的结合，它为数据传输提供了加密...
java使用httpclient发送post请求示例
09-04
主要介绍了java使用httpclient发送post请求示例,依赖JSON、HTTPClient等jar包,需要的朋友可以参考下
httpclient调用接口demo
12-01
本demo有两个例子test是作为服务端开启的，httpclient是客户端调用的，模拟服务端的test在启动后是没有界面的，要加上id才能看到json数据，httpclient的HttpClient33.java是测试类，最后的结果是接受到一个对象。...
java使用HttpClient
dianmie4090的博客
11-16 201
HttpClient常用的包有两个 org.apache.http.client以及org.apache.commons.httpclient 我常用的是org.apache.http.client。 HttpClient在4.3版本以后声明HttpClient的方法和以前略有区别，不再是直接声明new DefaultHttpClient() . 参考下文： new Defau...
JAVA实现HTTP请求 之 HTTPClient
热门推荐
WYP123456L的博客
12-17 1万+
一、目前JAVA实现HTTP请求的方法用的最多的有两种：通过HTTPClient这种第三方开源框架去实现。HTTPClient对HTTP的封装性比较不错，基本上能够满足我们大部分的需求，最新的HttpClient4.5是org.apache.http.impl.client下操作远程 url的工具包；HttpClient3.1 是 org.apache.commons.httpclient下操作远程 url的工具包，虽然已不再更新，但实现工作中使用httpClient3.1的代码还是有不少的.另一种则是通过
httpClient(JAVA)
有点想法的专栏
05-11 6963
文章目录1.介绍1.1 主要功能1.2 步骤2.使用2.1 get访问(不带参数)2.2 get访问(带参数)2.3 post访问(不带参数)2.4 post访问(带参数)2.5 连接池2.6 请求参数配置参考 1.介绍 1.1 主要功能 1.实现了所有HTTP的方法（get、post、put、head等） 2.支持自动转向 3.支持代理服务器 4.自动处理set-cookie中的cookie 5...
httpclient的使用（java）
韩利鹏
01-10 1547
httpclient主要用途，系统间的调用，一个系统使用http协议调用另一个系统的服务（web service），当然也可以做网页爬虫（爬虫推荐使用jsoup）0：添加maven依赖 <!-- httpclient依赖 --> <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient --
java httpclient 使用_java之HttpClient简单使用
weixin_35805266的博客
02-21 2178
最近在做微信公众号开发，需要用java代码访问微信端接口来请求数据。由于博主java的网络通信也不是很精通，只是粗略了解皮毛，等以后知识上来了再深入研究java的网络编程。所以这篇文章就先介绍简单使用。需要的jar包：org.apache.httpcomponentshttpclient4.3.6org.apache.httpcomponentshttpcore4.4本篇博客分为几块部分：http...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值