轻松搞定Httpclient服务调用

HttpClient简介

HttpClient是Apache jakarta common下维护的子项目，封装在 commons-httpclient    jar包中，是一个能提供高效、功能丰富的支持http协议的客户端工具包，在java中的应用主要体现在模拟客户端请求，例如同其他系统或项目进行API数据的交互等。为解决并发量大问题，建议升级到高版本，如3.0以上

maven项目直接引入jar依赖

        <!-- HttpClient依赖 -->
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>

Get方式请求

Get方式请求主要分为以下步骤：

1、创建客户端

HttpClient  client = new HttpClient();

2、创建Get方式连接实例 

GetMethod  getMethod = new GetMethod(url);

3、execute方法执行方法实例 

client.executeMethod(getMethod);

4、读取响应response信息 

getMethod.getResponseBody()

5、处理获取到的response信息并释放连接 

method.releaseConnection();

Post方式请求

HttpClient基于post方式请求步骤基本同Get方式，除了

PostMethod method = new PostMethod(url);

通用类的封装

1、使用 MultiThreadedHttpConnectionManager类管理httpclient，类似于连接池复用连接数，同时也解决了多线程下并发访问的问题;

2、下面的代码中包装了一个支持 https请求的post方法; 

3、使用httpclient一定要要根据实际场景正确设置HttpConnectionManagerParams对象的几个参数，不然会有风险。如并发量大时连接池不够、请求等待等风险;

package com.simonsfan.cn.util;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpConnectionManager;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

/**
 * Created by simons on ~.
 */
public class HttpClientUtil {
    private static Logger log = LoggerFactory.getLogger(HttpClientUtil.class);

    private static final String ENCODING = "UTF-8";

    private static final int CONNECTION_TIME_OUT = 3000;

    private static final int SO_TIME_OUT = 5000;

    private static final boolean STALE_CHECK_ENABLED = true;

    private static final boolean TCP_NO_DELAY = true;

    private static final int DEFAULT_MAX_CONNECTIONS_PER_HOST = 100;

    private static final int MAX_TOTAL_CONNECTIONS = 1000;

    private static final HttpConnectionManager connectionManager;

    private static final HttpClient client;

    static {
        HttpConnectionManagerParams params = loadHttpConfFromFile();

        connectionManager = new MultiThreadedHttpConnectionManager();

        connectionManager.setParams(params);

        client = new HttpClient(connectionManager);
    }

