JAVA开发_网络连接请求

最新推荐文章于 2024-11-14 16:54:29 发布

xiaoyaoxiaozi02

最新推荐文章于 2024-11-14 16:54:29 发布

阅读量184

点赞数

文章标签： java json javascript ViewUI

发起交易请求

   //实例化对象  
    HttpClient httpClient=CustomHttpClient.GetHttpClient();

    /**
     * 发起交易请求
     * 
     * @param bean
     * @return
     */
    public String request(String reqJson, String url)
    {
        System.out.println("发起url[" + url + "]请求报文:" + reqJson);
        HttpPost post = new HttpPost(url);
        post.setHeader("Content-Type",
                "application/json;charset=UTF-8");
        BufferedReader br = null;
        try
        {
            StringEntity formEntiry = new StringEntity(reqJson, "UTF-8");
            // 设置请求参数
            post.setEntity(formEntiry);
            // 发起交易
            HttpResponse resp = httpClient.execute(post);
            // 响应分析
            HttpEntity entity = resp.getEntity();
            br = new BufferedReader(new InputStreamReader(entity.getContent(),
                    "utf-8"));
            StringBuffer responseString = new StringBuffer();
            String result = br.readLine();
            while (result != null)
            {
                responseString.append(result);
                result = br.readLine();
            }
            // 直接获取返回的字符串
            String resJson = responseString.toString();
            System.out.println("返回报文:" + resJson);
            return resJson;
        } catch (Exception cte)
        {
            System.out.print(cte);
            return "";
        } finally
        {
            if (br != null)
            {
                try
                {
                    br.close();
                } catch (IOException e)
                {
                    // do nothing
                }
            }
        }
    }

线程安全的HttpCLient,单例模式，支持http、https协议

 public static synchronized HttpClient GetHttpClient()
    {

        if (customHttpClient == null)
        {
            return httpClientInstance();
        }
        return customHttpClient;
    }

    private static HttpClient httpClientInstance()
    {

        KeyStore trustStore;
        SSLSocketFactory sf = null;
        try
        {
            trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);
            sf = new MySSLSocketFactory(trustStore);
            sf
                    .setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        } catch (KeyManagementException e)
        {
            log.error(e.getMessage(), e);
        } catch (NoSuchAlgorithmException e)
        {
            log.error(e.getMessage(), e);
        } catch (UnrecoverableKeyException e)
        {
            log.error(e.getMessage(), e);
        } catch (IOException e)
        {
            log.error(e.getMessage(), e);
        } catch (CertificateException e)
        {
            log.error(e.getMessage(), e);
        } catch (KeyStoreException e)
        {
            log.error(e.getMessage(), e);
        }
        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
        ConnManagerParams.setTimeout(params, TIME_OUT);
        HttpConnectionParams.setConnectionTimeout(params, TIME_OUT);
        HttpConnectionParams.setSoTimeout(params, TIME_OUT);
        SchemeRegistry schReg = new SchemeRegistry();
        schReg.register(new Scheme("http", PlainSocketFactory
                .getSocketFactory(), 80));
        schReg.register(new Scheme("https", sf, 443));

        ClientConnectionManager conMgr = new ThreadSafeClientConnManager(
                params, schReg);
        customHttpClient = new DefaultHttpClient(conMgr, params);
        return customHttpClient;
    }

SSL全部信任登录


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全部信任登录
 * 
 * 
 */
public class MySSLSocketFactory extends SSLSocketFactory{

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

    public MySSLSocketFactory(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();
    }

}