HttpClient工具类

import java.io.UnsupportedEncodingException;
import java.security.KeyStore;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.NTCredentials;
import org.apache.http.auth.params.AuthPNames;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.params.AuthPolicy;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.PlainSocketFactory;
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.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

/**
 * httpclient-4.1工具类
 *
 * @author kouyi
 * @version 1.0
 */
public class HttpClientUtil {
    // http代理参数
    private static final boolean isproxy = false; // 设置代理开关
    private static final String proxy_IP = "127.0.0.1";
    private static final int proxy_POST = 8088;
    private static final String proxy_USER = "test";
    private static final String proxy_PASSWD = "test";
    private static final String proxy_DOMAIN = "domain";
    // http连接参数
    private static final int proxy_CONNECTTIMEOUT = 20000; // 连接超时毫秒
    private static final int proxy_SOTIMEOUT = 30000; // 读取超时毫秒
    private static final boolean proxy_SO_REUSEADDR = true; // 是否重用地址
    private static final boolean proxy_TCP_NODELAY = true; // 是否禁用nodelay算法
    private static final boolean proxy_STALE_CONNECTION_CHECK = false; // 是否开启陈旧的连接检查

    /**
     * 执行httpclient GET请求
     *
     * @param url
     * @return
     */
    public static String callHttpGet(String url) {
        return call(new HttpGet(url));
    }

    /**
     * 执行httpclient POST请求
     * @param url
     * @param mapParams
     *            map参数
     * @return
     * @throws Exception
     */
    public static String callHttpPost_Map(String url, Map<String, String> mapParams) {
        HttpPost post = new HttpPost(url);
        List<NameValuePair> data = null;
        UrlEncodedFormEntity formEntity = null;
        if (mapParams != null) {
            data = new ArrayList<NameValuePair>(mapParams.size());
            for (Entry<String, String> entry : mapParams.entrySet()) {
                data.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            // 对参数编码
            try {
                formEntity = new UrlEncodedFormEntity(data, HTTP.UTF_8);
            } catch (UnsupportedEncodingException e) {
                System.out.println("httpclient：编码POST参数失败,原因["+ e.getLocalizedMessage() + "]");
                return null;
            }
            post.setEntity(formEntity);
        }
        return call(post);
    }
    
    /**
     * 执行httpclient POST请求
     *
     * @param url
     * @param body
     *             字符串参数
     * @param bNeedProxy 是否需要代理
     * @return 请求返回的串
     */
    public static String callHttpPost_String(String url, String body) throws Exception {
        HttpPost post = new HttpPost(url);
        StringEntity entity = new StringEntity(body, HTTP.UTF_8);
        entity.setContentEncoding(new BasicHeader(HTTP.CONTENT_ENCODING,"UTF-8"));
        post.setEntity(entity);
        return call(post);
    }

    /**
     * httpclient调用执行
     * @param base
     * @return
     */
    private static String call(HttpRequestBase base) {
        HttpClient httpClient = null;
        try {
            httpClient = getHttpClient();
            HttpResponse response = httpClient.execute(base);
            StatusLine httpstatus = response.getStatusLine();
            if (httpstatus.getStatusCode() != HttpStatus.SC_OK) {
                System.out.println("httpclient：调用[" + base.getURI()+ "]失败,状态码[" + httpstatus.getStatusCode() + "]");
                return null;
            }
            HttpEntity resEntity = response.getEntity();
            String charSet = EntityUtils.getContentCharSet(resEntity); // 获取字符编码
            String relsult = EntityUtils.toString(resEntity, charSet);
            EntityUtils.consume(resEntity); // 关闭流
            return relsult;
        } catch (Exception e) {
            System.out.println("httpclient：调用[" + base.getURI() + "]失败,原因["+ e.getLocalizedMessage() + "]");
            return null;
        } finally {
            if (httpClient != null) { // 关闭连接
                httpClient.getConnectionManager().shutdown();
            }
        }
    }

    /**
     * 创建httpclient对象
     * @return
     */
    @SuppressWarnings("deprecation")
    private static HttpClient getHttpClient() {
        KeyStore trustStore;
        SSLSocketFactory sf = null;
        try {
            trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);
            sf = new HttpSSLSocketFactory(trustStore);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        } catch (Exception e) {
            System.out.println("获取httpclient失败: [" +e.getMessage()+ "]");
        }
        SchemeRegistry schReg = new SchemeRegistry();
        schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        schReg.register(new Scheme("https", sf, 443));
        
        DefaultHttpClient httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(schReg));
        
