package com.hx.mp.util;
|
|
import java.io.BufferedReader;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.security.KeyManagementException;
|
import java.security.KeyStore;
|
import java.security.KeyStoreException;
|
import java.security.NoSuchAlgorithmException;
|
import java.security.SecureRandom;
|
import java.security.UnrecoverableKeyException;
|
import java.security.cert.Certificate;
|
import java.security.cert.CertificateException;
|
import java.security.cert.CertificateFactory;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
import javax.net.ssl.HttpsURLConnection;
|
import javax.net.ssl.KeyManagerFactory;
|
import javax.net.ssl.SSLContext;
|
import javax.net.ssl.TrustManagerFactory;
|
|
/**
|
* Http�ͻ��˹�����<br/>
|
* �����ڲ������࣬�벻Ҫ���ⲿ���á�
|
* @author miklchen
|
*
|
*/
|
public class HttpClientUtil {
|
|
public static final String SunX509 = "SunX509";
|
public static final String JKS = "JKS";
|
public static final String PKCS12 = "PKCS12";
|
public static final String TLS = "TLS";
|
|
/**
|
* get HttpURLConnection
|
* @param strUrl url��ַ
|
* @return HttpURLConnection
|
* @throws IOException
|
*/
|
public static HttpURLConnection getHttpURLConnection(String strUrl)
|
throws IOException {
|
URL url = new URL(strUrl);
|
HttpURLConnection httpURLConnection = (HttpURLConnection) url
|
.openConnection();
|
return httpURLConnection;
|
}
|
|
/**
|
* get HttpsURLConnection
|
* @param strUrl url��ַ
|
* @return HttpsURLConnection
|
* @throws IOException
|
*/
|
public static HttpsURLConnection getHttpsURLConnection(String strUrl)
|
throws IOException {
|
URL url = new URL(strUrl);
|
HttpsURLConnection httpsURLConnection = (HttpsURLConnection) url
|
.openConnection();
|
return httpsURLConnection;
|
}
|
|
/**
|
* ��ȡ�����ѯ����url
|
* @param strUrl
|
* @return String
|
*/
|
public static String getURL(String strUrl) {
|
|
if(null != strUrl) {
|
int indexOf = strUrl.indexOf("?");
|
if(-1 != indexOf) {
|
return strUrl.substring(0, indexOf);
|
}
|
|
return strUrl;
|
}
|
|
return strUrl;
|
|
}
|
|
/**
|
* ��ȡ��ѯ��
|
* @param strUrl
|
* @return String
|
*/
|
public static String getQueryString(String strUrl) {
|
|
if(null != strUrl) {
|
int indexOf = strUrl.indexOf("?");
|
if(-1 != indexOf) {
|
return strUrl.substring(indexOf+1, strUrl.length());
|
}
|
|
return "";
|
}
|
|
return strUrl;
|
}
|
|
/**
|
* ��ѯ�ַ�ת����Map<br/>
|
* name1=key1&name2=key2&...
|
* @param queryString
|
* @return
|
*/
|
@SuppressWarnings("rawtypes")
|
public static Map queryString2Map(String queryString) {
|
if(null == queryString || "".equals(queryString)) {
|
return null;
|
}
|
|
Map m = new HashMap();
|
String[] strArray = queryString.split("&");
|
for(int index = 0; index < strArray.length; index++) {
|
String pair = strArray[index];
|
HttpClientUtil.putMapByPair(pair, m);
|
}
|
|
return m;
|
|
}
|
|
/**
|
* �Ѽ�ֵ�����Map<br/>
|
* pair:name=value
|
* @param pair name=value
|
* @param m
|
*/
|
@SuppressWarnings({ "unchecked", "rawtypes" })
|
public static void putMapByPair(String pair, Map m) {
|
|
if(null == pair || "".equals(pair)) {
|
return;
|
}
|
|
int indexOf = pair.indexOf("=");
|
if(-1 != indexOf) {
|
String k = pair.substring(0, indexOf);
|
String v = pair.substring(indexOf+1, pair.length());
|
if(null != k && !"".equals(k)) {
|
m.put(k, v);
|
}
|
} else {
|
m.put(pair, "");
|
}
|
}
|
|
/**
|
* BufferedReaderת����String<br/>
|
* ע��:���ر���Ҫ���д���
|
* @param reader
|
* @return String
|
* @throws IOException
|
*/
|
public static String bufferedReader2String(BufferedReader reader) throws IOException {
|
StringBuffer buf = new StringBuffer();
|
String line = null;
|
while( (line = reader.readLine()) != null) {
|
buf.append(line);
|
buf.append("\r\n");
|
}
|
|
return buf.toString();
|
}
|
|
/**
|
* �������<br/>
|
* ע��:���ر���Ҫ���д���
|
* @param out
|
* @param data
|
* @param len
|
* @throws IOException
|
*/
|
public static void doOutput(OutputStream out, byte[] data, int len)
|
throws IOException {
|
int dataLen = data.length;
|
int off = 0;
|
while (off < data.length) {
|
if (len >= dataLen) {
|
out.write(data, off, dataLen);
|
off += dataLen;
|
} else {
|
out.write(data, off, len);
|
off += len;
|
dataLen -= len;
|
}
|
|
// ˢ�»�����
|
out.flush();
|
}
|
|
}
|
|
/**
|
* ��ȡSSLContext
|
* @param trustFile
|
* @param trustPasswd
|
* @param keyFile
|
* @param keyPasswd
|
* @return
|
* @throws NoSuchAlgorithmException
|
* @throws KeyStoreException
|
* @throws IOException
|
* @throws CertificateException
|
* @throws UnrecoverableKeyException
|
* @throws KeyManagementException
|
*/
|
public static SSLContext getSSLContext(
|
FileInputStream trustFileInputStream, String trustPasswd,
|
FileInputStream keyFileInputStream, String keyPasswd)
|
throws NoSuchAlgorithmException, KeyStoreException,
|
CertificateException, IOException, UnrecoverableKeyException,
|
KeyManagementException {
|
|
// ca
|
TrustManagerFactory tmf = TrustManagerFactory.getInstance(HttpClientUtil.SunX509);
|
KeyStore trustKeyStore = KeyStore.getInstance(HttpClientUtil.JKS);
|
trustKeyStore.load(trustFileInputStream, HttpClientUtil
|
.str2CharArray(trustPasswd));
|
tmf.init(trustKeyStore);
|
|
final char[] kp = HttpClientUtil.str2CharArray(keyPasswd);
|
KeyManagerFactory kmf = KeyManagerFactory.getInstance(HttpClientUtil.SunX509);
|
KeyStore ks = KeyStore.getInstance(HttpClientUtil.PKCS12);
|
ks.load(keyFileInputStream, kp);
|
kmf.init(ks, kp);
|
|
SecureRandom rand = new SecureRandom();
|
SSLContext ctx = SSLContext.getInstance(HttpClientUtil.TLS);
|
ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), rand);
|
|
return ctx;
|
}
|
|
/**
|
* ��ȡCA֤����Ϣ
|
* @param cafile CA֤���ļ�
|
* @return Certificate
|
* @throws CertificateException
|
* @throws IOException
|
*/
|
public static Certificate getCertificate(File cafile)
|
throws CertificateException, IOException {
|
CertificateFactory cf = CertificateFactory.getInstance("X.509");
|
FileInputStream in = new FileInputStream(cafile);
|
Certificate cert = cf.generateCertificate(in);
|
in.close();
|
return cert;
|
}
|
|
/**
|
* �ַ�ת����char����
|
* @param str
|
* @return char[]
|
*/
|
public static char[] str2CharArray(String str) {
|
if(null == str) return null;
|
|
return str.toCharArray();
|
}
|
|
/**
|
* �洢ca֤���JKS��ʽ
|
* @param cert
|
* @param alias
|
* @param password
|
* @param out
|
* @throws KeyStoreException
|
* @throws NoSuchAlgorithmException
|
* @throws CertificateException
|
* @throws IOException
|
*/
|
public static void storeCACert(Certificate cert, String alias,
|
String password, OutputStream out) throws KeyStoreException,
|
NoSuchAlgorithmException, CertificateException, IOException {
|
KeyStore ks = KeyStore.getInstance("JKS");
|
|
ks.load(null, null);
|
|
ks.setCertificateEntry(alias, cert);
|
|
// store keystore
|
ks.store(out, HttpClientUtil.str2CharArray(password));
|
|
}
|
|
public static InputStream String2Inputstream(String str) {
|
return new ByteArrayInputStream(str.getBytes());
|
}
|
|
/**
|
* InputStreamת����Byte
|
* ע��:���ر���Ҫ���д���
|
* @param in
|
* @return byte
|
* @throws Exception
|
*/
|
public static byte[] InputStreamTOByte(InputStream in) throws IOException{
|
|
int BUFFER_SIZE = 4096;
|
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
|
byte[] data = new byte[BUFFER_SIZE];
|
int count = -1;
|
|
while((count = in.read(data,0,BUFFER_SIZE)) != -1)
|
outStream.write(data, 0, count);
|
|
data = null;
|
byte[] outByte = outStream.toByteArray();
|
outStream.close();
|
|
return outByte;
|
}
|
|
/**
|
* InputStreamת����String
|
* ע��:���ر���Ҫ���д���
|
* @param in
|
* @param encoding ����
|
* @return String
|
* @throws Exception
|
*/
|
public static String InputStreamTOString(InputStream in,String encoding) throws IOException{
|
|
return new String(InputStreamTOByte(in),encoding);
|
|
}
|
|
|
}
|
