package org.yeshi.utils;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.net.MalformedURLException;
|
import java.net.URL;
|
import java.net.URLEncoder;
|
import java.security.KeyStore;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
import javax.net.ssl.SSLContext;
|
|
import org.apache.commons.httpclient.Header;
|
import org.apache.commons.httpclient.HttpClient;
|
import org.apache.commons.httpclient.HttpException;
|
import org.apache.commons.httpclient.HttpStatus;
|
import org.apache.commons.httpclient.NameValuePair;
|
import org.apache.commons.httpclient.methods.GetMethod;
|
import org.apache.commons.httpclient.methods.PostMethod;
|
import org.apache.commons.httpclient.methods.multipart.FilePart;
|
import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
|
import org.apache.commons.httpclient.methods.multipart.Part;
|
import org.apache.commons.httpclient.methods.multipart.StringPart;
|
import org.apache.commons.io.FileUtils;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.HttpHost;
|
import org.apache.http.auth.AuthScope;
|
import org.apache.http.auth.UsernamePasswordCredentials;
|
import org.apache.http.client.CredentialsProvider;
|
import org.apache.http.client.config.RequestConfig;
|
import org.apache.http.client.methods.CloseableHttpResponse;
|
import org.apache.http.client.methods.HttpPost;
|
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
|
import org.apache.http.conn.ssl.SSLContexts;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.BasicCredentialsProvider;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.util.EntityUtils;
|
import org.yeshi.utils.entity.ProxyIP;
|
|
import net.sf.json.JSONObject;
|
|
public class HttpUtil {
|
|
public static List<String> getUrlListFromText(String text) {
|
List<String> urlList = new ArrayList<String>();
|
// 链接
|
String URL_REGEX = "(((http|https)://)|(www\\.))[a-zA-Z0-9\\._-]+\\.[a-zA-Z]{2,6}(:[0-9]{1,4})?(/[a-zA-Z0-9\\&%_\\./-~-]*)?";
|
Pattern p = Pattern.compile(URL_REGEX);
|
Matcher matcher = p.matcher(text);
|
while (matcher.find()) {
|
String url = matcher.group();
|
if (!StringUtil.isNullOrEmpty(url)) {
|
urlList.add(url);
|
}
|
}
|
return urlList;
|
}
|
|
/**
|
* 获取链接中的参数
|
*
|
* @param url
|
* @return
|
*/
|
public static Map<String, String> getPramsFromUrl(String url) {
|
Map<String, String> params = new HashMap<>();
|
if (url != null && url.indexOf("?") > -1) {
|
String paramStr = url.split("\\?")[1];
|
String[] sts = paramStr.split("&");
|
for (String st : sts) {
|
if (st.indexOf("=") > -1) {
|
params.put(st.split("=")[0], st.split("=")[1]);
|
}
|
}
|
}
|
return params;
|
}
|
|
public static String getHost(String host) {
|
try {
|
URL url = new URL(host);
|
return url.getHost();
|
} catch (MalformedURLException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String getShortLink(String url) {
|
// return url;
|
String shortLink = getShortLink3(url);
|
if (StringUtil.isNullOrEmpty(shortLink))
|
shortLink = getShortLink1(url);
|
if (StringUtil.isNullOrEmpty(shortLink))
|
shortLink = getShortLink2(url);
|
return shortLink;
|
}
|
|
private static String getShortLink1(String url) {
|
try {
|
String totalUrl = String.format(
|
"http://suo.im/api.htm?format=json&url=%s&key=5d7728078e676d45275f816b@681bb0446f1e6af4f8fc6ce3cad2a684",
|
URLEncoder.encode(url));
|
String result = get(totalUrl, null);
|
System.out.println(result);
|
try {
|
JSONObject json = JSONObject.fromObject(result);
|
return json.optString("url");
|
} catch (Exception e) {
|
}
|
} catch (Exception e) {
|
}
|
return null;
|
}
|
|
// 搜狐网址
|
private static String getShortLink2(String url) {
|
try {
|
String totalUrl = String.format("https://sohu.gg/api/?key=2zumZxsL8MuX&url=%s",
|
URLEncoder.encode(url, "UTF-8"));
|
String result = get(totalUrl, null);
|
if (result != null && result.startsWith("http"))
|
return result;
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
private static String getShortLink3(String url) {
|
// try {
|
// String totalUrl = String.format("http://h5.flq001.com/short/createShort?url=%s",
|
// URLEncoder.encode(url, "UTF-8"));
|
// String result = get(totalUrl, null);
|
// JSONObject data = JSONObject.fromObject(result);
|
// return data.optString("short_url");
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// }
|
return null;
|
}
|
|
public static String get(String url) {
|
return get(url, null);
|
}
|
|
/**
|
* get请求
|
*
|
* @param url
|
* @param timeoutMS-请求超时时间
|
* @return
|
*/
|
public static String get(String url, int timeoutMS) {
|
HttpClient client = new HttpClient();
|
client.getHttpConnectionManager().getParams().setConnectionTimeout(timeoutMS);
|
try {
|
GetMethod method = new GetMethod(url);
|
client.executeMethod(method);
|
return method.getResponseBodyAsString();
|
} catch (Exception e) {
|
|
}
|
return null;
|
}
|
|
public static String get(String url, Map<String, String> headers) {
|
HttpClient client = new HttpClient();
|
try {
|
GetMethod method = new GetMethod(url);
|
if (headers != null) {
|
Iterator<String> keys = headers.keySet().iterator();
|
while (keys.hasNext()) {
|
String key = keys.next();
|
method.addRequestHeader(key, headers.get(key));
|
}
|
}
|
client.executeMethod(method);
|
return method.getResponseBodyAsString();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String get(String url, Map<String, String> headers, ProxyIP ipInfo) {
|
HttpClient client = new HttpClient();
|
if (ipInfo != null)
|
client.getHostConfiguration().setProxy(ipInfo.getIp(), ipInfo.getPort());
|
client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
|
try {
|
GetMethod method = new GetMethod(url);
|
if (headers != null) {
|
Iterator<String> keys = headers.keySet().iterator();
|
while (keys.hasNext()) {
|
String key = keys.next();
|
method.addRequestHeader(key, headers.get(key));
|
}
|
}
|
client.executeMethod(method);
|
return method.getResponseBodyAsString();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String get(String url, Map<String, String> headers, ProxyIP ipInfo, String userName,
|
String proxyPwd) {
|
CloseableHttpClient httpclient = null;
|
if (!StringUtil.isNullOrEmpty(userName)) {
|
CredentialsProvider credsProvider = new BasicCredentialsProvider();
|
credsProvider.setCredentials(new AuthScope(ipInfo.getIp(), ipInfo.getPort()),
|
new UsernamePasswordCredentials(userName, proxyPwd));
|
httpclient = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
|
} else
|
HttpClients.createDefault();
|
HttpHost proxy = null;
|
if (ipInfo.getPort() != 0 && ipInfo.getPort() != 80) {
|
proxy = new HttpHost(ipInfo.getIp(), ipInfo.getPort());
|
} else
|
proxy = new HttpHost(ipInfo.getIp());
|
RequestConfig config = RequestConfig.custom().setProxy(proxy).build();
|
HttpPost post = new HttpPost(url);
|
try {
|
post.setConfig(config);
|
CloseableHttpResponse response = httpclient.execute(post);
|
return EntityUtils.toString(response.getEntity());
|
} catch (Exception e) {
|
return null;
|
}
|
|
}
|
|
public static String getAsString(String url, String fromCharset, String toCharset) {
|
HttpClient client = new HttpClient();
|
GetMethod method = new GetMethod(url);
|
try {
|
client.executeMethod(method);
|
String response = method.getResponseBodyAsString();
|
String s1 = new String(response.getBytes(fromCharset), toCharset);
|
return s1;
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String get(String url, Map<String, String> params, Map<String, String> headers) {
|
HttpClient client = new HttpClient();
|
try {
|
Iterator<String> keys = params.keySet().iterator();
|
url += "?";
|
while (keys.hasNext()) {
|
String key = keys.next();
|
url += String.format("%s=%s&", key, URLEncoder.encode(params.get(key), "UTF-8"));
|
}
|
GetMethod method = new GetMethod(url);
|
if (headers != null) {
|
keys = headers.keySet().iterator();
|
while (keys.hasNext()) {
|
String key = keys.next();
|
headers.get(key);
|
method.setRequestHeader(key, headers.get(key));
|
}
|
}
|
client.executeMethod(method);
|
System.out.println(method.getResponseHeader("cookies"));
|
String result = method.getResponseBodyAsString();
|
return result;
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static InputStream getAsInputStream(String url) {
|
HttpClient client = new HttpClient();
|
GetMethod method = new GetMethod(url);
|
try {
|
client.executeMethod(method);
|
return method.getResponseBodyAsStream();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
/**
|
* 下载图片文件
|
*
|
* @param url
|
* @return
|
*/
|
public static InputStream downLoadImg(String url) throws org.yeshi.utils.exception.HttpException {
|
HttpClient client = new HttpClient();
|
GetMethod method = new GetMethod(url);
|
try {
|
client.executeMethod(method);
|
Header contentTypeHeader = method.getResponseHeader("Content-Type");
|
if (contentTypeHeader == null || contentTypeHeader.getValue().contains("text"))
|
throw new org.yeshi.utils.exception.HttpException(2, "图片下载出错");
|
return method.getResponseBodyAsStream();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static InputStream getAsInputStream(String url, Map<String, String> headers) {
|
HttpClient client = new HttpClient();
|
GetMethod method = new GetMethod(url);
|
Iterator<String> keys = headers.keySet().iterator();
|
while (keys.hasNext()) {
|
String key = keys.next();
|
method.setRequestHeader(key, headers.get(key));
|
}
|
|
try {
|
client.executeMethod(method);
|
return method.getResponseBodyAsStream();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static InputStream getImage(String url) {
|
HttpClient client = new HttpClient();
|
GetMethod method = new GetMethod(url);
|
try {
|
method.setRequestHeader("Content-Type", "image/jpeg");
|
client.executeMethod(method);
|
return method.getResponseBodyAsStream();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static String postSimple(String url) {
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
try {
|
client.executeMethod(method);
|
return method.getResponseBodyAsString();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String post(String url) {
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
method.addRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
try {
|
client.executeMethod(method);
|
return convertInputStreamToString(method.getResponseBodyAsStream());
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String post(String url, Map<String, String> map) {
|
Iterator<String> its = map.keySet().iterator();
|
NameValuePair[] params = new NameValuePair[map.keySet().size()];
|
int p = 0;
|
while (its.hasNext()) {
|
String key = its.next();
|
NameValuePair np = new NameValuePair(key, map.get(key));
|
params[p] = np;
|
p++;
|
}
|
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
method.addRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestBody(params);
|
try {
|
client.executeMethod(method);
|
return convertInputStreamToString(method.getResponseBodyAsStream());
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String post(String url, Map<String, String> map, Map<String, String> headers, ProxyIP ipInfo) {
|
HttpClient client = new HttpClient();
|
if (ipInfo != null)
|
client.getHostConfiguration().setProxy(ipInfo.getIp(), ipInfo.getPort());
|
PostMethod pm = new PostMethod(url);// 创建HttpPost对象
|
NameValuePair[] ns = new NameValuePair[map.keySet().size()];
|
Iterator<String> its = map.keySet().iterator();
|
int index = 0;
|
while (its.hasNext()) {
|
String key = its.next();
|
ns[index++] = (new NameValuePair(key, map.get(key)));
|
}
|
|
if (headers != null) {
|
its = headers.keySet().iterator();
|
while (its.hasNext()) {
|
String key = its.next();
|
pm.setRequestHeader(key, headers.get(key));
|
}
|
}
|
|
try {
|
pm.setRequestBody(ns);
|
client.executeMethod(pm);
|
return pm.getResponseBodyAsString();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String post(String url, Map<String, String> map, Map<String, String> headers) {
|
HttpClient client = new HttpClient();
|
// client.getHostConfiguration().setProxy("192.168.3.122", 8888);
|
PostMethod pm = new PostMethod(url);// 创建HttpPost对象
|
NameValuePair[] ns = new NameValuePair[map.keySet().size()];
|
Iterator<String> its = map.keySet().iterator();
|
int index = 0;
|
while (its.hasNext()) {
|
String key = its.next();
|
ns[index++] = (new NameValuePair(key, map.get(key)));
|
}
|
|
if (headers != null) {
|
its = headers.keySet().iterator();
|
while (its.hasNext()) {
|
String key = its.next();
|
pm.setRequestHeader(key, headers.get(key));
|
}
|
}
|
|
try {
|
pm.setRequestBody(ns);
|
client.executeMethod(pm);
|
return pm.getResponseBodyAsString();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
private static String convertInputStreamToString(InputStream inputStream) {
|
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
|
StringBuffer stringBuffer = new StringBuffer();
|
String str = "";
|
try {
|
while ((str = br.readLine()) != null) {
|
stringBuffer.append(str);
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return stringBuffer.toString();
|
}
|
|
@SuppressWarnings("deprecation")
|
public static String post(String url, String entity) {
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
method.addRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestBody(entity);
|
try {
|
client.executeMethod(method);
|
return convertInputStreamToString(method.getResponseBodyAsStream());
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
@SuppressWarnings("deprecation")
|
public static String post(String url, String entity, String charset) {
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
method.addRequestHeader("Content-Type", "text/html;charset=" + charset);
|
method.setRequestHeader("Content-Type", "text/html;charset=" + charset);
|
method.setRequestBody(entity);
|
try {
|
client.executeMethod(method);
|
return convertInputStreamToString(method.getResponseBodyAsStream());
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static String postInputStream(String url, File file) throws FileNotFoundException {
|
HttpClient client = new HttpClient();
|
PostMethod postMethod = new PostMethod(url);
|
Part[] parts = {new StringPart("filename", file.getName()), new StringPart("filelength", file.length() + ""),
|
new StringPart("content-type", "image/jpg"), new FilePart("file", file)};
|
postMethod.setRequestEntity(new MultipartRequestEntity(parts, postMethod.getParams()));
|
|
try {
|
client.executeMethod(postMethod);
|
return convertInputStreamToString(postMethod.getResponseBodyAsStream());
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
public static File downloadFile(String url, String targetPath) {
|
try {
|
URL httpurl = new URL(url);
|
FileUtils.copyURLToFile(httpurl, new File(targetPath));
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
File f = new File(targetPath);
|
if (!f.exists() || f.length() <= 0)
|
return null;
|
return f;
|
}
|
|
@SuppressWarnings("deprecation")
|
public static InputStream postForInputstream(String url, String entity) {
|
HttpClient client = new HttpClient();
|
|
PostMethod method = new PostMethod(url);
|
method.addRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestHeader("Content-Type", "text/html;charset=UTF-8");
|
method.setRequestBody(entity);
|
try {
|
client.executeMethod(method);
|
return method.getResponseBodyAsStream();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static String post(String url, String fileKey, File f) {
|
PostMethod filePost = new PostMethod(url);
|
HttpClient client = new HttpClient();
|
try {
|
Part[] parts = {new FilePart(fileKey, f)};
|
filePost.setRequestEntity(new MultipartRequestEntity(parts, filePost.getParams()));
|
client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
|
int status = client.executeMethod(filePost);
|
if (status == HttpStatus.SC_OK) {
|
return filePost.getResponseBodyAsString();
|
} else {
|
System.out.println("上传失败");
|
}
|
} catch (Exception ex) {
|
ex.printStackTrace();
|
} finally {
|
filePost.releaseConnection();
|
}
|
return null;
|
}
|
|
@SuppressWarnings("deprecation")
|
public static String httpsPost(String url, String body, String pwd, InputStream cert) throws Exception {
|
String result = "";
|
KeyStore keyStore = KeyStore.getInstance("PKCS12");
|
InputStream instream = cert;
|
try {
|
keyStore.load(instream, pwd.toCharArray());
|
} finally {
|
instream.close();
|
}
|
|
// Trust own CA and all self-signed certs
|
SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, pwd.toCharArray()).build();
|
// Allow TLSv1 protocol only
|
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[]{"TLSv1"}, null,
|
SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
|
CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
|
try {
|
HttpPost httppost = new HttpPost(url);
|
httppost.setHeader("Content-Type", "text/html;charset=UTF-8");
|
System.out.println("executing request" + httppost.getRequestLine());
|
httppost.setEntity(new StringEntity(body, "UTF-8"));
|
CloseableHttpResponse response = httpclient.execute(httppost);
|
try {
|
HttpEntity entity = response.getEntity();
|
if (entity != null) {
|
result = convertInputStreamToString(entity.getContent());
|
}
|
EntityUtils.consume(entity);
|
} finally {
|
response.close();
|
}
|
} finally {
|
httpclient.close();
|
}
|
|
return result;
|
}
|
|
/**
|
* 获取post返回location
|
*
|
* @param url
|
* @return
|
*/
|
public static String getLocation(String url) {
|
HttpClient client = new HttpClient();
|
PostMethod method = new PostMethod(url);
|
try {
|
client.executeMethod(method);
|
return method.getResponseHeader("location").getValue();
|
} catch (HttpException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
}
|
