HttpClient简单使用

HttpClient简介

　　HttpClient主要用来访问基于HTTP协议的地址，得到返回的报文。但它不是一个浏览器，它是一个客户端的HTTP通信实现库。HttpClient的目标是发送和接受报文，它不能执行返回的页面中的JavaScript代码、重定向等与HTTP传输无关的内容。

一、简单使用

　　HttpClient的一个重要功能是执行Http方法，一个Http方法中至少会有一个或多个Http请求/Http响应。

　　使用步骤

　　

/*
 1. 创建HttpClient对象。

 2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。

 3. 如果需要发送请求参数，HttpGet的话在url之后加上?连接参数；对于HttpPost对象而言，可调用setEntity(HttpEntity entity)方法来设置请求参数。

 4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。

 5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；
    调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

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

 

一个使用例子

public class Client {
    private static final Logger logger = LogManager.getLogger(Client.class);
    
    public static void main(String[] args) {

        // 百度API市场里的一个天气API
        String url = "https://apis.baidu.com/heweather/weather/free";
        //请求类型
　　　　 String method = "GET";
　　　　 //请求头
        HashMap<String, String> header = new HashMap<String, String>();
        //参数列表
　　　　 Map<String, String> params = new HashMap<String, String>();
        //返回值类型
　　　　 ReturnType dataType = ReturnType.JSON;
　　　　 //编码格式 
        String charset = "UTF-8";
        // 请求头内容，apiKey可以自己去百度API注册
        String apiKey = "485ddc762724fad0e065c95caee？？？？？";
        header.put("apiKey", apiKey);
        // 参数内容
        String cityname = "西安";
        params.put("city", cityname);

        ReturnEntity entity = queryResult(url, method, dataType, header, params,charset);
        System.out.println(entity.toString());
    }

    // 向api地址发起请求,返回得到的json结果
    public static ReturnEntity queryResult(String url, String method,
            ReturnType dataType, Map<String, String> header,
            Map<String, String> params, String charset) {

        ReturnEntity result = new ReturnEntity();
        // 先将参数转换
        List<NameValuePair> nameValuePairs = convertParams(params);
        // 创建httpClient
        HttpClientBuilder builder = HttpClientBuilder.create();
        CloseableHttpClient httpClient = builder.build();
        try {
            CloseableHttpResponse response = executeRequest(httpClient, url,
                    method, header, nameValuePairs,charset);
            // 获得执行结果
            StatusLine statusLine = response.getStatusLine();
            logger.info("protocolVersion:{} ; statusCode:{} ; reasonPhrase:{}",
                    statusLine.getProtocolVersion(),
                    statusLine.getStatusCode(), statusLine.getReasonPhrase());
            if (statusLine.getStatusCode() == HttpStatus.SC_OK) {
                // 执行成功
                HttpEntity entity = response.getEntity();
                // 获得结果内容
                Object data = getContent(entity, dataType);
                // 将结果填充到返回的对象里
                result.setData(data);
                result.setStatusLine(statusLine);
                result.setType(dataType);
            } else {
                throw new RuntimeException("执行失败");
            }
        } catch (IOException e) {
            logger.error("", e);
            result.setType(ReturnType.ERROR);
        }
        return result;
    }

    // 从返回的HttpEntity里取得内容
    public static Object getContent(HttpEntity entity, ReturnType dataType)
            throws ParseException, IOException {
        Object data = null;
        if (dataType.equals(ReturnType.JSON)) {
            // 数据类型为JSON
            data = EntityUtils.toString(entity);
        } else if (dataType.equals(ReturnType.XML)) {
            // 数据类型为XML
        } else if (dataType.equals(ReturnType.TEXT)) {
            // 数据类型为文本
        }
        return data;
    }

    // 执行请求，得到resonse对象
    public static CloseableHttpResponse executeRequest(
            CloseableHttpClient httpClient, String url, String method,
            Map<String, String> header, List<NameValuePair> nameValuePairs,
            String charset) {
        CloseableHttpResponse response = null;

        try {
            if (HttpPost.METHOD_NAME.equalsIgnoreCase(method)) {
                // post方法
                // 创建httpPost
                HttpPost httpPost = new HttpPost(url);
                // 设置请求头
                if (header != null && !header.isEmpty()) {
                    Header[] requestHeaders = getHeader(header);
                    httpPost.setHeaders(requestHeaders);
                }
                // 设置参数
                if (nameValuePairs != null && !nameValuePairs.isEmpty()) {
                    httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs,charset));
                }
                // 执行并得到response
                response = httpClient.execute(httpPost);
            } else if (HttpGet.METHOD_NAME.equalsIgnoreCase(method)) {
                // get方法    
                // 创建httpGet
                HttpGet httpGet = new HttpGet(url);
                
                // 设置请求头
                if (header != null && !header.isEmpty()) {
                    Header[] requestHeaders = getHeader(header);
                    httpGet.setHeaders(requestHeaders);
                }
                // 设置参数
                if (nameValuePairs != null && !nameValuePairs.isEmpty()) {
                    httpGet.setURI(URI.create(url
                            + "?"
                            + EntityUtils.toString(new UrlEncodedFormEntity(
                                    nameValuePairs,charset))));
                }
                // 执行并得到resposne
                response = httpClient.execute(httpGet);
            } else {
                throw new TypeException("method must be POST or GET");
            }
        } catch (TypeException | IOException e) {
            logger.error("", e);
        }
        return response;
    }

    // 获得请求头
    public static Header[] getHeader(Map<String, String> header) {
        List<Header> headers = null;
        if (header != null && !header.isEmpty()) {
            headers = new ArrayList<Header>();
            Set<String> keys = header.keySet();
            for (Iterator<String> keyIterator = keys.iterator(); keyIterator
                    .hasNext();) {
                String key = keyIterator.next();
                headers.add(new BasicHeader(key, header.get(key)));
            }
            Header[] requestHeaders = headers.toArray(new Header[0]);

            return requestHeaders;
        }
        return null;
    }

    // 对参数进行转换
    public static List<NameValuePair> convertParams(Map<String, String> params) {
        List<NameValuePair> nameValueParams = null;
        if (params != null && !params.isEmpty()) {
            Set<String> keys = params.keySet();
            nameValueParams = new ArrayList<NameValuePair>();
            for (Iterator<String> keyIterator = keys.iterator(); keyIterator
                    .hasNext();) {
                String key = keyIterator.next();
                String value = params.get(key);
                logger.debug("key:{};value:{}", key, value);
                nameValueParams.add(new BasicNameValuePair(key, value));
            }
        } else {
            logger.debug("the params is null");
        }
        return nameValueParams;
    }
}

View Code

其中ReturnEntity有三个字段Object data,StatusLine statusLine,ReturnType dataType;

而ReturnType是指请求所返回的对象类型,是一个枚举

 

二、HttpClient简介

　　HttpClient在使用时总共有以下几个需要注意的对象：

　　1.CloseableHttpClient->用来执行请求对象；

　　2.请求对象：主要是HttpGet和HttpPost;

　　　　其他的还有HttpHead，HttpPut，HttpDelete，HttpTrace和HttpOptions。分别对应定义在HTTP/1.1版本中的HTTP方法：GET，HEAD，POST，PUT，DELETE，TRACE和OPTIONS。

　　3.实体：Entity是HTTP传输中的主体内容

　　4.响应对象：CloseableHttpResponse->执行请求后对方返回来的响应对象，可以得到返回来的实体。

 

　　

转载于:https://www.cnblogs.com/zaixiuxing/p/5035532.html