import java.io.BufferedReader;
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Serializable;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.activation.MimetypesFileTypeMap;
import javax.net.ssl.*;
import java.security.cert.Certificate;
public class HttpUtil {
public static final String DEFAULT_CHARSET = "UTF-8";
public static final String METHOD_POST = "POST";
public static final String METHOD_GET = "GET";
public static final int BUFFER_SIZE = 8192; // 8K
public static final int CONNECT_TIMEOUT = 3000; // 3s
public static final int READ_TIMEOUT = 60000; // 6s
public static final int READ_FILE_TIMEOUT = 3600000; // 3600s
public static final String KEY_X_REQUESTED_WITH = "X-Requested-With";
public static final String KEY_USER_AGENT = "User-Agent";
public static final String KEY_ACCEPT_ENCODING = "Accept-Encoding";
public static final String KEY_CONTENT_TYPE = "Content-Type";
public static final String KEY_ACCEPT_LANGUAGE = "Accept-Language";
public static final String KEY_CONNECTION = "Connection";
public static final String KEY_CACHE_CONTROL = "Cache-Control";
public static final String KEY_ACCEPT = "Accept";
public static final String KEY_CHARSERT = "Charsert";
public static final String KEY_COOKIE = "Cookie";
// 定义数据分隔线
private static String BOUNDARY = "---------------------------71a816d53b6o219";
private HttpUtil() {
}
/**
* 测试url是否可连接，默认3秒超时
* @param url 请求地址
* @return
*/
public static boolean isConnected(String url) {
try {
return isConnected(new URL(url), CONNECT_TIMEOUT);
} catch (MalformedURLException e) {
return false;
}
}
/**
* 测试url是否可连接
* @param url 请求地址
* @param timeout 超时时间
* @return
*/
public static boolean isConnected(String url, int timeout) {
try {
return isConnected(new URL(url), timeout);
} catch (MalformedURLException e) {
return false;
}
}
/**
* 测试url是否可连接
* @param url 请求地址
* @return
*/
public static boolean isConnected(URL url) {
return isConnected(url, CONNECT_TIMEOUT);
}
/**
* 测试url是否可连接
* @param url 请求地址
* @param timeout 超时时间
* @return
*/
public static boolean isConnected(URL url, int timeout) {
HttpURLConnection httpConn = null;
try {
httpConn = (HttpURLConnection) url.openConnection();
httpConn.setConnectTimeout(timeout);
httpConn.connect();
int responseCode = httpConn.getResponseCode();
return isSuccess(responseCode);
} catch (Exception e) {
return false;
} finally {
close(httpConn);
}
}
/**
* 发送异步请求，返回响应的结果
* @param httpParameter 请求参数
* @return
* @throws IOException
*/
public static HttpResult ajaxRequest(HttpParameter httpParameter) throws IOException {
// Ajax 异步请求方式
httpParameter.putDefaultProperty(KEY_X_REQUESTED_WITH, "XMLHttpRequest");
return httpRequest(httpParameter);
}
/**
* 发送http请求，返回响应的结果
* @param httpParameter 请求参数
* @return
* @throws IOException
*/
public static HttpResult httpRequest(HttpParameter httpParameter) throws IOException {
HttpURLConnection httpConn = null;
try {
httpConn = getHttpConn(httpParameter);
return getResponseAsString(httpConn);
} finally {
close(httpConn);
}
}
/**
* 发送POST请求，下载远程文件
* @param url 请求地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param file 文件保存路径
* @param params 请求时传递的参数
* @param charset 字符集
* @param property HttpURLConnection属性配置,对象不允许为空
* @return File 文件保存路径
* @throws IOException
*/
public static File ajaxDownload(HttpParameter httpParameter, File file) throws IOException {
// Ajax 异步请求方式
httpParameter.putDefaultProperty(KEY_X_REQUESTED_WITH, "XMLHttpRequest");
return httpDownload(httpParameter, file);
}
/**
* 下载远程文件
* @param url 请求地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param file 文件保存路径
* @param params 请求时传递的参数
* @param charset 字符集
* @param property HttpURLConnection属性配置,对象不允许为空
* @return File 文件保存路径
* @throws IOException
*/
public static File httpDownload(HttpParameter httpParameter, File file) throws IOException {
HttpURLConnection httpConn = null;
try {
httpConn = getHttpConn(httpParameter);
return getResponseAsFile(httpConn, file);
} finally {
close(httpConn);
}
}
/**
* 发送POST异步请求，上传文件
* @param url 请求地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param fileMap 上传的文件和对应的字段信息
* @param params 请求时传递的参数
* @return
* @throws IOException
*/
public static HttpResult ajaxUpload(HttpParameter httpParameter, List<File> fileList) throws IOException {
// Ajax 异步请求方式
httpParameter.putDefaultProperty(KEY_X_REQUESTED_WITH, "XMLHttpRequest");
return httpUpload(httpParameter, fileList);
}
/**
* 发送POST异步请求，上传文件
* @param url 请求地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param fileMap 上传的文件和对应的字段信息
* @param params 请求时传递的参数
* @return
* @throws IOException
*/
public static HttpResult ajaxUpload(HttpParameter httpParameter, Map<String, File> fileMap) throws IOException {
// Ajax 异步请求方式
httpParameter.putDefaultProperty(KEY_X_REQUESTED_WITH, "XMLHttpRequest");
return httpUpload(httpParameter, fileMap);
}
/**
* 发送POST请求，返回响应的结果
* @param httpParameter 请求地址
* @param fileList 上传的文件列表
* @return
* @throws IOException
*/
public static HttpResult httpUpload(HttpParameter httpParameter, List<File> fileList) throws IOException {
Map<String, File> fileMap = new HashMap<String, File>();
for (File file : fileList) {
fileMap.put(file.getName(), file);
}
return httpUpload(httpParameter, fileMap);
}
/**
* 发送http请求，返回响应的结果
* @param url 请求地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param fileMap 上传的文件和对应的字段信息
* @param params 请求时传递的参数
* @param charset 请求的编码
* @param property HttpURLConnection属性配置,对象不允许为空
* @return
* @throws IOException
*/
public static HttpResult httpUpload(HttpParameter httpParameter, Map<String, File> fileMap) throws IOException {
String url = httpParameter.getUrl();
Map<String, String> params = httpParameter.getParams();
Map<String, String> property = httpParameter.getProperty();
int connectTimeout = httpParameter.getConnectTimeout();
int readTimeout = httpParameter.getReadTimeout();
HttpURLConnection httpConn = null;
OutputStream out = null;
try {
String contentType = "multipart/form-data; boundary=" + BOUNDARY;
property.put(KEY_CONTENT_TYPE, contentType);
httpConn = openHttpConn(new URL(url), connectTimeout, readTimeout, METHOD_POST, property);
out = new DataOutputStream(httpConn.getOutputStream());
appendContent(params, out);
appendFile(fileMap, out);
byte[] endData = ("\r\n--" + BOUNDARY + "--\r\n").getBytes();
out.write(endData);
out.flush();
return getResponseAsString(httpConn);
} finally {
close(out);
close(httpConn);
}
}
/**
* 发送http请求，返回响应的结果
* @param httpParameter 请求地址
* @return
* @throws IOException
*/
public static HttpURLConnection getHttpConn(HttpParameter httpParameter) throws IOException {
String charset = httpParameter.getCharset();
if (StringUtil.isEmpty(charset)) {
charset = DEFAULT_CHARSET;
}
String url = httpParameter.getUrl();
Map<String, String> params = httpParameter.getParams();
params = buildParams(url, params);
String content = getParamsContext(params, charset);
String method = httpParameter.getMethod();
if (METHOD_POST.equalsIgnoreCase(method)) {
url = tranferUrl(url);
}
Map<String, String> property = httpParameter.getProperty();
// 设置请求的 HTTP内容类型
String contentType = "application/x-www-form-urlencoded;charset=" + charset;
httpParameter.putDefaultProperty(KEY_CONTENT_TYPE, contentType);
httpParameter.putDefaultProperty(KEY_ACCEPT, "*/*");
httpParameter.putDefaultProperty(KEY_CHARSERT, charset);
httpParameter.putDefaultProperty(KEY_USER_AGENT, "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)");
// httpParameter.putDefaultProperty(KEY_ACCEPT_ENCODING, "gzip, deflate");
httpParameter.putDefaultProperty(KEY_ACCEPT_LANGUAGE, "zh-cn");
httpParameter.putDefaultProperty(KEY_CONNECTION, "Keep-Alive");
httpParameter.putDefaultProperty(KEY_CACHE_CONTROL, "no-cache");
int connectTimeout = httpParameter.getConnectTimeout();
int readTimeout = httpParameter.getReadTimeout();
HttpURLConnection httpConn = null;
OutputStream out = null;
try {
httpConn = openHttpConn(new URL(url), connectTimeout, readTimeout, method, property);
if (!isEmpty(content)) {
out = httpConn.getOutputStream();
out.write(content.getBytes(charset));
}
return httpConn;
} finally {
close(out);
}
}
/**
* 获取一个HttpURLConnection连接，并设置相应的参数
* @param url 请求地址 url地址
* @param connectTimeout 连接超时时间
* @param readTimeout 读取超时时间
* @param method 请求的方法，可以是POST,GET
* @param property HttpURLConnection属性配置,对象不允许为空
* @return
* @throws IOException
*/
private static HttpURLConnection openHttpConn(URL url, int connectTimeout, int readTimeout, String method,
Map<String, String> property) throws IOException {
HttpURLConnection httpConn;
if (url.toString().toLowerCase().startsWith("https")) {
try {
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm = { new X509TrustManagerNone() };
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tm, null);
SSLSocketFactory ssf = sslContext.getSocketFactory();
httpConn = (HttpsURLConnection) url.openConnection();
((HttpsURLConnection) httpConn).setSSLSocketFactory(ssf);
((HttpsURLConnection) httpConn).setHostnameVerifier(new AllowAllHostnameVerifier());
} catch(Exception e) {
throw new IOException(e);
}
} else {
httpConn = (HttpURLConnection) url.openConnection();
}
if (StringUtil.isEmpty(method)) {
method = METHOD_POST;
}
// 设定请求的方法，默认是GET
httpConn.setRequestMethod(method);
if ("POST".equalsIgnoreCase(method)) {
// 设置是否向httpUrlConnection输出，因为这个是post请求，参数要放在
// http正文内，因此需要设为true, 默认情况下是false;
httpConn.setDoOutput(true);
// 设置是否从httpUrlConnection读入，默认情况下是true;
httpConn.setDoInput(true);
// Post 请求不能使用缓存
httpConn.setUseCaches(false);
}
if (connectTimeout != -1) {
// 设置连接超时时间
httpConn.setConnectTimeout(connectTimeout > 0 ? connectTimeout : CONNECT_TIMEOUT);
}
if (readTimeout != -1) {
// 设置读取超时时间
httpConn.setReadTimeout(readTimeout > 0 ? readTimeout : READ_TIMEOUT);
}
for (Entry<String, String> entry : property.entrySet()) {
httpConn.setRequestProperty(entry.getKey(), entry.getValue());
}
return httpConn;
}
/**
* 添加表单内容
* @param textMap
* @param out
* @throws IOException
*/
private static void appendContent(Map<String, String> textMap, OutputStream out) throws IOException {
if (textMap == null) {
return;
}
StringBuffer contentBuffer = new StringBuffer();
for (Entry<String, String> entry : textMap.entrySet()) {
String inputName = entry.getKey();
String inputValue = entry.getValue();
if (inputValue == null) {
continue;
}
contentBuffer.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
contentBuffer.append("Content-Disposition: form-data; name=\"" + inputName + "\"\r\n\r\n");
contentBuffer.append(inputValue);
}
out.write(contentBuffer.toString().getBytes());
}
/**
* 添加表单文件
* @param fileMap
* @param out
* @throws IOException
*/
private static void appendFile(Map<String, File> fileMap, OutputStream out) throws IOException {
if (fileMap == null) {
return;
}
for (Entry<String, File> entry : fileMap.entrySet()) {
String inputName = entry.getKey();
File file = entry.getValue();
if (file == null) {
continue;
}
upFile(inputName, file, out);
}
}
private static void upFile(String inputName, File file, OutputStream out) throws IOException {
if (file.isDirectory()) {
File[] listFiles = file.listFiles();
if (listFiles != null) {
for (int i = 0; i < listFiles.length; i++) {
upFile(inputName + "_" + i, listFiles[i], out);
}
}
} else {
String filename = file.getName();
String contentType = new MimetypesFileTypeMap().getContentType(file);
if (contentType == null || contentType.equals("")) {
contentType = "application/octet-stream";
}
StringBuffer strBuf = new StringBuffer();
strBuf.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
strBuf.append("Content-Disposition: form-data;name=\"" + inputName + "\"; filename=\"" + filename + "\"\r\n");
strBuf.append("Content-Type:" + contentType + "\r\n\r\n");
out.write(strBuf.toString().getBytes());
int length = 0;
byte[] buffer = new byte[1024];
DataInputStream in = null;
try {
in = new DataInputStream(new FileInputStream(file));
while ((length = in.read(buffer)) != -1) {
out.write(buffer, 0, length);
}
} finally {
close(in);
}
}
}
/**
* 判断http请求返回状态是否正确
* @param responseCode
* @return
*/
private static boolean isSuccess(int responseCode) {
return (responseCode >= 200 && responseCode < 300);// || responseCode == 404;
}
/**
* 过滤掉Post请求url中的参数
* @param url 请求地址
* @return
* @throws MalformedURLException
* @throws UnsupportedEncodingException
*/
private static String tranferUrl(String url) throws MalformedURLException, UnsupportedEncodingException {
if (url != null) {
URL _url = new URL(url);
String path = _url.getPath();
String DOT_RE = "/\\./";
String DOUBLE_DOT_RE = "/[^/]+/\\.\\./";
path = path.replaceAll(DOT_RE, "/");
Pattern p = Pattern.compile(DOUBLE_DOT_RE);
Matcher m = p.matcher(path);
while (m.find()) {
String a = path.substring(m.start(), m.end());
path = path.replaceFirst(a, "/");
m = p.matcher(path);
}
path = path.replaceAll("/\\.\\./", "/");
url = _url.getProtocol() + "://" + _url.getHost() + (_url.getPort() > 0 ? ":" + _url.getPort() : "") + path;
}
// 加入对url中包括非URI格式的处理
if (url != null && url.indexOf("&") > -1) {
int idx = -1;
String prefiex = null;
StringBuilder sb = new StringBuilder();
while ((idx = url.indexOf("&")) > -1) {
if (prefiex == null) {
prefiex = url.substring(0, idx);
}
url = url.substring(idx + 1, url.length());
int split = url.indexOf("=");
String key = url.substring(0, split);
int last = url.indexOf("&");
String value;
if (last > -1) {
value = url.substring(split + 1, last);
} else {
value = url.substring(split + 1, url.length());
}
value = URLEncoder.encode(value, "UTF-8");
sb.append("&" + key + "=" + value);
}
url = prefiex + sb.toString();
}
int mark = url.indexOf("?");
// 已经包含参数
if (mark > -1) {
url = url.substring(0, mark);
}
return url;
}
private static Map<String, String> buildParams(String url, Map<String, String> params) {
int mark = url.indexOf("?");
// 已经包含参数
if (mark > -1) {
String _params = url.substring(mark + 1, url.length());
url = url.substring(0, mark);
String[] paramArray = _params.split("&");
if (params == null) {
params = new HashMap<String, String>();
}
for (int i = 0; i < paramArray.length; i++) {
String string = paramArray[i];
int index = string.indexOf("=");
if (index > 0) {
String key = string.substring(0, index);
String value = string.substring(index + 1, string.length());
params.put(key, value);
}
}
}
return params;
}
private static String getParamsContext(Map<String, String> params, String charset)
throws UnsupportedEncodingException {
if ((params == null) || (params.isEmpty())) {
return null;
}
StringBuilder query = new StringBuilder();
Set<Entry<String, String>> entries = params.entrySet();
boolean hasParam = false;
for (Map.Entry<String, String> entry : entries) {
String name = entry.getKey();
String value = entry.getValue();
if (hasParam) {
query.append("&");
} else {
hasParam = true;
}
if (!isEmpty(name) && !isEmpty(value)) {
query.append(name).append("=").append(URLEncoder.encode(value, charset));
} else if (!isEmpty(name)) {
query.append(name).append("=");
}
}
return query.toString();
}
/**
* 获取Http请求返回的内容
* @param httpConn
* @return
* @throws IOException
*/
private static HttpResult getResponseAsString(HttpURLConnection httpConn) throws IOException {
String charset = getResponseCharset(httpConn.getContentType());
InputStream errorStream = httpConn.getErrorStream();
HttpResult httpResult = new HttpResult();
httpResult.setResponseCode(httpConn.getResponseCode());
if (errorStream == null) {
httpResult.setSuccess(true);
httpResult.setMessage(getStreamAsString(httpConn.getInputStream(), charset));
} else {
httpResult.setSuccess(false);
httpResult.setMessage(getStreamAsString(errorStream, charset));
}
return httpResult;
}
/**
* 获取Http请求返回的内容
* @param httpConn
* @return
* @throws IOException
*/
private static File getResponseAsFile(HttpURLConnection httpConn, File file) throws IOException {
String charset = getResponseCharset(httpConn.getContentType());
InputStream errorStream = httpConn.getErrorStream();
if (errorStream != null) {
String streamAsString = getStreamAsString(errorStream, charset);
throw new RuntimeException(streamAsString);
}
writeFileByInputStream(file, httpConn.getInputStream());
return file;
}
/**
* 保存数据流到指定的文件
* @param file 输出文件
* @param inputStream 输入流
* @throws IOException
*/
private static void writeFileByInputStream(File file, InputStream inputStream) throws IOException {
OutputStream out = null;
if (!file.getParentFile().exists()) { // 如果目录不存在则创建目录
file.getParentFile().mkdirs();
}
try {
out = new FileOutputStream(file);
byte[] buffer = new byte[BUFFER_SIZE];
int read;
while ((read = inputStream.read(buffer)) != -1) {
out.write(buffer, 0, read);
out.flush();
}
} finally {
close(inputStream);
close(out);
}
}
/**
* 读取输入流的内容，转换成字符串返回
* @param stream
* @param charset
* @return
* @throws IOException
*/
private static String getStreamAsString(InputStream stream, String charset) throws IOException {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(stream, charset));
StringWriter writer = new StringWriter();
char[] buffer = new char[BUFFER_SIZE];
int length = 0;
while ((length = reader.read(buffer)) > 0) {
writer.write(buffer, 0, length);
}
return writer.toString();
} finally {
close(stream);
}
}
/**
* 获取请求响应的字符编码
* @param contentType 内容类型
* @return
*/
private static String getResponseCharset(String contentType) {
String charset = DEFAULT_CHARSET;
if (!isEmpty(contentType)) {
String[] params = contentType.split(";");
for (String param : params) {
param = param.trim();
if (param.startsWith("charset")) {
String[] pair = param.split("=", 2);
if ((pair.length != 2) || (isEmpty(pair[1])))
break;
charset = pair[1].trim();
break;
}
}
}
return charset;
}
/**
* 判断字符串是否为空
* @param msg
* @return
*/
private static boolean isEmpty(String msg) {
return msg == null || msg.trim().length() == 0;
}
/**
* 关闭资源
* @param object 要关闭的对象
*/
public static void close(Closeable object) {
try {
if (object != null) {
object.close();
}
} catch (Exception e) {
logger.warn(e.getMessage(), e);
}
}
/**
* 关闭资源
* @param conn 要关闭的对象
*/
public static void close(HttpURLConnection conn) {
try {
if (conn != null) {
close(conn.getInputStream());
close(conn.getErrorStream());
conn.disconnect();
}
} catch (Exception e) {
logger.warn(e.getMessage(), e);
}
}
/**
* HTTP请求响应结果
* @author huangsq
* @version 1.0, 2016-01-12
* @since 1.0, 2016-01-12
*/
public static class HttpResult implements Serializable {
private static final long serialVersionUID = 1L;
private boolean success;
private String message;
private int responseCode;
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getResponseCode() {
return responseCode;
}
public void setResponseCode(int responseCode) {
this.responseCode = responseCode;
}
}
/**
* HTTP请求参数
*/
public static class HttpParameter implements Serializable {
private static final long serialVersionUID = 1L;
private String url;
private int connectTimeout;
private int readTimeout;
private String method;
private Map<String, String> params;
private String charset;
private Map<String, String> property;
public HttpParameter(String url) {
this(url, CONNECT_TIMEOUT, READ_TIMEOUT, METHOD_POST, null, DEFAULT_CHARSET, new HashMap<String, String>());
}
public HttpParameter(String url, int connectTimeout, int readTimeout) {
this(url, connectTimeout, readTimeout, METHOD_POST, null, DEFAULT_CHARSET, new HashMap<String, String>());
}
public HttpParameter(String url, int connectTimeout, int readTimeout, String method) {
this(url, connectTimeout, readTimeout, method, null, DEFAULT_CHARSET, new HashMap<String, String>());
}
public HttpParameter(String url, int connectTimeout, int readTimeout, String method, Map<String, String> params) {
this(url, connectTimeout, readTimeout, method, params, DEFAULT_CHARSET, new HashMap<String, String>());
}
public HttpParameter(String url, int connectTimeout, int readTimeout, String method, Map<String, String> params,
String charset) {
this(url, connectTimeout, readTimeout, method, params, charset, new HashMap<String, String>());
}
public HttpParameter(String url, int connectTimeout, int readTimeout, String method, Map<String, String> params,
String charset, Map<String, String> property) {
super();
this.url = url;
this.connectTimeout = connectTimeout;
this.readTimeout = readTimeout;
this.method = method;
this.params = params;
this.charset = charset;
this.property = property;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public int getConnectTimeout() {
return connectTimeout;
}
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
public int getReadTimeout() {
return readTimeout;
}
public void setReadTimeout(int readTimeout) {
this.readTimeout = readTimeout;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public Map<String, String> getParams() {
return params;
}
public void setParams(Map<String, String> params) {
this.params = params;
}
public String getCharset() {
return charset;
}
public void setCharset(String charset) {
this.charset = charset;
}
public Map<String, String> getProperty() {
if (property == null) {
property = new HashMap<String, String>();
}
return property;
}
public void setProperty(Map<String, String> property) {
this.property = property;
}
public void putDefaultProperty(String key, String value) {
Map<String, String> property = getProperty();
String result = property.get(key);
if (result == null) {
property.put(key, value);
}
}
}
public static class X509TrustManagerNone implements X509TrustManager {
X509TrustManager sunJSSEX509TrustManager;
public X509TrustManagerNone() throws Exception {
}
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
}
public static class AllowAllHostnameVerifier implements HostnameVerifier {
public boolean verify(String host, SSLSession session) {
try {
Certificate[] certs = session.getPeerCertificates();
return ((certs != null) && (certs[0] instanceof X509Certificate));
} catch (SSLException e) {
}
return false;
}
}
}
扫一扫
06-26
1340
1340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
