HeapDump性能社区

性能工具
登录注册
性能文章>Apache HttpClient使用和源码分析>

Apache HttpClient使用和源码分析原创

阿弱
1年前
386924

在上文中分析了 HttpURLConnection的用法，功能还是比较简单的，没有什么封装

接下来看看Apache HttpClient是如何封装httpClient的

使用的版本

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

 

目录

 

组成

HttpClient 5 的系统架构主要由以下几个部分组成：

  1. HttpCore：核心包，包含了 HTTP 协议的核心抽象和实现，定义了 HTTP 客户端和服务端的基本组件，例如请求消息、响应消息、传输层等。
  2. HttpClient：高级 API，封装了 HttpCore 包中的核心抽象，提供了一组简单易用的 API，以便于客户端应用程序发送 HTTP 请求。
  3. HttpAsyncClient：异步 API，是基于 HttpCore 和 HttpClient 构建的异步 HTTP 客户端，可以通过异步方式实现 HTTP 请求。
  4. HttpClient 和 HttpAsyncClient 都可以通过扩展进行定制和优化，可以添加拦截器、设置连接管理器、Cookie 管理器、认证器等。

请求代码

GET请求代码

String resultContent = null;
String url = "http://127.0.0.1:8081/get";
HttpGet httpGet = new HttpGet(url);
//通过工厂获取
CloseableHttpClient httpClient = HttpClients.createDefault();
//请求
CloseableHttpResponse response = httpClient.execute(httpGet);

// Get status code
System.out.println(response.getVersion()); 
// HTTP/1.1
System.out.println(response.getCode()); 
// 200
System.out.println(response.getReasonPhrase()); 
// OK
HttpEntity entity = response.getEntity();
// Get response information
resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

代码分析

创建实例

Apache HttpClient提供了一个工厂类来返回HttpClient实例

但实际上都是通过HttpClientBuilder去创建的，

Apache HttpClient通过构建者模式加上策略模式实现非常灵活的配置，以实现各种不同的业务场景

通过看build()的代码，创建HttpClient主要分为两步

    public static CloseableHttpClient createDefault() {
        return HttpClientBuilder.create().build();
    }

第一步是初始化配置

里边很多策略模式的使用，可以实现相关的类来拓展自己的需求，可以通过HttpClient的set方法把新的策略设置进去，其他配置也可以通过RequestConfig设置好

ConnectionKeepAliveStrategy keepAliveStrategyCopy = this.keepAliveStrategy;
if (keepAliveStrategyCopy == null) {
    keepAliveStrategyCopy = DefaultConnectionKeepAliveStrategy.INSTANCE;
}
AuthenticationStrategy targetAuthStrategyCopy = this.targetAuthStrategy;
if (targetAuthStrategyCopy == null) {
    targetAuthStrategyCopy = DefaultAuthenticationStrategy.INSTANCE;
}
AuthenticationStrategy proxyAuthStrategyCopy = this.proxyAuthStrategy;
if (proxyAuthStrategyCopy == null) {
    proxyAuthStrategyCopy = DefaultAuthenticationStrategy.INSTANCE;
}

在这里会初始化包括连接管理器、请求重试处理器、请求执行器、重定向策略、认证策略、代理、SSL/TLS等配置

第二步是创建处理器链

通过组合多个处理器来构建成处理器链处理请求

需要注意的是这里的添加顺序的方法，添加最终的执行处理器调用的是addLast()

处理器链中的每个处理器都有不同的功能，例如请求预处理、重试、身份验证、请求发送、响应解析等等。在每个处理器的处理过程中，可以对请求或响应进行修改或扩展，以满足不同的需求

最后再把初始化好的参数传递给InternalHttpClient返回一个HttpClient实例

发起请求

接下来看看请求方法

CloseableHttpResponse response = httpClient.execute(httpGet);

主要请求方法在InternalHttpClient#doExecute中

