HttpEntity的类型及其使用

转自：http://blog.csdn.net/nefetaria/article/details/8703346

一 HttpEntity的类型

1 BasicHttpEntity

代表底层流的基本实体。通常是在http报文中获取的实体。他只有一个空参的构造方法。刚创建时没有内容，长度为负值。需要通过两个方法，把值赋进去。

[java] view
plaincopy

/**

* BasicHttpEntity

* @throws IOException

*/

public static void testBasicHttpEntity() throws IOException{

InputStream is = null;

//BasicHttpEntity这类就是一个输入流的内容包装类，包装内容的相关的编码格式，长度等

BasicHttpEntity entity = new BasicHttpEntity();

//设置内容

entity.setContent(is);

//设置长度

entity.setContentLength(is.available());

//没搞懂chunked这个属性啥意思

entity.setChunked(false);

}

2 ByteArrayEntity

是自我包含的，可重复获得使用的，从指定的字节数组中取出内容的实体。字节数组是这个实体的构造方法的参数。

[java] view
plaincopy

/**

* ByteArrayEntity

* @throws IOException

*/

public static void testByteArrayEntity() throws IOException{

ByteArrayEntity entity = new ByteArrayEntity("内容".getBytes());

ByteArrayInputStream is = (ByteArrayInputStream) entity.getContent();

//上面这行代码返回的其实是一个ByteArrayInputStream对象

/*public InputStream getContent() {

return new ByteArrayInputStream(this.b, this.off, this.len);

}*/

}

3 StringEntity

是自我包含的可重复的实体。通过String创建的实体。有两个构造方法，一个是自Sring为参数的构造方法，一个是以String和字符编码为参数的构造方法。

[java] view
plaincopy

/**

* StringEntity

* @throws IOException

*/

public static void testStringEntity() throws IOException{

StringBuilder sb = new StringBuilder();

//获取系统的信息集合，这个集合是不可以修改的

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

for(Entry<String, String> entry : nev.entrySet()){

sb.append(entry.getKey()).append("=")

.append(entry.getValue()).append("\n");

}

String content = sb.toString();

System.out.println(content);

//创建只带字符串参数的

StringEntity entity = new StringEntity(content);

//创建带字符创参数和字符编码的

StringEntity entity2 = new StringEntity(content, "UTF-8");

}

4 InputreamEntity

是流式不可以重复的实体。构造方法是InputStream 和内容长度，内容长度是输入流的长度。

[java] view
plaincopy

/**

* InputStreamEntity

* @throws IOException

*/

public static void testInputStreamEntity() throws IOException{

InputStream is = null;

//InputStreamEntity严格是对内容和长度相匹配的。用法和BasicHttpEntity类似

InputStreamEntity entity = new InputStreamEntity(is, is.available());

}

5 FileEntity

自我包含式，可以重复的实体。参数传入文件和文件类型。

[java] view
plaincopy

/**

* FileEntity

* @throws IOException

*/

public static void testFileEntity() throws IOException{

FileEntity entity = new FileEntity(new File(""), ContentType.APPLICATION_FORM_URLENCODED);

FileEntity entity2 = new FileEntity(new File(""), "application/java-achive");

}

6 EntityTemplete

从ContentProducer接口接受内容的实体。在ContentProducer的实现类中写入想要写入的内容。

[java] view
plaincopy

/**

* EntityTemplate

* @throws IOException

*/

public static void testEntityTemplate() throws IOException{

ContentProducer producer = new ContentProducer() {

@Override

public void writeTo(OutputStream outstream) throws IOException {

outstream.write("这是什么东东》。".getBytes());

}

};

EntityTemplate entity = new EntityTemplate(producer);

entity.writeTo(System.out);

}

7 HttpEntityWrapper

这个是创建被包装实体的基类，有被包装实体的引用。相当于实体的代理类，被包装实体是他的一个属性。下面是这个类的源码：

[java] view
plaincopy

/*

* ====================================================================

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0
*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

* ====================================================================

*

* This software consists of voluntary contributions made by many

* individuals on behalf of the Apache Software Foundation. For more

* information on the Apache Software Foundation, please see

* <http://www.apache.org/>.

*

*/

package org.apache.http.entity;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.apache.http.Header;

import org.apache.http.HttpEntity;

import org.apache.http.annotation.NotThreadSafe;

/**

* Base class for wrapping entities.

* Keeps a {@link #wrappedEntity wrappedEntity} 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.

*

* @since 4.0

*/

@NotThreadSafe

public class HttpEntityWrapper implements HttpEntity {

/** The wrapped entity. */

protected HttpEntity wrappedEntity;

/**

* Creates a new entity wrapper.

*

* @param wrapped the entity to wrap, not null

* @throws IllegalArgumentException if wrapped is null

*/

public HttpEntityWrapper(HttpEntity wrapped) {

super();

if (wrapped == null) {

throw new IllegalArgumentException

("wrapped entity must not be null");

}

wrappedEntity = wrapped;

} // constructor

public boolean isRepeatable() {

return wrappedEntity.isRepeatable();

}

public boolean isChunked() {

return wrappedEntity.isChunked();

}

public long getContentLength() {

return wrappedEntity.getContentLength();

}

public Header getContentType() {

return wrappedEntity.getContentType();

}

public Header getContentEncoding() {

return wrappedEntity.getContentEncoding();

}

public InputStream getContent()

throws IOException {

return wrappedEntity.getContent();

}

public void writeTo(OutputStream outstream)

throws IOException {

wrappedEntity.writeTo(outstream);

}

public boolean isStreaming() {

return wrappedEntity.isStreaming();

}

/**

* @deprecated (4.1) Either use {@link #getContent()} and call {@link java.io.InputStream#close()} on that;

* otherwise call {@link #writeTo(OutputStream)} which is required to free the resources.

*/

@Deprecated

public void consumeContent() throws IOException {

wrappedEntity.consumeContent();

}

}

