HttpClientUtil

最新推荐文章于 2021-04-16 16:45:47 发布

weixin_30827565

最新推荐文章于 2021-04-16 16:45:47 发布

阅读量65

点赞数

原文链接：http://www.cnblogs.com/sidekick/p/8401798.html

版权

applicationContext-httpclient

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 加载外部资源配置文件 -->
    <context:property-placeholder location="classpath:properties/*.properties" />

    <!-- 扫描Servcice -->
    <context:component-scan base-package="com.sidekick.front" />

    <bean id="requestConfigBuilder" class="org.apache.http.client.config.RequestConfig.Builder">
        <!-- 创建连接的最长时间 -->
        <property name="connectTimeout" value="${httpclient.connectTimeout}" />

        <!-- 从连接池中获取连接的最长时间 -->
        <property name="connectionRequestTimeout" value="${httpclient.connectionRequestTimeout}" />

        <!-- 数据传输的最长时间 -->
        <property name="socketTimeout" value="${httpclient.socketTimeout}" />

        <!-- 提交请求前，测试连接是否可用 -->
        <property name="staleConnectionCheckEnabled" value="${httpclient.staleConnectionCheckEnabled}" />

    </bean>


    <!-- 配置连接管理器 -->
    <bean id="connectionManager"
        class="org.apache.http.impl.conn.PoolingHttpClientConnectionManager">
        <property name="maxTotal" value="${httpclient.MaxTotal}" />
        <property name="defaultMaxPerRoute" value="${httpclient.DefaultMaxPerRoute}" />
    </bean>
    <bean id="httpClientBuilder" class="org.apache.http.impl.client.HttpClientBuilder">
        <!-- 设置连接管理器 -->
        <property name="connectionManager" ref="connectionManager" />
    </bean>



    <bean id="httpClient" class="org.apache.http.impl.client.CloseableHttpClient"
        factory-bean="httpClientBuilder" factory-method="build" scope="prototype">
    </bean>
    
    <!-- 配置清理连接对象 -->
    <bean id="idleConnectionEvictor" class="com.atguigu.front.httpclient.IdleConnectionEvictor" destroy-method="shutdown">
        <constructor-arg index="0" ref="connectionManager" />
    </bean>

</beans>

HttpClientUtils

@Service
public class HttpClientUtils {

    @Autowired(required = false)
    private CloseableHttpClient httpclient;

    @Autowired(required = false)
    private RequestConfig config;

