http方式调用webservice

http方式调用webservice

import org.apache.commons.httpclient.HttpStatus;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.IOException;

/**
 * 通过Http Post调用webservice服务
 * 
 *
 */
public class CommonWebServiceClient {

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

	@Autowired
	private CommonHttpServiceClient commonHttpServiceClient;

	private String requestCharSet;

	private String responseCharSet;

	/**
	 * 
	 * @param postUrl webservice地址 
	 * @param requestXML 请求报文（soapUI工具请求报文）
	 * @param connectionTimeout 连接超时时间
	 * @param requestTimeout 请求超时时间
	 * @return
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public String invokeService(String postUrl, String requestXML, int connectionTimeout, int requestTimeout)
			throws ClientProtocolException, IOException {

		CloseableHttpClient httpClient = commonHttpServiceClient.getConnection(connectionTimeout, requestTimeout);
		HttpPost httpPost = new HttpPost(postUrl);

		StringEntity entity = new StringEntity(requestXML, requestCharSet);
		httpPost.setEntity(entity);
		httpPost.setHeader("Content-Type", "text/xml; charset="+requestCharSet);
		httpPost.setHeader("SOAPAction", "");
		CloseableHttpResponse httpResponse = httpClient.execute(httpPost);

		String result = null;
		int iCode = httpResponse.getStatusLine().getStatusCode();
		if (HttpStatus.SC_OK == iCode) {
			HttpEntity httpEntity = httpResponse.getEntity();
			result = EntityUtils.toString(httpEntity, responseCharSet);
		} else { // 如果返回非200，则手动关闭连接
			httpPost.abort();
			logger.info("get status code {} from server", httpResponse.getStatusLine().getStatusCode());
		}
		return result;
	}

	public void setRequestCharSet(String requestCharSet) {
		this.requestCharSet = requestCharSet;
	}

	public void setResponseCharSet(String responseCharSet) {
		this.responseCharSet = responseCharSet;
	}
	
	public String getRequestCharSet() {
		return requestCharSet;
	}

	public String getResponseCharSet() {
		return responseCharSet;
	}
}

http 连接池

import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;

import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.PostConstruct;
import javax.net.ssl.SSLContext;

import java.net.URI;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;

/**
 * 
 * 该类主要提供http相关的服务功能：(1)连接池
 */
public class CommonHttpServiceClient {

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

    private static PoolingHttpClientConnectionManager poolConnManager;

    private int maxConnection;
    private int maxConnPerRoute;
    private int socketTimeout;

    @PostConstruct
    public void init() {
        try {
            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null,
                    new TrustSelfSignedStrategy())
                    .build();
            X509HostnameVerifier hostnameVerifier = SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslcontext, hostnameVerifier);
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslConnectionSocketFactory)
                    .build();
            poolConnManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            poolConnManager.setMaxTotal(getMaxConnection());
            poolConnManager.setDefaultMaxPerRoute(getMaxConnPerRoute());
            SocketConfig socketConfig = SocketConfig.custom().setSoTimeout(getSocketTimeout()).build();
            poolConnManager.setDefaultSocketConfig(socketConfig);
        } catch (Exception e) {
            logger.error("catch exception when init PoolingHttpClientConnectionManager:" + e);
        }
    }

    public CloseableHttpClient getConnection(int connectionTimeout, int requestTimeout) {
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionTimeout)
                .setConnectTimeout(connectionTimeout).setSocketTimeout(requestTimeout).build();
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(poolConnManager).setDefaultRequestConfig(requestConfig).build();
        if (null != poolConnManager && null != poolConnManager.getTotalStats()) {
            logger.info("now client pool " + poolConnManager.getTotalStats().toString());
        }
        return httpClient;
    }

    public static URI buildUri(String url, Map<String, String> parametersMap) {
        if (null == parametersMap || parametersMap.isEmpty()) {
            return URI.create(url);
        }
        ArrayList list = new ArrayList(parametersMap.size());
        Iterator iterator = parametersMap.entrySet().iterator();

        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            list.add(entry.getKey().toString().trim() + "=" + entry.getValue().toString().trim());
        }
        return list.isEmpty() ? URI.create(url) : URI.create(url + "?" + StringUtils.join(list, "&"));
    }

    public int getMaxConnection() {
        return maxConnection;
    }

    public void setMaxConnection(int maxConnection) {
        this.maxConnection = maxConnection;
    }

    public int getMaxConnPerRoute() {
        return maxConnPerRoute;
    }

    public void setMaxConnPerRoute(int maxConnPerRoute) {
        this.maxConnPerRoute = maxConnPerRoute;
    }

    public int getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
    }
}

配置文件

    <bean id="commonHttpServiceClient" class="com.service.client.impl.CommonHttpServiceClient">
        <property name="maxConnection" value="${http.connection.pool.max.connecton}"/>
        <property name="maxConnPerRoute" value="${http.connection.pool.max.connection.per.router}"/>
        <property name="socketTimeout" value="${http.connection.pool.socket.timeout}"/>
    </bean>

值：

http.connection.pool.max.connecton=2000
http.connection.pool.max.connection.per.router=50
http.connection.pool.socket.timeout=5000

如果出现httpclient一段时间后首次访问缓慢，可能是由于长连接被异常关闭，选择关闭长连接使用get方式 

        HttpGet get = new HttpGet("https://www.baidu.com");
        get.setHeader("Connection", "close");