8 BufferedHttpEntity

是HttpEntityWarpper的子类，可以把不可以重复的实体，实现成可以重复的实体。它从提供的实体中读取内容，缓存到内容中。源码如下：

[java] view
plaincopy

/*

* ====================================================================

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0
*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

* ====================================================================

*

* This software consists of voluntary contributions made by many

* individuals on behalf of the Apache Software Foundation. For more

* information on the Apache Software Foundation, please see

* <http://www.apache.org/>.

*

*/

package org.apache.http.entity;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.apache.http.HttpEntity;

import org.apache.http.annotation.NotThreadSafe;

import org.apache.http.util.EntityUtils;

/**

* A wrapping entity that buffers it content if necessary.

* The buffered entity is always repeatable.

* If the wrapped entity is repeatable itself, calls are passed through.

* If the wrapped entity is not repeatable, the content is read into a

* buffer once and provided from there as often as required.

*

* @since 4.0

*/

@NotThreadSafe

public class BufferedHttpEntity extends HttpEntityWrapper {

private final byte[] buffer;

/**

* Creates a new buffered entity wrapper.

*

* @param entity the entity to wrap, not null

* @throws IllegalArgumentException if wrapped is null

*/

public BufferedHttpEntity(final HttpEntity entity) throws IOException {

super(entity);

if (!entity.isRepeatable() || entity.getContentLength() < 0) {

this.buffer = EntityUtils.toByteArray(entity);

} else {

this.buffer = null;

}

}

@Override

public long getContentLength() {

if (this.buffer != null) {

return this.buffer.length;

} else {

return wrappedEntity.getContentLength();

}

}

@Override

public InputStream getContent() throws IOException {

if (this.buffer != null) {

return new ByteArrayInputStream(this.buffer);

} else {

return wrappedEntity.getContent();

}

}

/**

* Tells that this entity does not have to be chunked.

*

* @return <code>false</code>

*/

@Override

public boolean isChunked() {

return (buffer == null) && wrappedEntity.isChunked();

}

/**

* Tells that this entity is repeatable.

*

* @return <code>true</code>

*/

@Override

public boolean isRepeatable() {

return true;

}

@Override

public void writeTo(final OutputStream outstream) throws IOException {

if (outstream == null) {

throw new IllegalArgumentException("Output stream may not be null");

}

if (this.buffer != null) {

outstream.write(this.buffer);

} else {

wrappedEntity.writeTo(outstream);

}

}

// non-javadoc, see interface HttpEntity

@Override

public boolean isStreaming() {

return (buffer == null) && wrappedEntity.isStreaming();

}

} // class BufferedHttpEntity

二 HttpEntity 的使用

1 HttpEntity实体即可以使流也可以使字符串形式。具体有什么用法看他的方法解释：

[java] view
plaincopy

package com.scl.base;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import org.apache.http.HttpEntity;

import org.apache.http.ParseException;

import org.apache.http.entity.StringEntity;

import org.apache.http.util.EntityUtils;

public class HttpClientDemo06 {

/**

* @param args

*/

public static void main(String[] args) {

try {

HttpEntity entity = new StringEntity("这一个字符串实体", "UTF-8");

//内容类型

System.out.println(entity.getContentType());

//内容的编码格式

System.out.println(entity.getContentEncoding());

//内容的长度

System.out.println(entity.getContentLength());

//把内容转成字符串

System.out.println(EntityUtils.toString(entity));

//内容转成字节数组

System.out.println(EntityUtils.toByteArray(entity).length);

//还有个直接获得流

//entity.getContent();

} catch (UnsupportedEncodingException e) {

throw new RuntimeException(e);

} catch (ParseException e) {

} catch (IOException e) {

}

}

}

2 对于实体的资源使用完之后要适当的回收资源，特别是对于流实体。例子代码如下:

[java] view
plaincopy

public static void test() throws IllegalStateException, IOException{

HttpResponse response = null;

HttpEntity entity = response.getEntity();

if(entity!=null){

InputStream is = entity.getContent();

try{

//做一些操作

}finally{

//最后别忘了关闭应该关闭的资源，适当的释放资源

if(is != null){

is.close();

}

//这个方法也可以把底层的流给关闭了

EntityUtils.consume(entity);

//下面是这方法的源码

/*public static void consume(final HttpEntity entity) throws IOException {

if (entity == null) {

return;

}

if (entity.isStreaming()) {

InputStream instream = entity.getContent();

if (instream != null) {

instream.close();

}

}

}*/

}

}





点击打开链接