HttpClient进阶教程：异步I/O与Webservice调用

源码

需积分: 20 92 浏览量更新于2023-05-23 收藏 229KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本文档主要介绍了HttpClient在Java中的应用，特别是作为客户端调用Web服务时的使用技巧和原理。HttpClient是Apache HttpClient库的一部分，它提供了高效、灵活的HTTP通信功能，适用于不同的网络编程场景，包括同步和异步模式。 1. **HttpCore概述**: HttpCore是HttpClient的核心组件，负责处理HTTP协议的底层实现。文档首先阐述了HttpCore的范围和目标，明确指出其不是为了解决所有HTTP需求而设计，而是专注于提供基础的HTTP消息处理，如消息结构、基本操作、HTTP实体的创建等。 - **HTTP消息基础**: - HTTP消息结构详细解释了请求和响应的组成部分，包括头部和主体。 - 基本操作涉及构建请求、解析响应以及处理HTTP状态码和头部信息。 - HTTP实体讨论了如何创建和管理数据载体，如文本、二进制数据或流。 2. **阻塞I/O模型**: 文档深入剖析了HttpClient在使用阻塞I/O（如Java的Socket API）时的工作方式。这包括： - 阻塞HTTP连接的管理和使用，例如处理连接打开、关闭以及内容传输。 - 异常处理机制，如处理可能出现的ProtocolException，并介绍如何正确地终止HTTP连接。 - Connection池的概念，以优化资源利用和性能。 - TLS/SSL支持，确保安全的数据传输。 - 内嵌的HTTP服务器，可能用于测试或简单服务的开发。 3. **异步I/O与NIO**: 文档强调了HttpClient对非阻塞I/O（Non-blocking I/O，如Java NIO）的支持，这是现代高性能网络编程的重要特性。讲解了与传统I/O框架的区别，如I/O Reactor设计，以及如何使用I/O调度器进行事件驱动的通信。 - 异步I/O框架的优势在于提高了并发性和响应速度，通过I/O reactor实现事件监听和处理，避免了长时间的阻塞。 - I/O Reactor shutdown的管理也很关键，以确保程序的正确终止。这篇博文深入剖析了HttpClient库如何在不同I/O模型下工作，特别关注了其在客户端调用Web服务时的关键部分，如协议处理器、执行上下文、连接管理和安全机制。无论是对于Java开发者学习HTTP客户端编程，还是需要在项目中选择合适的网络库，这篇文章都提供了丰富的技术细节和实用指导。

资源详情

资源推荐

Fundamentals

}

When working with streaming entities, one can use the EntityUtils#consume(HttpEntity) method

to ensure that the entity content has been fully consumed and the underlying stream has been closed.

1.1.4. Creating entities

There are a few ways to create entities. HttpCore provides the following implementations:

• BasicHttpEntity

• ByteArrayEntity

• StringEntity

• InputStreamEntity

• FileEntity

• EntityTemplate

• HttpEntityWrapper

• BufferedHttpEntity

1.1.4.1. BasicHttpEntity

Exactly as the name implies, this basic entity represents an underlying stream. In general, use this class

for entities received from HTTP messages.

This entity has an empty constructor. After construction, it represents no content, and has a negative

content length.

One needs to set the content stream, and optionally the length. This can be done with

the BasicHttpEntity#setContent(InputStream) and BasicHttpEntity#setContentLength(long)

methods respectively.

BasicHttpEntity myEntity = new BasicHttpEntity();

myEntity.setContent(someInputStream);

myEntity.setContentLength(340); // sets the length to 340

1.1.4.2. ByteArrayEntity

ByteArrayEntity is a self-contained, repeatable entity that obtains its content from a given byte array.

Supply the byte array to the constructor.

ByteArrayEntity myEntity = new ByteArrayEntity(new byte[] {1,2,3},

ContentType.APPLICATION_OCTET_STREAM);

1.1.4.3. StringEntity

StringEntity is a self-contained, repeatable entity that obtains its content from a java.lang.String

object. It has three constructors, one simply constructs with a given java.lang.String object; the

second also takes a character encoding for the data in the string; the third allows the mime type to

be specified.

Fundamentals

StringBuilder sb = new StringBuilder();

Map<String, String> env = System.getenv();

for (Map.Entry<String, String> envEntry : env.entrySet()) {

sb.append(envEntry.getKey())

.append(": ").append(envEntry.getValue())

.append("\r\n");

}

// construct without a character encoding (defaults to ISO-8859-1)

HttpEntity myEntity1 = new StringEntity(sb.toString());

// alternatively construct with an encoding (mime type defaults to "text/plain")

HttpEntity myEntity2 = new StringEntity(sb.toString(), Consts.UTF_8);

// alternatively construct with an encoding and a mime type

HttpEntity myEntity3 = new StringEntity(sb.toString(),

ContentType.create("text/plain", Consts.UTF_8));