        // 处理是否需要代理
        if (isproxy) {
            // 加载代理配置
            HttpHost proxy = new HttpHost(proxy_IP, proxy_POST,HttpHost.DEFAULT_SCHEME_NAME);
            httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,proxy);
            // NT认证
            NTCredentials ntCredentials = new NTCredentials(proxy_USER,proxy_PASSWD, proxy_IP, proxy_DOMAIN);
            httpClient.getCredentialsProvider().setCredentials(
                    new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT,AuthScope.ANY_REALM, AuthScope.ANY_SCHEME),ntCredentials);
            // 认证协议类型，
            List<String> authpref = new ArrayList<String>();
            authpref.add(AuthPolicy.NTLM);
            authpref.add(AuthPolicy.BASIC);
            authpref.add(AuthPolicy.DIGEST);
            httpClient.getParams().setParameter(AuthPNames.PROXY_AUTH_PREF,authpref);
        }
        httpClient.getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
        httpClient.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, proxy_CONNECTTIMEOUT);
        httpClient.getParams().setIntParameter(CoreConnectionPNames.SO_TIMEOUT, proxy_SOTIMEOUT);
        httpClient.getParams().setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, proxy_TCP_NODELAY);
        httpClient.getParams().setBooleanParameter(CoreConnectionPNames.SO_REUSEADDR, proxy_SO_REUSEADDR);
        httpClient.getParams().setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, proxy_STALE_CONNECTION_CHECK);
        return httpClient;
    }
}

/**
 *
 */

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

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

import org.apache.http.conn.ssl.SSLSocketFactory;

/**
 * SSL全部信任登录
 *
 * @author linys
 *
 */
public class HttpSSLSocketFactory extends SSLSocketFactory {

    SSLContext sslContext = SSLContext.getInstance("TLS");

    public HttpSSLSocketFactory(KeyStore truststore)
            throws NoSuchAlgorithmException, KeyManagementException,
            KeyStoreException, UnrecoverableKeyException {

        super(truststore);

        TrustManager tm = new X509TrustManager() {

            public void checkClientTrusted(X509Certificate[] chain,
                    String authType) throws CertificateException {
            }

            public void checkServerTrusted(X509Certificate[] chain,
                    String authType) throws CertificateException {
            }

            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }

        };
        sslContext.init(null, new TrustManager[] { tm }, null);
    }

    @Override
    public Socket createSocket(Socket socket, String host, int port,
            boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port,
                autoClose);
    }

    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }

}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.UUID;

import com.mina.rbc.util.DateUtil;
import com.mina.rbc.util.StringUtil;

public class HttpUrlConnectionUtil {

    /**
     * 通过HttpURLConnection模拟post表单提交
     *
     * @param path
     * @param params 例如"name=zhangsan&age=21"
     * @return
     * @throws Exception
     */
    public static String sendPostRequestByForm(String path, String params) throws Exception {
        URL url = new URL(path);
        HttpURLConnection conn = null;
        InputStream inStream = null;
        try {
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");// 提交模式
            conn.setConnectTimeout(10000);// 连接超时 单位毫秒
            conn.setReadTimeout(2000);// 读取超时 单位毫秒
            conn.setDoOutput(true);// 是否输入参数
            byte[] bypes = params.toString().getBytes();
            conn.getOutputStream().write(bypes);// 输入参数
            inStream = conn.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(  inStream));
            StringBuffer responseResult = new StringBuffer();
            String line;  
            while ((line = bufferedReader.readLine()) != null) {
                if (responseResult.length() != 0){
                    responseResult.append("/n");
                }
                responseResult.append(line);
            }  

            return responseResult.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (null != inStream){
                inStream.close();
            }
        }
    }

    public static void main(String[] args) throws Exception{

    }
}