001—spring整合httpclient4.5.2

1.添加pom依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.2</version>
</dependency>

spring与httpclient的配置

2.spring-httpclient.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--定义连接管理器 -->
    <bean id="connectionManager"
        class="org.apache.http.impl.conn.PoolingHttpClientConnectionManager"
        destroy-method="close">
        <!-- 最大连接数 -->
        <property name="maxTotal" value="${http.maxTotal}" />
        <!--设置每个主机最大的并发数 -->
        <property name="defaultMaxPerRoute" value="${http.defaultMaxPerRoute}" />
    </bean>

    <!--定义HttpClient构建器 -->
    <bean id="httpClientBuilder" class="org.apache.http.impl.client.HttpClientBuilder"
        factory-method="create">
        <property name="connectionManager" ref="connectionManager" />
    </bean>

    <!--定义httpClient对象，该bean一定是多例的 -->
    <bean id="httpClient" class="org.apache.http.impl.client.CloseableHttpClient"
        factory-bean="httpClientBuilder" factory-method="build" scope="prototype"></bean>
    <!--定义requestConfig构建器 -->
    <bean id="requestConfigBuilder" class="org.apache.http.client.config.RequestConfig.Builder">
        <!--设置创建连接的最长时间 -->
        <property name="connectTimeout" value="${http.connectTimeout}" />
        <!--从连接池中获取到连接的最长时间 -->
        <property name="connectionRequestTimeout" value="${http.connectionRequestTimeout}" />
        <!--数据传输的最长时间 -->
        <property name="socketTimeout" value="${http.socketTimeout}" />
    </bean>
    <!--请求参数对象 -->
    <bean class="org.apache.http.client.config.RequestConfig"
        factory-bean="requestConfigBuilder" factory-method="build"></bean>
    <!--定期清理无效连接 -->
    <bean class="org.apache.http.impl.client.IdleConnectionEvictor"
        destroy-method="shutdown">
        <constructor-arg index="0" ref="connectionManager" />
        <constructor-arg index="1" value="${http.maxIdleTime}" />
        <constructor-arg index="2" value="MINUTES" />
    </bean>
</beans>

3.httpclient.properties（httpclient的属性）

#设置连接总数
http.maxTotal=500
#设置每个主机最大的并发数
http.defaultMaxPerRoute=100
#设置创建连接的最长时间
http.connectTimeout=2000
#从连接池中获取到连接的最长时间
http.connectionRequestTimeout=500
#数据传输的最长时间
http.socketTimeout=6000
#空闲时间(用于定期清理空闲连接)
http.maxIdleTime = 1

4.HttpClientService（httpclient请求服务）

package com.dowin.httpclient;

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.google.common.collect.Lists;

/**
* @ClassName: HttpClientService
* @Description: HttpClient请求工具
* @author kaifeng
* @date 2017年2月27日 下午5:33:10
*
*/
@Service
public class HttpClientService
{
    @Autowired
    private CloseableHttpClient httpClient;
    @Autowired
    private RequestConfig requestConfig;

    /**
    * @Title: doGet
    * @Description: 执行get请求,200返回响应内容，其他状态码返回null
    * @Author kaifeng
    * @Date 2017年2月27日 下午5:24:09
    * @param url 请求地址
    * @return
    * @throws IOException
    * @throws
    */
    public String doGet(String url) throws IOException
    {
        //创建httpClient对象
        CloseableHttpResponse response = null;
        HttpGet httpGet = new HttpGet(url);
        //设置请求参数
        httpGet.setConfig(requestConfig);
        try
        {
            //执行请求
            response = httpClient.execute(httpGet);
            //判断返回状态码是否为200
            if (response.getStatusLine().getStatusCode() == 200)
            {               
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        }
        finally
        {
            if (response != null)
            {
                response.close();
            }
        }
        return null;
    }

    /**
    * @Title: doGet
    * @Description: 执行带有参数的get请求
    * @Author kaifeng
    * @Date 2017年2月27日 下午5:24:33
    * @param url 请求地址
    * @param paramMap 参数键值对
    * @return
    * @throws IOException
    * @throws URISyntaxException
    * @throws
    */
    public String doGet(String url, Map<String, String> paramMap)
            throws IOException, URISyntaxException
    {
        URIBuilder builder = new URIBuilder(url);
        for (String s : paramMap.keySet())
        {
            builder.addParameter(s, paramMap.get(s));
        }
        return doGet(builder.build().toString());
    }

    /**
    * @Title: doPost
    * @Description: 执行post请求（有参数）
    * @Author kaifeng
    * @Date 2017年2月27日 下午5:25:38
    * @param url 请求地址
    * @param paramMap 参数键值对
    * @return
    * @throws IOException
    * @throws
    */
    public HttpResult doPost(String url, Map<String, String> paramMap)
            throws IOException
    {
        HttpPost httpPost = new HttpPost(url);
        //设置请求参数
        httpPost.setConfig(requestConfig);
        if (paramMap != null)
        {
            List<NameValuePair> parameters = Lists.newArrayList();
            for (String s : paramMap.keySet())
            {
                parameters.add(new BasicNameValuePair(s, paramMap.get(s)));
            }
            //构建一个form表单式的实体
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(
                    parameters, Charset.forName("UTF-8"));
            //将请求实体放入到httpPost中
            httpPost.setEntity(formEntity);
        }
        //创建httpClient对象
        CloseableHttpResponse response = null;
        try
        {
            //执行请求
            response = httpClient.execute(httpPost);
            return new HttpResult(response.getStatusLine().getStatusCode(),
                    EntityUtils.toString(response.getEntity()));
        }
        finally
        {
            if (response != null)
            {
                response.close();
            }
        }
    }

    /**
    * @Title: doPost
    * @Description: 执行post请求（无参数）
    * @Author kaifeng
    * @Date 2017年2月27日 下午5:26:26
    * @param url 请求地址
    * @return
    * @throws IOException
    * @throws
    */
    public HttpResult doPost(String url) throws IOException
    {
        return doPost(url, null);
    }

    /**
    * @Title: doPostJson
    * @Description: POST请求（JSON格式参数）
    * @Author kaifeng
    * @Date 2017年2月27日 下午5:27:04
    * @param url 请求地址
    * @param json 请求参数为JSON格式
    * @return
    * @throws ClientProtocolException
    * @throws IOException
    * @throws
    */
    public HttpResult doPostJson(String url, String json)
            throws ClientProtocolException, IOException
    {
        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(this.requestConfig);

        if (json != null)
        {
            // 构造一个请求实体
            StringEntity stringEntity = new StringEntity(json,
                    ContentType.APPLICATION_JSON);
            // 将请求实体设置到httpPost对象中
            httpPost.setEntity(stringEntity);
        }
        CloseableHttpResponse response = null;
        try
        {
            // 执行请求
            response = this.httpClient.execute(httpPost);
            return new HttpResult(response.getStatusLine().getStatusCode(),
                    EntityUtils.toString(response.getEntity(), "UTF-8"));
        }
        finally
        {
            if (response != null)
            {
                response.close();
            }
        }
    }
}