大家好，又见面了，我是你们的朋友全栈君。
HttpEntity的类型及其使用（各种继承的使用）
package com.lyj.demo.customTests;
import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentProducer;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.EntityTemplate;
import org.apache.http.entity.FileEntity;
import org.apache.http.entity.HttpEntityWrapper;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.util.Map;
import static java.nio.charset.StandardCharsets.UTF_8;
/** * @author 凌兮 * @date 2020/10/8 13:45 * HttpEntity相关类测试 */
@RunWith(SpringJUnit4ClassRunner.class)
public class HttpEntityTest {
/** * basicHttpEntity测试 * 代表底层流的基本实体。通常是在http报文中获取的实体。 * 他只有一个空参的构造方法。刚创建时没有内容，长度为负值。 * 需要通过两个方法，把值赋进去 */
@Test
public void basicHttpEntityTest() throws IOException {
InputStream inputStream = null;
// BasicHttpEntity这类就是一个输入流的内容包装类，包装内容的相关的编码格式，长度等
BasicHttpEntity basicHttpEntity = new BasicHttpEntity();
// 设置内容
basicHttpEntity.setContent(inputStream);
// 设置长度
basicHttpEntity.setContentLength(inputStream.available());
// 暂时不明白他是干啥的
basicHttpEntity.setChunked(false);
}
/** * byteArrayEntity测试 * 是自我包含的，可重复获得使用的， * 从指定的字节数组中取出内容的实体。 * 字节数组是这个实体的构造方法的参数。 */
@Test
public void byteArrayEntityTest() {
ByteArrayEntity byteArrayEntity = new ByteArrayEntity("你好呀".getBytes());
// 返回byteArrayInputStream对象
ByteArrayInputStream content = (ByteArrayInputStream) byteArrayEntity.getContent();
/*public InputStream getContent() { return new ByteArrayInputStream(this.b, this.off, this.len); }*/
}
/** * StringEntity测试 * 是自我包含的可重复的实体。通过String创建的实体。 * 有两个构造方法，一个是自Sring为参数的构造方法， * 一个是以String和字符编码为参数的构造方法 */
@Test
public void stringEntityTest() throws UnsupportedEncodingException {
StringBuilder stringBuilder = new StringBuilder();
// 获取系统信息集合，这个集合是不可以修改的
Map<String, String> getenv = System.getenv();
for (Map.Entry<String,String> entry : getenv.entrySet()) {
stringBuilder.append(entry.getKey()).append("=").append(entry.getValue()).append("\n");
}
// 拼接后的系统信息集合
String content = stringBuilder.toString();
System.out.println(content);
// 创建只带字符串参数的entity
StringEntity entity = new StringEntity(content);
// 创建带字符串参数的和指定的字符编码格式的entity
StringEntity entity1 = new StringEntity(content, UTF_8);
}
/** * InputStream测试 * 是流式不可以重复的实体。 * 构造方法是InputStream 和内容长度，内容长度是输入流的长度。 */
@Test
public void inputStreamEntityTest() throws IOException {
InputStream inputStream = null;
// InputStreamEntity严格是对内容和长度相匹配的。用法和BasicHttpEntity类似
InputStreamEntity inputStreamEntity = new InputStreamEntity(inputStream, inputStream.available());
}
/** * fileEntity测试 * 自我包含式，可以重复的实体。参数传入文件和文件类型。 */
@Test
public void fileEntityTest() {
FileEntity fileEntity = new FileEntity(new File(""), ContentType.APPLICATION_FORM_URLENCODED);
FileEntity fileEntity1 = new FileEntity(new File(""), ContentType.APPLICATION_JSON);
// 已经过时了
// FileEntity fileEntity1 = new FileEntity(new File(""), ContentType.APPLICATION_JSON.getMimeType());
System.out.println(ContentType.APPLICATION_JSON.getMimeType());
}
/** * EntityTemplete测试 * 从ContentProducer接口接受内容的实体。 * 在ContentProducer的实现类中写入想要写入的内容 */
@Test
public void entityTempleteTest() throws IOException {
ContentProducer contentProducer = new ContentProducer() {
@Override
public void writeTo(OutputStream outputStream) throws IOException {
outputStream.write("你好呀".getBytes());
}
};
EntityTemplate entityTemplate = new EntityTemplate(contentProducer);
entityTemplate.writeTo(System.out);
// System.out.println(entityTemplate.getContent());
}
/** * HttpEntityWrapper测试 * 这个是创建被包装实体的基类，有被包装实体的引用。 * 相当于实体的代理类，被包装实体是他的一个属性。 */
@Test
public void httpEntityWrapperTest() throws IOException {
HttpEntityWrapper httpEntityWrapper = new HttpEntityWrapper(new HttpEntity() {
@Override
public boolean isRepeatable() {
return false;
}
@Override
public boolean isChunked() {
return false;
}
@Override
public long getContentLength() {
return 0;
}
@Override
public Header getContentType() {
return null;
}
@Override
public Header getContentEncoding() {
return null;
}
@Override
public InputStream getContent() throws IOException, UnsupportedOperationException {
return null;
}
@Override
public void writeTo(OutputStream outputStream) throws IOException {
outputStream.write("你好呀".getBytes());
}
@Override
public boolean isStreaming() {
return false;
}
@Override
public void consumeContent() throws IOException {
}
});
httpEntityWrapper.writeTo(System.out);
System.out.println(httpEntityWrapper.getContent());
}
/** * BufferedHttpEntity测试 * 是HttpEntityWarpper的子类，可以把不可以重复的实体， * 实现成可以重复的实体。它从提供的实体中读取内容，缓存到内容中。 */
@Test
public void bufferedHttpEntityTest() throws IOException {
BufferedHttpEntity bufferedHttpEntity = new BufferedHttpEntity(new HttpEntity() {
@Override
public boolean isRepeatable() {
return false;
}
@Override
public boolean isChunked() {
return false;
}
@Override
public long getContentLength() {
return 0;
}
@Override
public Header getContentType() {
return null;
}
@Override
public Header getContentEncoding() {
return null;
}
@Override
public InputStream getContent() throws IOException, UnsupportedOperationException {
return null;
}
@Override
public void writeTo(OutputStream outputStream) throws IOException {
outputStream.write("你好呀".getBytes());
}
@Override
public boolean isStreaming() {
return false;
}
@Override
public void consumeContent() throws IOException {
}
});
bufferedHttpEntity.writeTo(System.out);
System.out.println(bufferedHttpEntity.getContent());
// 入参校验函数
// Args.notNull();
}
/** * HttpEntity测试1 * HttpEntity实体即可以使流也可以使字符串形式。具体有什么用法看他的方法解释 */
@Test
public void httpEntityTest1() throws IOException {
// new StringEntity();
try {
HttpEntity entity = new StringEntity("这是一个字符串", StandardCharsets.UTF_8);
// 内容类型
System.out.println(entity.getContentType());
// 内容的编码格式
System.out.println(entity.getContentEncoding());
// 内容的长度
System.out.println(entity.getContentLength());
// 内容的长度
System.out.println(entity.getContent().available());
// 获取流
System.out.println(entity.getContent());
// 把内容转换成字符串
System.out.println(EntityUtils.toString(entity));
// 把内容转为字节数组并获取长度
System.out.println(EntityUtils.toByteArray(entity).length);
System.out.println("----------------------------------");
// 获取entity内容类型
Header header = entity.getContentType();
System.out.println(header);
// 内容类型元素
HeaderElement[] elements = header.getElements();
System.out.println(elements);
// 通过entity获取内容类型
ContentType contentType = ContentType.get(entity);
System.out.println(contentType);
} catch (IOException | UnsupportedOperationException | UnsupportedCharsetException | ParseException e) {
throw new RuntimeException(e);
}
}
/** * HttpEntity测试2 * 对于实体的资源使用完之后要适当的回收资源，特别是对于流实体。 */
@Test
public void httpEntityTest2() throws IOException {
HttpResponse response = null;
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream inputStream = entity.getContent();
try {
// 做一些流式操作
} catch (Exception e) {
// 异常捕捉
e.printStackTrace();
} finally {
// 由于InputSteam实现了Closeable接口，可以实现自动关闭流，所以这里可以不用关闭流，
if (inputStream != null) {
inputStream.close();
}
// 采用这种方法也可以实现关闭流
EntityUtils.consume(entity);
}
}
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/126070.html原文链接：https://javaforall.net
