HTTP Component (Apache HttpClient) 5.0 + 教程

已于 2022-10-21 08:50:24 修改
阅读量1.5k 收藏
点赞数 2
分类专栏： Java基础 杂项 文章标签： http java apache
于 2022-08-12 09:08:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yh4494/article/details/126296672
版权

文件上传下载系列
HTTP Component 5.0 + 教程

在这里插入图片描述

介绍

超文本传输​​协议 (HTTP) 可能是当今 Internet 上使用的最重要的协议。 Web 服务、支持网络的设备和网络计算的增长继续将 HTTP 协议的作用扩展到用户驱动的 Web 浏览器之外，同时增加了需要 HTTP 支持的应用程序的数量。 尽管 java.net 包提供了通过 HTTP 访问资源的基本功能，但它并没有提供许多应用程序所需的全部灵活性或功能。 HttpClient 旨在通过提供高效、最新且功能丰富的包来实现最新 HTTP 标准和建议的客户端来填补这一空白。 为扩展而设计，同时为基本 HTTP 协议提供强大的支持，任何构建 HTTP 感知客户端应用程序（如 Web 浏览器、Web 服务客户端或利用或扩展 HTTP 协议进行分布式通信的系统）的任何人都可能对 HttpClient 感兴趣。

MAVEN 引用

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.1.3</version>
</dependency>

使用示例

同步

package com.allens.http.pool;

/**
 * HttpClientUtil
 *
 * @author 澄风
 * @date 2021/6/21
 */
@SuppressWarnings("all")
public class HttpClientUtil {

    private static CloseableHttpClient httpClient = null;

    static {

        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        // 总连接池连接数量
        connectionManager.setMaxTotal(1500);
        // socket config 可自定义
        // httpclient 现在的默认socket超时时间是3分钟，如果需要调整请自己定义socket config进行定义
        // private static final Timeout DEFAULT_SOCKET_TIMEOUT = Timeout.ofMinutes(3);
        connectionManager.setDefaultSocketConfig(SocketConfig.DEFAULT);

        // 可为每个域名设置最大的并行连接数量
        // connectionManager.setMaxPerRoute(new HttpRoute(new HttpHost("xx.xx.xx.xx")), 80);
        connectionManager.setDefaultMaxPerRoute(100);


        // setConnectTimeout：设置建立连接的超时时间
        // setConnectionRequestTimeout：从连接池中拿连接的等待超时时间
        // setSocketTimeout：发出请求后等待对端应答的超时时间
        RequestConfig requestConfig = RequestConfig.custom()
                // 保持长连接
                .setConnectionKeepAlive(TimeValue.of(600, TimeUnit.SECONDS))
                // 连接超时时间
                .setConnectTimeout(Timeout.of(1000, TimeUnit.SECONDS))
                // 请求超时时间
                .setConnectionRequestTimeout(Timeout.of(1000, TimeUnit.SECONDS))
                // 和上面二选一
                // .setDefaultKeepAlive(1000, TimeUnit.SECONDS)
                .build();

        // 重试处理器，StandardHttpRequestRetryHandler
        // HttpRequestRetryHandler retryHandler = new StandardHttpRequestRetryHandler();

        // BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // credentialsProvider.setCredentials(new AuthScope());

        httpClient = HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setDefaultRequestConfig(requestConfig)
                // .setDefaultCredentialsProvider(credentialsProvider)
                // .setRetryHandler(retryHandler)
                .build();
    }