    private static HttpConnectionManagerParams loadHttpConfFromFile() {  //这几个参数很重要
        HttpConnectionManagerParams params = new HttpConnectionManagerParams();
        params.setConnectionTimeout(CONNECTION_TIME_OUT);  //连接超时时长
        params.setStaleCheckingEnabled(STALE_CHECK_ENABLED);   //是否启用旧连接检查
        params.setTcpNoDelay(TCP_NO_DELAY);
        params.setSoTimeout(SO_TIME_OUT);                //读取数据超时时长
        params.setDefaultMaxConnectionsPerHost(DEFAULT_MAX_CONNECTIONS_PER_HOST);  //由MultiThreadedHttpConnectionManager管理的最大连接数
        params.setMaxTotalConnections(MAX_TOTAL_CONNECTIONS);    //最大连接数
        params.setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(0, false));
        return params;
    }

    /**
     * get请求
     *
     * @param url
     * @return
     */
    public static String doGet(String url) {
        String result = null;
        try {
            GetMethod getMethod = new GetMethod(url);
            client.executeMethod(getMethod);
            result = getMethod.getResponseBodyAsString();
        } catch (Exception e) {
            log.error("httpclient get request url=" + url + ",exception=" + e);
        }
        return result;
    }

    /**
     * 普通的post请求
     *
     * @param url
     * @return
     */
    public static String doPost(String url) {
        String result = null;
        try {
            PostMethod postMethod = new PostMethod(url);
            client.executeMethod(postMethod);
            result = postMethod.getResponseBodyAsString();
        } catch (IOException e) {
            log.error("httpclient post request url=" + url + ",exception=" + e);
        }
        return result;
    }

    /**
     *  支持https请求的post
     *
     * @param httpsFlag
     * @param params
     * @param url
     * @return
     */
    public static String doPost(boolean httpsFlag, Map<String, String> params, String url) {
        org.apache.http.client.HttpClient client = new DefaultHttpClient();
        String result = "";
        try {
            if (httpsFlag) {
                client = WebClientWrapperUtil.wrapClient(client);
            }
            //设置超时时间
            client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000 * 3);
            HttpPost post = new HttpPost(url);
            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
            if (MapUtils.isNotEmpty(params)) {
                Iterator<String> iterator = params.keySet().iterator();
                while (iterator.hasNext()) {
                    String key = iterator.next();
                    String value = params.get(key);
                    nameValuePairs.add(new BasicNameValuePair(key, value));
                }
                post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
            }
            HttpResponse res = client.execute(post);
            result = streamToStr(res.getEntity().getContent(),ENCODING);
        } catch (Exception e) {
            log.error("url=" + url + "请求异常" + e.getMessage(), e);
        } finally {
            if (client != null) {
                client.getConnectionManager().shutdown();
            }
        }
        return result;
    }


    /**
     * InputStream--->String
     *
     * @param is
     * @param encoding
     * @return
     * @throws IOException
     */
    private static String streamToStr(InputStream is, String encoding) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(is, encoding));
        StringBuffer sb = new StringBuffer();
        String str;
        while (StringUtils.isNotEmpty((str = in.readLine()))) {
            sb.append(str);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
/*      Map<String,String> map = new HashMap<>();
        map.put("req","sss");
        String s = HttpClientUtil.doPost(false,map,"http://×××/virtual/api/order/setRecord");    */
        String s = HttpClientUtil.doGet("http://localhost:80/common/checkjoin");
        System.out.println("result=" + s);
    }
}

import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class WebClientWrapperUtil {
    @SuppressWarnings("deprecation")
    public static HttpClient wrapClient(HttpClient base) throws Exception {
        SSLContext ctx = SSLContext.getInstance("TLS");
        X509TrustManager tm = new X509TrustManager() {
            @Override
            public void checkClientTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) throws java.security.cert.CertificateException {
            }

            @Override
            public void checkServerTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) throws java.security.cert.CertificateException {
            }

            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return new java.security.cert.X509Certificate[0];
            }
        };
        ctx.init(null, new TrustManager[]{tm}, null);
        SSLSocketFactory ssf = new SSLSocketFactory(ctx);
        ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        ClientConnectionManager ccm = base.getConnectionManager();
        SchemeRegistry sr = ccm.getSchemeRegistry();
        sr.register(new Scheme("https", ssf, 443));
        return new DefaultHttpClient(ccm, base.getParams());
    }
}

注意事项:

当url中的参数中包含中文时，一定要先encode下，不然会乱码，导致调用api失败

   @Override
    public String sendMessage(String phone, String content) {
        String result = "";
        try {
            String url = PropertyUtils.getByKey("huyi.postmessage.url", "×××");
            String apiId = PropertyUtils.getByKey("huyi.apiid", "×××");
            String password = PropertyUtils.getByKey("huyi.password", "×××");
            String content1 = URLEncoder.encode(content,"UTF-8");  //这里的content内容是中文，一定要先encode下再拼接
            StringBuffer sb = new StringBuffer(url);
            sb.append("&account=").append(apiId).
                    append("&password=").append(password).
                    append("&mobile=").append(phone).
                    append("&content=").append(content1).
                    append("&format=json");
            String param = sb.toString();
            result = HttpClientUtil.doGet(param);
            log.info("huyi send message result=" + result);
        } catch (Exception e) {
            log.info("sendmessage exception=" + e);
        }
        return result;
   }