HttpClient之HTTP工具类

小灰灰 2021-05-03 03:51 645阅读 0赞

有了HttpClient对象,我们就可以把一些常用的发出GET和POST请求的代码也封装起来,写进我们的工具类中了。以下是我对GET和POST请求并返回响应字符串的方法。

# 1、什么是httpclient #

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。而HttpClient 它支持 HTTP 协议最新的版本和建议。

# 2、HttpClient 不是浏览器 #

HttpClient 不是浏览器，它是一个客户端 HTTP 协议传输类库。HttpClient 被用来发送和接受 HTTP 消息。HttpClient 不会处理 HTTP 消息的内容，不会进行 javascript 解析，不会关心 content type，如果没有明确设置，HttpClient 也不会对请求进行格式化、重定向 url，或者其他任何和 HTTP 消息传输相关的功能。

# 3、 HttpClient使用流程 #

1、创建HttpClient对象。

2、创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。  
3、如果需要发送请求参数，可调用HttpGetsetParams方法来添加请求参数；对于HttpPost对象而言，可调用setEntity(HttpEntity entity)方法来设置请求参数。

4、调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse对象。  
5、调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

6、释放连接。无论执行方法是否成功，都必须释放连接

## 工具类 ##

所需jar包：

````
<!— fastjson —>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.7</version>
</dependency>
<!— 异步httpclient（httpasynclient） —>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpasyncclient</artifactId>
    <version>4.0-alpha3</version>
	````

HttpUtils：

````
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/
  http 工具类
  TODO 改进：httpClient连接池
  @author Zhang
 /
public final class HttpUtils {

private HttpUtils() {
        throw new AssertionError(“不能产生实例”);
    }

private static Logger logger = LoggerFactory.getLogger(HttpUtils.class);

进行get请求
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doGet(String url, String params) throws IOException {
        return doGet(url, null, params);
    }
    /
      进行get请求
      @param url 访问地址
      @param headers 请求头
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     */
    public static String doGet(String url, Map<String, String> headers, String params) throws IOException {
        logger.info(“the url is {}”, url);
        logger.info(“the request params is {}”, params);
        HttpGet get = new HttpGet(url + ‘?’ + params);
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                get.addHeader(entry.getKey(), entry.getValue());
            }
        }
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpResponse res = httpClient.execute(get);
            int status = res.getStatusLine().getStatusCode();
            logger.info(“the response status is {}”, status);
            if (status != HttpStatus.SC_OK) {
                throw new IOException(“请求失败，响应码是：” + status);
            }
            String resText = EntityUtils.toString(res.getEntity(), “UTF-8”);
            logger.info(“the response is {}”, resText);
            return resText;
        } finally {
            get.releaseConnection();
        }
    }

进行get请求
      @param url 访问地址
      @param headers 请求头
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doGet(String url, Map<String, String> headers, Map<String, String> params) throws IOException {
        String query = “”;
        if (params != null && !params.isEmpty()) {
            StringBuilder s = new StringBuilder();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                s.append(entry.getKey()).append(‘=’).append(entry.getValue()).append(‘&’);
            }
            s.setLength(s.length() - 1);
            query = s.toString();
        }
        return doGet(url, headers, query);
    }
    /**
      进行post请求
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doPost(String url, String params, String contentType, String charset) throws IOException {
        logger.info(“the params is {}”, params);
        HttpEntity entity = new StringEntity(params, ContentType.create(contentType, charset));
        return doPost(url, entity);
    }

/**
      进行post请求
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doPost(String url, String params) throws IOException {
        return doPost(url, params, “application/x-www-form-urlencoded”, “UTF-8”);
    }

/**
      进行post请求
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doPostJson(String url, String params) throws IOException {
        return doPost(url, params, “application/json”, “UTF-8”);
    }

/**
      进行post请求
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doPost(String url, Map<String, String> params) throws IOException {
        logger.info(“the request params is {}”, params);
        // 添加参数
        List<NameValuePair> list = new ArrayList<>(params.size());
        for (Map.Entry<String, String> entry : params.entrySet()) {
            list.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }
        HttpEntity entity = new UrlEncodedFormEntity(list, “UTF-8”);
        return doPost(url, entity);
    }

/**
      进行post请求
      @param url 访问地址
      @param entity 参数
      @return 响应
      @throws IOException 请求失败
     /
    public static String doPost(String url, HttpEntity entity) throws IOException {
        logger.info(“the url is {}”, url);
        HttpPost post = new HttpPost(url);
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            post.setEntity(entity);
            HttpResponse res = httpClient.execute(post);
            int status = res.getStatusLine().getStatusCode();
            logger.info(“the response status is {}”, status);
            if (status != HttpStatus.SC_OK) {
                throw new IOException(“请求失败，响应码是：” + status);
            }
            String resText = EntityUtils.toString(res.getEntity(), “UTF-8”);
            logger.info(“the response is {}”, resText);
            return resText;
        } finally {
            post.releaseConnection();
        }
    }

/**
      进行post，提交文件
      @param url 访问地址
      @param params 参数
      @return 响应
      @throws IOException 请求失败
     */
    public static String doPostFile(String url, Map<String, Object> params) throws IOException {
        logger.info(“the params is {}”, params);
        MultipartEntityBuilder builder = MultipartEntityBuilder.create();
        Object obj;
        // 解决中文乱码
        ContentType contentType = ContentType.create(“text/plain”, Charset.forName(“UTF-8”));
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            obj = entry.getValue();
            if (obj == null) { continue; }
            logger.info(“the name is {}, the value is {}”, entry.getKey(), obj);
            if (obj instanceof File) {
                File f = (File) obj;
                String name = f.getName();
                ContentType type;
                if (name.endsWith(“.jpg”)) {
                    type = ContentType.create(“image/jpg”);
                } else if (name.endsWith(“.png”)) {
                    type = ContentType.create(“image/png”);
                } else if (name.endsWith(“.jpeg”)) {
                    type = ContentType.create(“image/jpeg”);
                } else {
                    type = ContentType.DEFAULT_BINARY;
                }
                builder.addBinaryBody(entry.getKey(), f, type, f.getName());
            } else if (obj instanceof InputStream) {
                builder.addBinaryBody(entry.getKey(), (InputStream) obj);
            } else if (obj instanceof byte[]) {
                builder.addBinaryBody(entry.getKey(), (byte[]) obj);
            } else if (obj instanceof String) {
                builder.addTextBody(entry.getKey(), (String) obj, contentType);
            } else {
                builder.addTextBody(entry.getKey(), String.valueOf(obj), contentType);
            }
        }
        return doPost(url, builder.build());
    }
}
````