    /**
     * 没有带参数的get请求
     * 
     * @param url
     *请求地址
     * @return 返回状态码为200， 返回页面内容，否则返回null
     * @throws Exception
     */
    public String doget(String url) throws Exception {

        HttpGet httpGet = new HttpGet(url);

        CloseableHttpResponse response = null;
        try {
            response = httpclient.execute(httpGet);

            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                response.close();
            }
            // httpclient.close();
        }
        return null;
    }

    /**
     * 带有参数的get请求
     * 
     * @param url
     *请求地址
     * @param params
     *请求参数
     * @return 返回状态码为200，返回页面，否则，返回null
     * @throws Exception
     */

    public String doget(String url, Map<String, Object> params)
            throws Exception {
        // 定义请求的参数
        URIBuilder builder = new URIBuilder(url);
        if (!params.isEmpty()) {
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                builder.setParameter(entry.getKey(), entry.getValue()
                        .toString());
            }
        }

        URI uri = builder.build();

        HttpGet httpGet = new HttpGet(uri);

        // 设置请求参数
        httpGet.setConfig(config);

        CloseableHttpResponse response = null;
        try {
            response = httpclient.execute(httpGet);

            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                response.close();
            }
            // httpclient.close();
        }
        return null;
    }

    public HttpResult dopost(String url, Map<String, Object> params)
            throws Exception {
        // 创建HttpPost请求
        HttpPost httpPost = new HttpPost(url);
        // 设置2个post参数，一个是scope，一个是q
        List<NameValuePair> parameters = new ArrayList<>(0);
        if (!params.isEmpty()) {
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString()));
            }
        }

        // 构建一个form实体式的表单
        UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters);
        // 将请求实体设置到HttpPost对象中
        httpPost.setEntity(formEntity);
        // 设置请求参数
        httpPost.setConfig(config);

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpclient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                return new HttpResult(response.getStatusLine().getStatusCode(),
                        EntityUtils.toString(response.getEntity(), "UTF-8"));
            }
        } finally {
            if (response != null) {
                response.close();
            }
            // httpclient.close();
        }
        return new HttpResult(response.getStatusLine().getStatusCode(), null);

    }
    
    /**
     * 没有带参数的post请求
     * @param url
     * @return
     * @throws Exception
     */
    public HttpResult dopost(String url) throws Exception {
        return this.dopost(url, new HashMap<String, Object>());
    }
    
    /**
     * 指定POST请求 
     * @param url
     * @param json
     * @return
     * @throws Exception
     */
    public HttpResult doPostJson(String url, String json) throws Exception{
        //创建http POST请求
        HttpPost post = new HttpPost(url);
        post.setConfig(this.config);
        if(json != null) {
            //构造一个字符串的实体
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            //将请求实体设置到httppost对象中
            post.setEntity(entity);
            
        }
            
            CloseableHttpResponse response = null;
            try {
             response = this.httpclient.execute(post);
             if(response.getEntity() != null) {
                 return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(response.getEntity(),"UTF-8"));
             }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(response != null) {
                    response.close();
                }
            }
        return new HttpResult(response.getStatusLine().getStatusCode(), null);
        
    }
    /**
     * 
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public HttpResult doPut(String url, Map<String, Object> param)
            throws Exception {
        // 创建http POST请求
        HttpPut put = new HttpPut(url);

        if (param != null) {
            // 设置post参数
            List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString()));
            }
            // 构造一个form表单式的实体，并且指定其编码为UTF-8
            UrlEncodedFormEntity encodedFormEntity = new UrlEncodedFormEntity(
                    parameters, "UTF-8");
            // 将请求实体设置到httppost对象中
            put.setEntity(encodedFormEntity);
        }
        // 执行请求
        CloseableHttpResponse response = null;

        try {
            response = httpclient.execute(put);
            if (response.getEntity() != null) {
                return new HttpResult(response.getStatusLine().getStatusCode(),
                        EntityUtils.toString(response.getEntity(), "UTF-8"));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                response.close();
            }
        }

        return new HttpResult(response.getStatusLine().getStatusCode(), null);
    }
    
    /**
     * 执行PUT请求
     * @param url
     * @return
     * @throws Exception
     */
    public HttpResult doPut(String url) throws Exception {
        return this.doPut(url, null);
    }
    
    /**
     * 执行DELETE请求（真正的DELETE请求）
     * @param url
     * @return
     * @throws Exception
     */
    public HttpResult doDelete(String url) throws Exception {
        //创建http  DELET请求
        HttpDelete delete = new HttpDelete(url);
        delete.setConfig(this.config);
        
        CloseableHttpResponse response = null;
        try {
             response = this.httpclient.execute(delete);
             
             if(response.getEntity() != null) {
                 return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(response.getEntity(), "UTF-8"));
             }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(response != null) {
                response.close();
            }
        }
        return new HttpResult(response.getStatusLine().getStatusCode(), null);
    }
    
    /**
     * 执行DELETE请求通过post提交，_method是真正的请求方法
     * @param url
     * @param param
     * @return
     * @throws Exception
     */
    public HttpResult deDelete(String url, Map<String,Object> param) throws Exception {
        param.put("_method", "DELETE");
        return this.dopost(url, param);
    }
    
    
}

httpclient.properties

httpclient.connectTimeout = 1000
httpclient.connectionRequestTimeout = 500
httpclient.socketTimeout = 10000
httpclient.staleConnectionCheckEnabled = true
httpclient.MaxTotal = 200
httpclient.DefaultMaxPerRoute = 20

HttpResult

    public class HttpResult {

    private Integer code;
    private String body;

    public HttpResult() {
            super();
    }

    public HttpResult(Integer code, String body) {
        super();
        this.code = code;
        this.body = body;
    }

    public Integer getCode() {
        return code;
    }
    
    public void setCode(Integer code) {
        this.code = code;
    }
    
    public String getBody() {
        return body;
    }
    
    public void setBody(String body) {
        this.body = body;
    }

    @Override
    public String toString() {
        return "HttpResult [code=" + code + ", body=" + body + "]";
    }

    }

转载于:https://www.cnblogs.com/sidekick/p/8401798.html