Java访问https接口实现（JDK/Httpclient4）

用两种方式分别实现了，第一种是jdk原生的，代码稍微多点，第二种是基于httpclient4版本的。在我的机器上，访问同一个接口原生的性能要好很多（前者900ms，后者5.7s左右），httpclient主要性能消耗在"HttpResponse res = client.execute(post);"，大约占总执行时间的90%。

 

1、JDK API

 

 private static final String METHOD_POST = "POST";
     private static final String DEFAULT_CHARSET = "utf-8";

     public static String doPost(String url, String params, String charset, int connectTimeout, int readTimeout) throws Exception {
         String ctype = "application/json;charset=" + charset;
         byte[] content = {};
         if(params != null){
             content = params.getBytes(charset);
         }

         return doPost(url, ctype, content, connectTimeout, readTimeout);
     }
     public static String doPost(String url, String ctype, byte[] content,int connectTimeout,int readTimeout) throws Exception {
         HttpsURLConnection conn = null;
         OutputStream out = null;
         String rsp = null;
         try {
             try{
                 SSLContext ctx = SSLContext.getInstance("TLS");
                 ctx.init(new KeyManager[0], new TrustManager[] {new DefaultTrustManager()}, new SecureRandom());
                 SSLContext.setDefault(ctx);

                 conn = getConnection(new URL(url), METHOD_POST, ctype);
                 conn.setHostnameVerifier(new HostnameVerifier() {
                     @Override
                     public boolean verify(String hostname, SSLSession session) {
                         return true;
                     }
                 });
                 conn.setConnectTimeout(connectTimeout);
                 conn.setReadTimeout(readTimeout);
             }catch(Exception e){
                 log.error("GET_CONNECTOIN_ERROR, URL = " + url, e);
                 throw e;
             }
             try{
                 out = conn.getOutputStream();
                 out.write(content);
                 rsp = getResponseAsString(conn);
             }catch(IOException e){
                 log.error("REQUEST_RESPONSE_ERROR, URL = " + url, e);
                 throw e;
             }

         }finally {
             if (out != null) {
                 out.close();
             }
             if (conn != null) {
                 conn.disconnect();
             }
         }

         return rsp;
     }

     private static class DefaultTrustManager implements X509TrustManager {

         @Override
         public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {}

         @Override
         public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {}

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

     }

     private static HttpsURLConnection getConnection(URL url, String method, String ctype)
             throws IOException {
         HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
         conn.setRequestMethod(method);
         conn.setDoInput(true);
         conn.setDoOutput(true);
         conn.setRequestProperty("Accept", "text/xml,text/javascript,text/html");
         conn.setRequestProperty("User-Agent", "stargate");
         conn.setRequestProperty("Content-Type", ctype);
         return conn;
     }

     protected static String getResponseAsString(HttpURLConnection conn) throws IOException {
         String charset = getResponseCharset(conn.getContentType());
         InputStream es = conn.getErrorStream();
         if (es == null) {
             return getStreamAsString(conn.getInputStream(), charset);
         } else {
             String msg = getStreamAsString(es, charset);
             if (StringUtils.isEmpty(msg)) {
                 throw new IOException(conn.getResponseCode() + ":" + conn.getResponseMessage());
             } else {
                 throw new IOException(msg);
             }
         }
     }

     private static String getStreamAsString(InputStream stream, String charset) throws IOException {
         try {
             BufferedReader reader = new BufferedReader(new InputStreamReader(stream, charset));
             StringWriter writer = new StringWriter();

             char[] chars = new char[256];
             int count = 0;
             while ((count = reader.read(chars)) > 0) {
                 writer.write(chars, 0, count);
             }

             return writer.toString();
         } finally {
             if (stream != null) {
                 stream.close();
             }
         }
     }

     private static String getResponseCharset(String ctype) {
         String charset = DEFAULT_CHARSET;

         if (!StringUtils.isEmpty(ctype)) {
             String[] params = ctype.split(";");
             for (String param : params) {
                 param = param.trim();
                 if (param.startsWith("charset")) {
                     String[] pair = param.split("=", 2);
                     if (pair.length == 2) {
                         if (!StringUtils.isEmpty(pair[1])) {
                             charset = pair[1].trim();
                         }
                     }
                     break;
                 }
             }
         }

         return charset;
     }

 

2、Httpclient API 

 public static JSONObject post(String url, String json) {
         HttpClient client = new DefaultHttpClient();
         client = WebClientDevWrapper.wrapClient(client);
         HttpPost post = new HttpPost(url);
         JSONObject response = null;
         try {
             StringEntity s = new StringEntity(json);
             s.setContentEncoding("UTF-8");
             s.setContentType("application/json");
             post.setEntity(s);

             Long startTime = System.currentTimeMillis();
             HttpResponse res = client.execute(post);
             System.out.println(System.currentTimeMillis() - startTime);
             if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                 HttpEntity entity = res.getEntity();
                 String charset = EntityUtils.getContentCharSet(entity);
                 if(charset == null){
                     charset = "utf-8";
                 }
                 response = new JSONObject(new JSONTokener(
                         new InputStreamReader(entity.getContent(), charset)));
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
         return response;
     }

     public static class WebClientDevWrapper {
         public static HttpClient wrapClient(HttpClient base) {
             try {
                 SSLContext ctx = SSLContext.getInstance("TLS");
                 X509TrustManager tm = new X509TrustManager() {
                     @Override
                     public X509Certificate[] getAcceptedIssuers() {
                         return null;
                     }

                     @Override
                     public void checkClientTrusted(
                             java.security.cert.X509Certificate[] chain,
                             String authType)
                             throws java.security.cert.CertificateException {

                     }

                     @Override
                     public void checkServerTrusted(
                             java.security.cert.X509Certificate[] chain,
                             String authType)
                             throws java.security.cert.CertificateException {

                     }
                 };
                 ctx.init(null, new TrustManager[] { tm }, null);
                 SSLSocketFactory ssf = new SSLSocketFactory(ctx, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                 ClientConnectionManager ccm = base.getConnectionManager();
                 SchemeRegistry sr = ccm.getSchemeRegistry();
                 sr.register(new Scheme("https", 443, ssf));
                 return new DefaultHttpClient(ccm, base.getParams());
             } catch (Exception ex) {
                 ex.printStackTrace();
                 return null;
             }
         }
     }