主要分为三步，第一步是将各种配置填充到上下文中HttpContext

第二步，执行刚刚封装执行链

//execChain就是上一步封装好的执行链
final ClassicHttpResponse response = this.execChain.execute(ClassicRequestBuilder.copy(request).build(), scope);

执行 execute 方法，执行链中的处理器被依次调用，每个元素都可以执行一些预处理、后处理、重试等逻辑

第三步，请求结束后，将结果转换为CloseableHttpResponse返回

自定义拦截器和处理器

接下来试试加一下自定义的拦截器和处理器

拦截器和处理器的实现是不一样的，处理器的实现是ExecChainHandler，拦截器是HttpResponseInterceptor和HttpRequestInterceptor

//执行链处理器
class MyCustomInterceptor implements ExecChainHandler {
    @Override
    public ClassicHttpResponse execute(ClassicHttpRequest request, ExecChain.Scope scope, ExecChain chain) throws IOException, HttpException {
        System.out.println("MyCustomInterceptor-------------");
        //调用下一个链
        return chain.proceed(request,scope);
    }
}

//响应拦截器
class MyCustomResponseInterceptor implements HttpResponseInterceptor {

    @Override
    public void process(HttpResponse response, EntityDetails entity, HttpContext context) throws HttpException, IOException {
        System.out.println("MyCustomResponseInterceptor-------------");
    }
}

//请求拦截器
class MyCustomRequestInterceptor implements HttpRequestInterceptor {


    @Override
    public void process(HttpRequest request, EntityDetails entity, HttpContext context) throws HttpException, IOException {
        System.out.println("MyCustomRequestInterceptor-------------");
    }
}

然后加入到拦截链中，custom()方法返回HttpClientBuilder来支持自定义

CloseableHttpClient httpClient = HttpClients.custom()
.addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
.addRequestInterceptorFirst(new MyCustomRequestInterceptor())
.addResponseInterceptorLast(new MyCustomResponseInterceptor())
.build();

注意看日志就有输出了

拦截器和处理器都是用于拦截请求和响应的中间件，但它们在功能上有些不同：

  1. 拦截器：在请求发送前或响应返回后对请求或响应进行修改，例如添加、删除、修改请求头或响应头、修改请求体等。拦截器的主要作用是拦截请求和响应，对它们进行一些操作，并将它们传递给下一个拦截器或处理器
  2. 处理器：用于执行实际的请求和响应处理，例如建立连接、发送请求、解析响应等。处理器通常是在整个请求-响应流程中的最后一环，负责将最终的响应结果返回给调用方

总之，拦截器和处理器都是用于处理请求和响应的中间件，但它们的职责和功能略有不同

异步请求

异步请求的HttpAsyncClient通过HttpAsyncClients工厂返回

主要的流程和同步请求差不多，包括初始化配置和初始化执行链，主要差异在执行请求那里

因为是异步执行，需要开启异步请求的执行器线程池，通过httpClient.start();方法来设置异步线程的状态，否则异步请求将无法执行

@Override
public final void start() {
    if (status.compareAndSet(Status.READY, Status.RUNNING)) {
        executorService.execute(ioReactor::start);
    }
}

如果没有开启，会抛出异常

if (!isRunning()) {
    throw new CancellationException("Request execution cancelled");
}

因为是异步请求，所以请求方法需要提供回调方法，主要实现三个方法，执行完成、失败和取消

//创建url
SimpleHttpRequest get = SimpleHttpRequest.create("GET", url);

