https post

/**
* Post请求连接Https服务
* 
* @param serverURL
*            请求地址
* @param jsonStr
*            请求报文
* @return
* @throws Exception
* 
*/


public static synchronized String doHttpsPost(String serverURL,
String jsonStr) {
// 参数
HttpParams httpParameters = new BasicHttpParams();
// 设置连接超时
HttpConnectionParams.setConnectionTimeout(httpParameters, 3000);
// 设置socket超时
HttpConnectionParams.setSoTimeout(httpParameters, 3000);
// 获取HttpClient对象 （认证）
HttpClient hc = initHttpClient(httpParameters);
HttpPost post = new HttpPost(serverURL);
// 发送数据类型
post.addHeader("Content-Type", "application/json;charset=utf-8");
// 接受数据类型
post.addHeader("Accept", "application/json");
// 请求报文


try {
StringEntity entity = new StringEntity(jsonStr, "UTF-8");
post.setEntity(entity);
post.setParams(httpParameters);
HttpResponse response = null;
response = hc.execute(post);
int sCode = response.getStatusLine().getStatusCode();
if (sCode == HttpStatus.SC_OK) {
return EntityUtils.toString(response.getEntity());
} else
return null;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (SocketException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return "1";


}


private static HttpClient client = null;


/**
* 初始化HttpClient对象
* 
* @param params
* @return
*/
public static synchronized HttpClient initHttpClient(HttpParams params) {
if (client == null) {
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore
.getDefaultType());
trustStore.load(null, null);


SSLSocketFactory sf = new SSLSocketFactoryImp(trustStore);
// 允许所有主机的验证
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);


HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
// 设置http和https支持
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory
.getSocketFactory(), 80));
registry.register(new Scheme("https", sf, 443));


ClientConnectionManager ccm = new ThreadSafeClientConnManager(
params, registry);


return new DefaultHttpClient(ccm, params);
} catch (Exception e) {
e.printStackTrace();
return new DefaultHttpClient(params);
}
}
return client;
}


public static class SSLSocketFactoryImp extends SSLSocketFactory {
final SSLContext sslContext = SSLContext.getInstance("TLS");


public SSLSocketFactoryImp(KeyStore truststore)
throws NoSuchAlgorithmException, KeyManagementException,
KeyStoreException, UnrecoverableKeyException {
super(truststore);


TrustManager tm = new X509TrustManager() {
public java.security.cert.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 {
}
};
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();
}
}