1.1.4.4. InputStreamEntity

InputStreamEntity is a streamed, non-repeatable entity that obtains its content from an input stream.

Construct it by supplying the input stream and the content length. Use the content length to limit the

amount of data read from the java.io.InputStream. If the length matches the content length available

on the input stream, then all data will be sent. Alternatively, a negative content length will read all data

from the input stream, which is the same as supplying the exact content length, so use the length to

limit the amount of data to read.

InputStream instream = getSomeInputStream();

InputStreamEntity myEntity = new InputStreamEntity(instream, 16);

1.1.4.5. FileEntity

FileEntity is a self-contained, repeatable entity that obtains its content from a file. Use this mostly to

stream large files of different types, where you need to supply the content type of the file, for instance,

sending a zip file would require the content type application/zip, for XML application/xml.

HttpEntity entity = new FileEntity(staticFile,

ContentType.create("application/java-archive"));

1.1.4.6. HttpEntityWrapper

This is the base class for creating wrapped entities. The wrapping entity holds a reference to a wrapped

entity and delegates all calls to it. Implementations of wrapping entities can derive from this class and

need to override only those methods that should not be delegated to the wrapped entity.

1.1.4.7. BufferedHttpEntity

BufferedHttpEntity is a subclass of HttpEntityWrapper. Construct it by supplying another entity.

It reads the content from the supplied entity, and buffers it in memory.

This makes it possible to make a repeatable entity, from a non-repeatable entity. If the supplied entity

is already repeatable, it simply passes calls through to the underlying entity.

myNonRepeatableEntity.setContent(someInputStream);

BufferedHttpEntity myBufferedEntity = new BufferedHttpEntity(

Fundamentals

myNonRepeatableEntity);

1.2. HTTP protocol processors

HTTP protocol interceptor is a routine that implements a specific aspect of the HTTP protocol. Usually

protocol interceptors are expected to act upon one specific header or a group of related headers of the

incoming message or populate the outgoing message with one specific header or a group of related

headers. Protocol interceptors can also manipulate content entities enclosed with messages; transparent

content compression / decompression being a good example. Usually this is accomplished by using the

'Decorator' pattern where a wrapper entity class is used to decorate the original entity. Several protocol

interceptors can be combined to form one logical unit.

HTTP protocol processor is a collection of protocol interceptors that implements the 'Chain of

Responsibility' pattern, where each individual protocol interceptor is expected to work on the particular

aspect of the HTTP protocol it is responsible for.

Usually the order in which interceptors are executed should not matter as long as they do not depend on

a particular state of the execution context. If protocol interceptors have interdependencies and therefore

must be executed in a particular order, they should be added to the protocol processor in the same

sequence as their expected execution order.

Protocol interceptors must be implemented as thread-safe. Similarly to servlets, protocol interceptors

should not use instance variables unless access to those variables is synchronized.

1.2.1. Standard protocol interceptors

HttpCore comes with a number of most essential protocol interceptors for client and server HTTP

processing.

1.2.1.1. RequestContent

RequestContent is the most important interceptor for outgoing requests. It is responsible for delimiting

content length by adding the Content-Length or Transfer-Content headers based on the properties

of the enclosed entity and the protocol version. This interceptor is required for correct functioning of

client side protocol processors.

1.2.1.2. ResponseContent

ResponseContent is the most important interceptor for outgoing responses. It is responsible for

delimiting content length by adding Content-Length or Transfer-Content headers based on the

properties of the enclosed entity and the protocol version. This interceptor is required for correct

functioning of server side protocol processors.

1.2.1.3. RequestConnControl

RequestConnControl is responsible for adding the Connection header to the outgoing requests, which

is essential for managing persistence of HTTP/1.0 connections. This interceptor is recommended for

client side protocol processors.

1.2.1.4. ResponseConnControl

ResponseConnControl is responsible for adding the Connection header to the outgoing responses,

which is essential for managing persistence of HTTP/1.0 connections. This interceptor is recommended

for server side protocol processors.

剩余50页未读，继续阅读

weixin_38669628

粉丝: 385
资源: 6万+

HttpClient进阶教程：异步I/O与Webservice调用

C#使用HttpPost请求调用WebService的方法

Httpclient所需jar包

http调用webservice操作httprequest、httpresponse示例

httpclient调用webservice

HttpClient 调用webservice

C#使用httpclient调用webservice接口

常用的调用WebService的方法有哪些

httpclient webservice

java使用httpclient异步调用webservice的代码

调用webservice 的几种方式

C# 使用 HttpPost 请求调用 WebService

.net6 调用 Webservice服务

c#调用 webservice

使用http来调用webservice协议

Java11 调用webservice 天气服务

idea调用webservice的xml请求格式的代码参考

xamarin通过webservice操作sql sever数据库

java调用三方接口

c# webservice soap 请求

java webservice接口调用,传json参数

最新资源