    /**
     * GET请求
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static String doHttpGet(String uri, Map<String, String> getParams) {
        TestUtils testUtils = new TestUtils();
        String s = testUtils.testSome();
        System.out.println(s);
        CloseableHttpResponse response = null;
        try {
            URIBuilder uriBuilder = new URIBuilder(uri);
            if (null != getParams && !getParams.isEmpty()) {
                List<NameValuePair> list = new ArrayList<>();
                for (Map.Entry<String, String> param : getParams.entrySet()) {
                    list.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                uriBuilder.setParameters(list);
            }
            HttpGet httpGet = new HttpGet(uriBuilder.build());
            response = httpClient.execute(httpGet);
            int statusCode = response.getCode();
            if (HttpStatus.SC_OK == statusCode) {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    String resStr = EntityUtils.toString(entity, "utf-8");
                    return resStr;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            // log.error("CloseableHttpClient-get-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return "FAIL:NO CONTENT";
    }

    /**
     * GET请求
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static JSONObject doHttpDelete(String uri, Map<String, String> getParams) {
        TestUtils testUtils = new TestUtils();
        String s = testUtils.testSome();
        System.out.println(s);
        CloseableHttpResponse response = null;
        try {
            URIBuilder uriBuilder = new URIBuilder(uri);
            if (null != getParams && !getParams.isEmpty()) {
                List<NameValuePair> list = new ArrayList<>();
                for (Map.Entry<String, String> param : getParams.entrySet()) {
                    list.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                uriBuilder.setParameters(list);
            }
            HttpDelete httpDelete = new HttpDelete(uriBuilder.build());
            response = httpClient.execute(httpDelete);
            int statusCode = response.getCode();
            if (HttpStatus.SC_OK == statusCode) {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    String resStr = EntityUtils.toString(entity, "utf-8");
                    return JSON.parseObject(resStr);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            // log.error("CloseableHttpClient-get-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new JSONObject();
    }

    /**
     * 下载文件
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static void doHttpGetForFile(String uri,
                                        Map<String, String> getParams,
                                        Map<String, String> headers,
                                        long offset,
                                        File destFile) {
        CloseableHttpResponse response = null;
        long countLong = 0;
        try {
            URIBuilder uriBuilder = new URIBuilder(uri);
            if (null != getParams && !getParams.isEmpty()) {
                List<NameValuePair> list = new ArrayList<>();
                for (Map.Entry<String, String> param : getParams.entrySet()) {
                    list.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                uriBuilder.setParameters(list);
            }

            HttpGet httpGet = new HttpGet(uriBuilder.build());
            Optional.ofNullable(headers).ifPresent(data -> {
                data.forEach((k,v) -> {
                    httpGet.addHeader(k, v);
                });
            });

            response = httpClient.execute(httpGet);
            int statusCode = response.getCode();

            Header header = response.getHeader("Content-Length");

            if (HttpStatus.SC_OK == statusCode || HttpStatus.SC_PARTIAL_CONTENT == statusCode) {
                HttpEntity entity = response.getEntity();

                if (null != entity) {
                    try (InputStream content = entity.getContent();
                         FileOutputStream fileOutputStream = new FileOutputStream(destFile, true);
                         OutputStream out = new BufferedOutputStream(fileOutputStream)) {
                        byte[] buffer = new byte[102400]; // 100K
                        int length = 0;
                        while ((length = content.read(buffer, 0, buffer.length)) != -1) {
                            countLong += length;
                            out.write(buffer, 0, length);
                            //Thread.sleep(100);
                            //break;
                        }
                        System.out.println("Count long :" + countLong);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } else if (HttpStatus.SC_ACCEPTED == statusCode) {
                System.out.println("已经下载过了，请勿重新下载...");
            }
        } catch (Exception e) {
            e.printStackTrace();
            // log.error("CloseableHttpClient-get-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * post表单提交
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static JSONObject doHttpPostForForm(String uri, Map<String, String> getParams) {
        CloseableHttpResponse response = null;
        try {
            HttpPost httpPost = new HttpPost(uri);
            if (null != getParams && !getParams.isEmpty()) {
                List<NameValuePair> list = new ArrayList<>();
                for (Map.Entry<String, String> param : getParams.entrySet()) {
                    list.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                HttpEntity httpEntity = new UrlEncodedFormEntity(list, StandardCharsets.UTF_8);
                httpPost.setEntity(httpEntity);
            }
            response = httpClient.execute(httpPost);
            int statusCode = response.getCode();
            if (HttpStatus.SC_OK == statusCode) {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    String resStr = EntityUtils.toString(entity, "utf-8");
                    return JSON.parseObject(resStr);
                }
            }
        } catch (Exception e) {
            // log.error("CloseableHttpClient-post-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new JSONObject();
    }

    /**
     * post body请求
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static JSONObject doHttpPost(String uri, Map<String, String> getParams, Map<String, String> headers) {
        CloseableHttpResponse response = null;
        try {
            HttpPost httpPost = new HttpPost(uri);
            String queryString = JSON.toJSONString(getParams, SerializerFeature.valueOf("utf-8"));
            StringEntity stringEntity = new StringEntity(queryString);
            httpPost.setEntity(stringEntity);
            // 设置header
            Optional.ofNullable(headers).ifPresent(data -> data.forEach(httpPost::setHeader));

            response = httpClient.execute(httpPost);
            int statusCode = response.getCode();
            if (HttpStatus.SC_OK == statusCode) {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    String resStr = EntityUtils.toString(entity, "utf-8");
                    return JSON.parseObject(resStr);
                }
            }
        } catch (Exception e) {
            // log.error("CloseableHttpClient-post-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new JSONObject();
    }

    /**
     * 上传文件表单
     *
     * @param uri
     * @param getParams
     * @return
     */
    public static String doHttpPostForFormMutipart(String uri, Map<String, String> getParams, File file) {
        CloseableHttpResponse response = null;
        try {
            HttpPost httpPost = new HttpPost(uri);
            // httpPost.setHeader(new BasicHeader("Content-Type", "multipart/form-data"));
            if (null != getParams && !getParams.isEmpty()) {
                List<NameValuePair> list = new ArrayList<>();
                for (Map.Entry<String, String> param : getParams.entrySet()) {
                    list.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
            }
            MultipartPart multipartPart = MultipartPartBuilder
                    .create()
                    .setBody(new FileBody(file, ContentType.IMAGE_JPEG))
                    .addHeader("content-type", "image/jpeg")
                    .build();

            org.apache.hc.core5.http.HttpEntity httpEntity = MultipartEntityBuilder.create()
                    //.addPart(multipartPart)
                    .addPart("file", new FileBody(file, ContentType.IMAGE_JPEG))
                    //.setContentType(ContentType.IMAGE_JPEG)
                    .build();
            // HttpEntity httpEntity = new UrlEncodedFormEntity(list, "utf-8");
            httpPost.setEntity(httpEntity);

            response = httpClient.execute(httpPost);
            int statusCode = response.getCode();
            if (HttpStatus.SC_OK == statusCode) {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    String resStr = EntityUtils.toString(entity, "utf-8");
                    return resStr;
                }
            } else {
                HttpEntity entity = response.getEntity();
                System.out.println(EntityUtils.toString(entity, "utf-8"));
            }
        } catch (Exception e) {
            e.printStackTrace();
             //log.error("CloseableHttpClient-post-请求异常", e);
        } finally {
            try {
                if (null != response)
                    response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new String("NO CONTENT");
    }
}
  • GET请求
    普通GET请求http://xxx.xx?queryParam=xxxxx&a=b
  • 下载文件
    下载文件，支持断点续传，但需要服务器也支持，有兴趣的话可以看我的另一篇文章断点续传。
/**
  * 下载文件
  */
@Test
public void testDownloadFile () {
   Map<String, String> headers = Maps.newHashMap();
   long currentOffset = 0;
   File destFile = new File("/Users/yueyu/Project/allens-learn/download/123456.jpg");
   if (destFile.exists() && destFile.length() > 0) {
       currentOffset = destFile.length();
   }
   // 断点下载的核心
   headers.put("range", "bytes=" + currentOffset + "-");
   HttpClientUtil.doHttpGetForFile(
           // "http://localhost:8091/download/media?id=1631503405304",
           "http://localhost:8091/download/update",
           null,
           headers,
           currentOffset,
           destFile);
}
  • post表单提交
    普通的表单提交content-type=multipart/form-data
  • post body请求
    普通的http body提交content-type=application/json
  • 上传文件表单

异步

/**
 * Example of asynchronous HTTP/1.1 request execution.
 */
public class AsyncClientHttpExchange {

    public static void main(final String[] args) throws Exception {

        final IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
                .setSoTimeout(Timeout.ofSeconds(5))
                .build();

        final CloseableHttpAsyncClient client = HttpAsyncClients.custom()
                .setIOReactorConfig(ioReactorConfig)
                .build();

        client.start();

        final HttpHost target = new HttpHost("httpbin.org");
        final String[] requestUris = new String[] {"/", "/ip", "/user-agent", "/headers"};

        for (final String requestUri: requestUris) {
            final SimpleHttpRequest request = SimpleRequestBuilder.get()
                    .setHttpHost(target)
                    .setPath(requestUri)
                    .build();

            System.out.println("Executing request " + request);
            final Future<SimpleHttpResponse> future = client.execute(
                    SimpleRequestProducer.create(request),
                    SimpleResponseConsumer.create(),
                    new FutureCallback<SimpleHttpResponse>() {

                        @Override
                        public void completed(final SimpleHttpResponse response) {
                            System.out.println(request + "->" + new StatusLine(response));
                            System.out.println(response.getBody());
                        }

                        @Override
                        public void failed(final Exception ex) {
                            System.out.println(request + "->" + ex);
                        }

                        @Override
                        public void cancelled() {
                            System.out.println(request + " cancelled");
                        }

                    });
            future.get();
        }

        System.out.println("Shutting down");
        client.close(CloseMode.GRACEFUL);
    }
}

代理

public void proxy () {
        //创建httpClient实例
        CloseableHttpClient httpClient = HttpClients.createDefault();

		/**
		 * httpClient.getHostConfiguration().setProxy("192.168.101.1", 5608);
		 * httpClient.getParams().setAuthenticationPreemptive(true);
		 * //如果代理需要密码验证，这里设置用户名密码
		 * httpClient.getState().setProxyCredentials(AuthScope.ANY, new UsernamePasswordCredentials("llying.iteye.com","llying"));
		 */
        //创建httpGet实例
        HttpGet httpGet = new HttpGet("http://www.tuicool.com");
        //设置代理IP，设置连接超时时间 、 设置 请求读取数据的超时时间 、 设置从connect Manager获取Connection超时时间、
        HttpHost proxy = new HttpHost("58.60.255.82",8118);
        RequestConfig requestConfig = RequestConfig.custom()
                .setProxy(proxy)
                .setConnectTimeout(Timeout.ofMilliseconds(1000))
                // .setSocketTimeout(10000)
                .setConnectionRequestTimeout(Timeout.ofMilliseconds(3000))
                .build();
        httpGet.setConfig(requestConfig);
        //设置请求头消息
        httpGet.setHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36");
        try {
            CloseableHttpResponse response = null;
            response = httpClient.execute(httpGet);
            if (response != null) {
                HttpEntity entity = response.getEntity();  //获取返回实体
                if (entity != null) {
                    System.out.println("网页内容为:"+ EntityUtils.toString(entity,"utf-8"));
                }
            }
            if (response != null){
                response.close();
            }
            if (httpClient != null){
                httpClient.close();
            }
        } catch (IOException | ParseException e) {
            e.printStackTrace();
        }
}
  • maxDefaultPerRoute 每个路由默认的最大连接数。这里路由的定义是ip+port。ip和port其中一个不一样就是不同的路有。这意味某一个时刻，相同路由的连接数不能超过这个值(这里是每个路由的default值，实际可根据某个路由特殊设置具体的个性化值)。相当于在连接池中又划分一个个路由池。
  • maxTotal: 连接池的总共最大连接数。新的请求进来时，连接池中已有连接不可用时，那就只能新建一个连接，但是如果连接池中连接数已经达到上限，那么无法新建连接，意味着这个请求只能等待。

编程层面上经常会用到几种超时的设置。
1.connection timeout: 属于网络协议上的概念，指的是3次握手建立连接的超时。
2.socket timeout: 属于网络协议上的概念，指的是3次握手建立连接，client 发出请求开始到收到响应的这段时间的超时，其实是read timeout。
3.connection request timeout：在apache http client，这个其实非网络协议上概念，属于自定义，表示的是从连接池获取连接的超时。

参考文章

httpclient的两个重要的参数maxPerRoute及MaxTotal
HttpClient 代理使用 proxy & 异步HttpClient大量请求

澄风
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Apache HttpClient 5 使用详细教程
hebiwen95的博客
08-18 1万+
转存失败重新上传取消超文本传输协议（HTTP）可能是当今互联网上最重要的协议之一，Web 服务、微服务以及支持网络的各种设备上的服务几乎都是 HTTP 协议，HTTP 协议已经从 Web 浏览器走向了更广泛的使用场景。虽然java.net包已经提供了 HTTP 访问资源的基本功能，但是它不够灵活，而且不能随心所欲的进行自定义。...
apache的HttpComponents项目的介绍和简单使用
mao_xiaoxi的博客
04-11 1万+
1、HttpComponents项目的介绍 先介绍一下一个开源项目， 这个项目就是Apache开源组织中的HttpComponents，主要是提供对http服务器的访问功能，目前已经是一个单独的项目，可见http服务器的访问绝非易事。 在某些时候可能需要通过程序来访问这别人的网页程序，比如从别人的网页中“偷”一些数据。如果对方仅仅是一个很简单的页面，那我们的程序会很简单，。但是考虑到一...
OpenFeign修改HttpClient为Apache HttpClient 5
最新发布
tqh267的博客
05-01 928
OpenFeign中http client如果不做特殊配置，OpenFeign默认使用JDK自带的HttpURLConnection发送HTTP请求，由于默认HttpURLConnection没有连接池、性能和效率比较低。所以修改为Apache HttpClient 5。具体操作请往下看。
Springboot2.5集成HttpClient依赖，封装HTTP请求类并配置连接池
我思故我在的博客空间
12-10 5065
先看需要引入的依赖： <!--Http服务器的访问功能--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpasyncclient</artifactId> </dependency> <!-- http通信 --> <dependency> <groupId>o
完美解决org.apache.http
热门推荐
05-15 6万+
org.apache.http是Java中一个用于处理HTTP请求和响应的库。
org.apache.httpcomponents下的httpclient使用
GAMELOFT9----纸上得来终觉浅，绝知此事要躬行
05-16 1万+
一、概述      这里只针对4.5的版本进行介绍。项目中经常有需要发送http请求的场景，httpclient很好的解决了这个问题，而且非常易用。maven依赖&lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclien...
Apache httpclient源码4.5.12
05-15
Apache HttpClient 是一个强大的Java库，用于执行HTTP请求。在4.5.12版本中，它提供了丰富的功能，包括支持HTTP/1.1和部分HTTP/2协议，连接管理，重试策略，以及多种认证机制。这个源码版本是学习HTTP通信、网络编程...
Apache HttpClient 4.5.6
08-10
Apache HttpComponents Client的4.5.6版本 ，下载引入工程即可。
apache httpclient 4.5.1 doc
12-21
apache httpclient document apache httpcore document
wechatpay-apache-httpclient:微信支付 APIv3 Apache HttpClient装饰器（decorator）
05-01
wechatpay-apache-httpclient 概览 的扩展，实现了请求签名的生成和应答签名的验证。 如果你是使用Apache HttpClient的商户开发者，可以使用它构造HttpClient。得到的HttpClient在执行请求时将自动携带身份认证信息...
HttpClientMock:用于模拟Apache HttpClient的库
05-24
它与HttpClient 4.X和5.X一起使用。 安装 HttpClientMock在Maven中央存储库中可用。 要模拟HttpClient 4.x，请使用HttpClientMock1.X。 要模拟HttpClient 5.x，请使用HttpClientMock2.X。 用法 记录 使用...
【Java - 框架 - HttpClient 5】(01) HttpClient 5 使用详细教程，代码示例 - 快速上手
SUNxRUN的博客
03-24 2253
HttpClient 5 使用详细教程，代码示例 - 快速上手；Java爬虫；
httpclient5 工具类
飞在江湖的专栏
12-08 2945
最近公司升级httpclient，从httpclient-4.3.2.jar升级到httpclient5-5.1.3.jar,写了个工具类供参考，可以去mvn仓库下载。4、不论服务端是阻塞还是异步的实现，httpclient5均能支持服务端的过滤。从支持HHTP/2到新的连接池实现。从版本号的跳跃和包名和groupId的变更都显示着这次的变动非常之大。6、使用严格连接有限保证的方式重构连接池的实现。通过减少全局连接池的锁，连接池在高并发下获得更好的性能。7、新的不严格连接有限保证连接池的实现。
Java开源工具库使用之httpclient
十十办文武的博客
02-22 2641
HttpClient成立于2001年，是项目下的子项目，2004 年离开Commons，提升成为一个单独的 Jakarta 项目。2005 年，Jakarta 创建了项目，目标是开发的继任者。2007 年，Commons项目，也就是HttpClient项目的发源地，离开了Jakarta， 成为了1个新的顶级项目。不久之后，也离开了Jakarta， 成为一个独立的顶级项目，负责维护HttpClient的工作。HttpClient提供了高效、最新、功能丰富的支持HTTP。
httpclient5.0版本使用
qq_42339350的博客
04-22 2816
代码环境 纯普通的java项目，没有什么框架 官方教程 HttpClient Quick Start 下载依赖 Q：为什么还要下载slf4j的依赖？不是httpclient就行了吗 A ：不行的，不装的话就会报错在HttpClients.createDefault 这一行代码时候出现了NoClassDefFoundError的错误,详情见HttpClients.createDefault NoClassDefFoundError 代码 package httpclient; import com.go
深入学习 HttpClient 5：源码分析、封装工具类和注意点
ChiZng的博客
05-17 1566
在本篇技术博客中，我们将深入学习 HttpClient 5，并从以下几个方面入手：源码分析、封装工具类和最佳实践与注意点。通过这些深入的学习，你将能够更好地理解 HttpClient 5 的内部工作原理，灵活地封装和使用 HttpClient 5，以及遵循最佳实践来提升性能和稳定性。
Apache HttpComponents学习笔记（二）：HttpClient 接口
zjysource的专栏
10-25 2548
HttpClient接口代表了HTTP请求执行的核心协议：用户提供请求对象交给HttpClient执行，HttpClient负责把请求对象传递给服务器，然后返回响应对象，或者抛出异常。
httpClient集合
jinying_51eqhappy的博客
08-16 111
参考文档：https://hc.apache.org/httpcomponents-client-5.2.x/quickstart.html参考文档： https://blog.csdn.net/qq_38866898/article/details/118518221参考文档httpClientUtils:utm_id=0。
httpClient4.1入门教程
04-26
在 HttpClient 4.1 入门教程中，我们可以了解到 HttpClient 是 Apache Jakarta Common 下的子项目，它被设计用来提供高效、最新、功能丰富的支持 HTTP 协议的客户端编程工具包。HttpClient 支持 HTTP 协议的最新版本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

澄风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值