Future<SimpleHttpResponse> future = httpClient.execute(get, 
//异步回调                                                     
new FutureCallback<SimpleHttpResponse>() {
    @Override
    public void completed(SimpleHttpResponse result) {
        System.out.println("completed---------------");
    }

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

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

SimpleHttpResponse response = future.get();

通过future.get()来获取异步结果，接下来看看底层是怎么实现的

//请求
execute(SimpleRequestProducer.create(request), SimpleResponseConsumer.create(), context, callback);

异步请求会创建SimpleRequestProducer和SimpleResponseConsumer来处理请求和响应，execute()也支持我们自己传进去

最终的请求和数据的接收都是依赖管道，过程有点像NIO

当请求时，会调用requestProducer.produce(channel);把请求数据写入channel中，在响应时，responseConsumer从channel中取得数据

源码的整一块请求代码都是通过几个匿名函数的写法完成的，看的有点绕

发起请求，匿名函数段代表的是RequestChannel的请求方法

//requestProducer的sendRequest方法
void sendRequest(RequestChannel channel, HttpContext context)

因为RequestChannel类是一个函数式接口，所以可以通过这种方式调用

public interface RequestChannel {
	//请求方法也是叫sendRequest
    void sendRequest(HttpRequest request, EntityDetails entityDetails, HttpContext context) throws HttpException, IOException;
}

生产和消费数据的代码都在那一刻函数段中，具体的实现细节可以看一下那一段源码，最终requestProducer也是委托RequestChannel来发起请求

消费完后通过一层一层的回调，最终到达最上边自己实现的三个方法上

异步的HttpClient也可以自定义拦截器喝处理器，实现方式和上边的一样，处理异步处理器的实现不同

 CloseableHttpClient httpClient = HttpClients.custom()
                .setDefaultRequestConfig(config)
                .addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
                .addRequestInterceptorFirst(new MyCustomRequestInterceptor())
                .addResponseInterceptorLast(new MyCustomResponseInterceptor())
                .build();

使用示例

创建HttpClient

如果是同步的就使用HttpClients工厂，异步的使用HttpAsyncClients

//返回默认的
CloseableHttpClient httpClient = HttpClients.createDefault();

如果想实现自定义配置，可以使用HttpClients.custom()方法

基本的配置被封装在RequestConfig类中

RequestConfig config = RequestConfig.custom()
            .setConnectionRequestTimeout(3L, TimeUnit.SECONDS)
            .setResponseTimeout(3L, TimeUnit.SECONDS)
            .setDefaultKeepAlive(10L , TimeUnit.SECONDS)
            .build();

如果还不满足，可以还可以去实现这些策略类

使用自定义配置创建httpClient

CloseableHttpClient httpClient = HttpClients.custom()
            .setDefaultRequestConfig(config)
            .addExecInterceptorLast("myCustomInterceptor", new MyCustomInterceptor())
            .addRequestInterceptorFirst(new MyCustomRequestInterceptor())
            .addResponseInterceptorLast(new MyCustomResponseInterceptor())
            .build();

GET方法请求

 String url = "http://127.0.0.1:8081/get";

List<NameValuePair> nvps = new ArrayList<>();
// GET 请求参数
nvps.add(new BasicNameValuePair("username", "test"));
nvps.add(new BasicNameValuePair("password", "password"));
//将参数填充道url中
URI uri = new URIBuilder(new URI(url))
        .addParameters(nvps)
        .build();
//创建get请求对象
HttpGet httpGet = new HttpGet(uri);

//发起请求
CloseableHttpResponse response = httpClient.execute(httpGet);

// Get status code
System.out.println(response.getVersion()); // HTTP/1.1
System.out.println(response.getCode()); // 200
HttpEntity entity = response.getEntity();
// Get response information
String resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

POST请求

这次将参数写到HttpEntity里

String url = "http://127.0.0.1:8081/post";

List<NameValuePair> nvps = new ArrayList<>();
// GET 请求参数
nvps.add(new BasicNameValuePair("username", "test"));
nvps.add(new BasicNameValuePair("password", "password"));

UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nvps, StandardCharsets.UTF_8);

HttpPost httpPost = new HttpPost(url);
httpPost.setEntity(formEntity);

CloseableHttpClient httpClient = HttpClients.createDefault();

CloseableHttpResponse response = httpClient.execute(httpPost);

// Get status code
System.out.println(response.getVersion()); // HTTP/1.1
System.out.println(response.getCode()); // 200
HttpEntity entity = response.getEntity();
// Get response information
String resultContent = EntityUtils.toString(entity);
System.out.println(resultContent);

和GET请求基本一致，除了用的是HttpPost，参数可以像GET一样填充到url中，也可以使用HttpEntity填充到请求体里

Json请求

String json = "{"
        + "    \"username\": \"test\","
        + "    \"password\": \"password\""
        + "}";
StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
HttpPost post = new HttpPost("http://127.0.0.1:8081/postJson");
post.setEntity(entity);
CloseableHttpClient client = HttpClients.createDefault();
CloseableHttpResponse response = client.execute(post);

// Get status code
System.out.println(response.getCode()); // 200
// Get response information
String resultContent = EntityUtils.toString(response.getEntity());
System.out.println(resultContent);

总结

和HttpURLConnection相比，做了很多封装，功能也强大了很多，例如连接池、缓存、重试机制、线程池等等，并且对于请求参数的设置更加灵活，还封装了异步请求、HTTPS等、自定义拦截器和处理器等

请求是使用了处理链的方式发起的，可以对请求和响应进行一系列处理，好处是可以将这些处理器封装成一个公共的类库，然后通过自己组合来满足自己的需求，还可以在请求和响应的不同阶段进行拦截和修改，例如添加请求头、修改请求参数、解密响应数据等，不需要在一个大类里写很多代码了，已免代码臃肿

性能方面使用了连接池技术，可以有效地复用连接，提高性能

不得不说是apache的项目，源码使用了包括构建者模式、策略模式、责任链模式等设计模式对整个httpClient进行了封装，学习到了

点赞收藏
分类：
Java语言
标签：
java
阿弱
请先登录，查看2条精彩评论吧
快去登录吧，你将获得
  • 浏览更多精彩评论
  • 和开发者讨论交流，共同进步

为你推荐

随机一门技术分享之Netty

随机一门技术分享之Netty

java
netty
源码
MappedByteBuffer VS FileChannel：从内核层面对比两者的性能差异

MappedByteBuffer VS FileChannel：从内核层面对比两者的性能差异

jvm
java
jdk
4
2
Lv2
阿弱

徽章

推荐阅读

随机一门技术分享之NettyMappedByteBuffer VS FileChannel：从内核层面对比两者的性能差异JDBC PreparedStatement 字段值为null导致TBase带宽飙升的案例分析浅析AbstractQueuedSynchronizer日常Bug排查-集群逐步失去响应为什么要做代码Review？
站内搜索
Linux
SpringBoot
锁
字节码
火焰图
故障排查
java
jvm
gc
linux
内存泄漏
内核

专题推荐

对于刚刚接触 JVM 的同学来说，JVM 就像一个黑盒一样，完全不知道这是一个什么东西。所以对于小白来说，最重要是搞清楚 JVM 到底是干嘛的，以及其常用的知识框架。针对这样的需求，才有了这个专题，从零开始循序渐进地介绍了 JVM，相信是很不错的 JVM 入门教程。
15篇文章36767阅读量
通过阅读 Redis 源码，可以学习和掌握到的计算机系统设计思想，redis 涉及的知识点有很多，本期专题我们由浅入深，简洁的给大家剖析Redis源码。
15篇文章26396阅读量

本月精选性能专题

本月精选线上案例

本月精选原创好文

HeapDump

有性能问题，上HeapDump性能社区

Copyright © 2019-2024 heapdump.cn 版权所有 浙ICP备17054444号

联系我们

HeapDump性能社区

网媒渠道

堆堆酱

扫码加堆堆酱好友

友情链接

PerfMa官网SegmentFault思否TesterHomeXPocket开源社区DCloud 问答社区稀土掘金博客园W3CTech