HttpsUtil的get和post方法

package com.cmos.ebs.util;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.StringWriter;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.SecureRandom;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.KeyManager;

import javax.net.ssl.SSLContext;

import javax.net.ssl.SSLSession;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.util.EntityUtils;

import com.cmos.core.logger.Logger;

import com.cmos.core.logger.LoggerFactory;

public class HttpsUtil {
private static final String METHOD_POST = "POST";  

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

    private static final int connectTimeout = 6000; 

    private static final int readTimeout = 6000; 

    private static final Logger log = LoggerFactory.getUtilLog(HttpsUtil.class);

    

    

    
public static String doPost(String url, String str) {
String charset = DEFAULT_CHARSET;
String ctype = "application/json;charset=" + charset;
HttpsURLConnection conn = null;
OutputStream out = null;
String rsp = null;
byte[] content = null;
try {
content = str.getBytes(charset);
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() {

public boolean verify(String hostname, SSLSession session) {
return true;
}
});
conn.setConnectTimeout(connectTimeout);
conn.setReadTimeout(readTimeout);

out = conn.getOutputStream();
out.write(content);
rsp = getResponseAsString(conn);
} catch (Exception e) {
log.error("REQUEST_RESPONSE_ERROR, URL = " + url, e);
} finally {
try {
if (out != null)out.close();
if (conn != null)conn.disconnect();
} catch (Exception e) {
log.error("REQUEST_RESPONSE_ERROR, URL = " + url, e);
}
}

return rsp;
}  

public static String get(String path) throws Exception{
 HttpsURLConnection httpConn=null;
 BufferedReader in=null;
 try {
  URL url=new URL(path);
  httpConn=(HttpsURLConnection)url.openConnection();

  //读取响应
  if(httpConn.getResponseCode()==200){
   StringBuffer content=new StringBuffer();
   String tempStr="";
   in=new BufferedReader(new InputStreamReader(httpConn.getInputStream()));
   while((tempStr=in.readLine())!=null){
    content.append(tempStr);
   }
   return content.toString();
  }else{
  log.error("请求出现问题");
  }
 } catch (IOException e) {
 log.error("IOException:", e.getMessage(),e);
 }finally{
  in.close();
  httpConn.disconnect();
 }
 return null;
}
public static String doDelete(String url, String str) {

String charset = DEFAULT_CHARSET;
String ctype = "application/json;charset=" + charset;
HttpsURLConnection conn = null;
OutputStream out = null;
String rsp = null;
byte[] content = null;
try {
content = str.getBytes(charset);
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(new KeyManager[0], new TrustManager[] { new DefaultTrustManager() }, new SecureRandom());
SSLContext.setDefault(ctx);

conn = getConnection(new URL(url),"DELETE", ctype);
conn.setHostnameVerifier(new HostnameVerifier() {

public boolean verify(String hostname, SSLSession session) {
return true;
}
});
conn.setConnectTimeout(connectTimeout);
conn.setReadTimeout(readTimeout);

out = conn.getOutputStream();
out.write(content);
rsp = getResponseAsString(conn);
} catch (Exception e) {
log.error
4000
("REQUEST_RESPONSE_ERROR, URL = " + url, e);
} finally {

try {
if (out != null)out.close();
if (conn != null)conn.disconnect();
} catch (Exception e) {
log.error("REQUEST_RESPONSE_ERROR, URL = " + url, e);
}
}

return rsp;

}

  

    private static class DefaultTrustManager implements X509TrustManager {

public void checkClientTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
}
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;  

    }  

}