HttpCore教程：构建轻量级HTTP服务的核心组件与模型

需积分: 6 142 浏览量更新于2024-07-18 收藏 240KB PDF 举报

HttpCore教程深入探讨了Apache HttpCore框架的核心概念和实现原理，它专注于HTTP协议的基础部分，旨在帮助开发者构建功能完备的客户端和服务端HTTP服务，同时保持最小的资源占用。本教程分为几个关键章节： 1. **HttpCore范围与目标**： - HttpCore的设计旨在处理HTTP协议的底层逻辑，包括消息结构、基本操作和实体管理。 - 它的目标是提供一个轻量级且灵活的平台，支持同步和异步I/O模型。 2. **基础知识**： - **HTTP消息**：讲解了HTTP消息的结构，包括请求和响应的组成部分，如头部、主体等。 - **HTTP协议处理器**：介绍标准拦截器的使用，以及如何通过这些处理器处理HTTP请求和响应。 - **HTTP执行上下文**：讨论了共享上下文的重要性，以及在处理请求时如何利用这个机制。 3. **阻塞I/O模型**： - **阻塞HTTP连接**：阐述了如何在阻塞模式下处理HTTP连接，包括内容传输和连接管理。 - **异常处理**：着重介绍了处理HTTP协议异常，如`ProtocolException`，以及如何设计健壮的错误处理机制。 - **阻塞HTTP协议处理器**：详细解释了HTTP服务和请求执行器的使用，以及连接的持久性和重用策略。 - **连接池**：介绍了如何优化连接资源管理，减少开销。 - **TLS/SSL支持**：涉及安全套接层（SSL）和传输层安全（TLS）的集成，确保通信的安全性。 - **嵌入式HTTP服务器**：展示了如何使用HttpCore创建自定义的HTTP服务器实现。 4. **基于NIO的异步I/O**： - **与其它I/O框架的区别**：对比了HttpCore的异步I/O模型与其他I/O框架的特性，突出了其高效性和并发处理的优势。 - **I/O reactor**：重点讲解了I/O事件循环器（I/O reactor）的架构，包括I/O调度器和组件的协同工作。 - **I/O reactor的终止**：讨论了如何正确关闭和退出异步I/O环境。通过学习这个教程，开发者将能更好地理解HttpCore在实际项目中的应用，无论是作为客户端库还是用于构建服务器，都能掌握其核心原理和高效使用方法。

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页未读，继续阅读

我的新昵称

粉丝: 0
资源: 1

HttpCore教程：构建轻量级HTTP服务的核心组件与模型

httpcore-tutorial-simplified-chinese.pdf

httpclient资料

Python-Cheat-Sheet.pdf

CMSIS_RTOS_Tutorial.pdf

httpcore教程(中文版).pdf

Spring_Security-3.0.1_中文自学教程.pdf

Hadoop MapReduce.pdf

openGL超级宝典（第四版）.pdf

iOS_11_by_Tutorials_v1.1.pdf

VS2010上的OpenCV的版本选择与配置.pdf

最新资源