代码示例
使用HttpURLConnection实现：
package com.util.httpclient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
/**
* Webapi URL 请求
* @author zhanglang
* 2019-05-23
*/
public class TzWebapiCall {
private static final Logger logger = LoggerFactory.getLogger(TzWebapiCall.class);
//实现一个X509TrustManager接口，用于绕过验证，不用修改里面的方法
private static TrustManager myX509TrustManager = new X509TrustManager() {
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
@Override
public void checkServerTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
@Override
public void checkClientTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
};
//默认字符集为UTF-8
private String charset = "UTF-8";
//默认POST请求
private String httpMethod = "POST";
//错误信息
private String errorMsg = "";
//请求返回
private String webapiResult = "";
//记录WebAPI请求成功
private boolean isRequestSuccess = true;
//是否需要记录文件日志
private boolean needWriteFileLog = true;
public TzWebapiCall() {
}
public TzWebapiCall(String strHttpMethod) {
this.httpMethod = strHttpMethod;
}
public TzWebapiCall(String strHttpMethod, String strCharset) {
this.httpMethod = strHttpMethod;
this.charset = strCharset;
}
public void setCharset(String charset) {
this.charset = charset;
}
public void setHttpMethod(String httpMethod) {
this.httpMethod = httpMethod;
}
public void setNeedWriteFileLog(boolean needWriteFileLog) {
this.needWriteFileLog = needWriteFileLog;
}
//获取错误信息
public String getErrorMsg() {
return errorMsg;
}
//获取webapi返回结果
public String getWebapiResult() {
return webapiResult;
}
//获取请求结果
public boolean isRequestSuccess() {
return isRequestSuccess;
}
//构建表单数据
private String buildFormData(Map<String, String> keyValues)
throws Exception {
StringBuffer params = new StringBuffer();
if (keyValues != null) {
for (String tmpkey : keyValues.keySet()) {
if (params.length() <= 0) {
params.append(tmpkey).append("=")
.append(URLEncoder.encode(keyValues.get(tmpkey),
"UTF-8"));
} else {
params.append("&").append(tmpkey).append("=")
.append(URLEncoder.encode(keyValues.get(tmpkey),
"UTF-8"));
}
}
}
return params.toString();
}
//获取Webapi的URL 连接对象
private HttpURLConnection openUrl(String apiUrl) {
HttpURLConnection httpConn = null;
try {
//检查是否走https协议
boolean httpsConnection = apiUrl.toLowerCase().startsWith("https://");
//设置SSLContext
SSLContext sslcontext = null;
if (httpsConnection == true) {
sslcontext = SSLContext.getInstance("TLS");
sslcontext.init(null,
new TrustManager[] { myX509TrustManager }, null);
}
//打开连接
URL requestUrl = new URL(apiUrl);
HttpsURLConnection httpsConn = null;
if (httpsConnection == true) {
httpsConn = (HttpsURLConnection) requestUrl.openConnection();
} else {
httpConn = (HttpURLConnection) requestUrl.openConnection();
}
//设置套接工厂
if (httpsConnection == true) {
httpsConn.setSSLSocketFactory(sslcontext.getSocketFactory());
httpConn = httpsConn;
}
//设置接受的字符集
httpConn.addRequestProperty("Accept-Charset", charset + ";");
//设置HTTP请求方法
httpConn.setRequestMethod(httpMethod);
//设置header
httpConn.setRequestProperty("Connection", "keep-alive");
httpConn.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.9,zh-TW;q=0.8");
httpConn.setRequestProperty("Prefer", "return=representation");
return httpConn;
} catch (Exception e) {
e.printStackTrace();
httpConn = null;
}
return httpConn;
}
//从指定HTTP连接对象获取服务器响应内容
private String getResponseContent(HttpURLConnection httpConn)
throws Exception {
String responseText = "";
// 从指定对象httpConn中获取服务器响应内容
try {
// 根据指定的URL地址发起连接请求
httpConn.connect();
// 检查服务器返回的代码
int code = httpConn.getResponseCode();
if (needWriteFileLog) {
logger.info("返回码： " + code);
}
// 检查是否返回500错误
if (HttpsURLConnection.HTTP_INTERNAL_ERROR == code) {
//设置请求失败
isRequestSuccess = false;
// 获取输入流
BufferedReader in = new BufferedReader(new InputStreamReader(
httpConn.getErrorStream(), Charset.forName("UTF-8")));
String temp = in.readLine();
StringBuilder sb = new StringBuilder();
// 连接成一个字符串
while (temp != null) {
sb.append(temp);
temp = in.readLine();
}
// 关闭流
in.close();
// 取出最终获取的响应内容
responseText = sb.toString();
throw new Exception(
"The server returns an error code: 500, and please check if the parameter format is correct." +
responseText);
}
if ((HttpsURLConnection.HTTP_OK == code) ||
(HttpsURLConnection.HTTP_CREATED == code)) {
// 获取输入流
BufferedReader in = new BufferedReader(new InputStreamReader(
httpConn.getInputStream(), Charset.forName("UTF-8")));
String temp = in.readLine();
StringBuilder sb = new StringBuilder();
// 连接成一个字符串
while (temp != null) {
sb.append(temp);
temp = in.readLine();
}
// 关闭流
in.close();
// 取出最终获取的响应内容
responseText = sb.toString();
}
if (HttpsURLConnection.HTTP_BAD_REQUEST == code) {
//设置请求失败
isRequestSuccess = false;
// 获取输入流
BufferedReader in = new BufferedReader(new InputStreamReader(
httpConn.getErrorStream(), Charset.forName("UTF-8")));
String temp = in.readLine();
StringBuilder sb = new StringBuilder();
// 连接成一个字符串
while (temp != null) {
sb.append(temp);
temp = in.readLine();
}
// 关闭流
in.close();
// 取出最终获取的响应内容
responseText = sb.toString();
} else if (HttpsURLConnection.HTTP_NO_CONTENT == code) {
//无返回内容
responseText = "";
}
//其他的请求错误、服务器错误
if (code > 400) {
//设置请求失败
isRequestSuccess = false;
// 获取输入流
BufferedReader in = new BufferedReader(new InputStreamReader(
httpConn.getErrorStream(), Charset.forName("UTF-8")));
String temp = in.readLine();
StringBuilder sb = new StringBuilder();
// 连接成一个字符串
while (temp != null) {
sb.append(temp);
temp = in.readLine();
}
// 关闭流
in.close();
// 取出最终获取的响应内容
responseText = sb.toString();
}
} catch (Exception e) {
throw e;
}
return responseText;
}
/**
* Description: 请求处理
* @param apiUrl
* @param postData
* @param headerMap
* @param requestIsJsonFormat
* @param responseIsJsonFormat
* @return
*/
private boolean WebapiCallHandler(String apiUrl, String postData,
Map<String, String> headerMap, boolean requestIsJsonFormat,
boolean responseIsJsonFormat) {
boolean callResult = true;
HttpURLConnection httpConn = null;
boolean postRequestFlag = false;
try {
if (needWriteFileLog) {
logger.info("请求URL： " + apiUrl);
logger.info("请求类型： " + httpMethod);
if ((postData != null) && !"".equals(postData)) {
logger.info("post参数： " + postData);
}
}
if (!"".equals(httpMethod)) {
httpConn = openUrl(apiUrl);
if ("POST".equalsIgnoreCase(httpMethod) ||
"PUT".equalsIgnoreCase(httpMethod)) {
postRequestFlag = true;
}
} else {
if ((postData != null) && !"".equals(postData)) {
httpConn = openUrl(apiUrl);
postRequestFlag = true;
} else {
httpConn = openUrl(apiUrl);
}
}
if (httpConn != null) {
//设置请求数据格式及字符集
if (requestIsJsonFormat == true) {
//请求数据格式为JSON格式，字符集为“UTF-8”
httpConn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
} else {
//请求数据格式非JSON格式，字符集为“UTF-8”
if (postRequestFlag == true) {
httpConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
} else {
httpConn.setRequestProperty("Content-Type", "charset=UTF-8");
}
}
//设置客户端接受的响应数据格式及字符集
if (responseIsJsonFormat == true) {
//请求JSON格式的响应数据
httpConn.setRequestProperty("Accept", "application/json");
} else {
//请求非JSON格式的响应数据
httpConn.setRequestProperty("Accept", "application/json, text/javascript, */*; q=0.01");
}
// 设置其他请求头信息
if (headerMap != null) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
String headerName = entry.getKey();
String headerValue = entry.getValue();
httpConn.setRequestProperty(headerName, headerValue);
}
}
//提交数据到HTTP连接对象
if (("".equals(postData) != true) && (postData != null)) {
httpConn.setDoOutput(true);
httpConn.setDoInput(true);
byte[] tmpPostData = postData.getBytes(Charset.forName("UTF-8"));
httpConn.setRequestProperty("Content-Length",
"" + tmpPostData.length);
httpConn.getOutputStream().write(tmpPostData);
httpConn.getOutputStream().flush();
}
//读取服务器响应内容
webapiResult = getResponseContent(httpConn);
if (needWriteFileLog) {
logger.info("返回内容：" + webapiResult);
}
} else {
callResult = false;
errorMsg = "Failed to establish URL connection.";
}
} catch (Exception e) {
callResult = false;
errorMsg = "Request error." + e.getMessage();
logger.error("请求失败，", e);
}
return callResult;
}
/**
* POST请求提交表单数据
* @param url
* @param formData
* @return
*/
public boolean sendPostForm(String url, Map<String, String> formData) {
try {
String strFormData = this.buildFormData(formData);
return this.WebapiCallHandler(url, strFormData, null, false, false);
} catch (Exception e) {
e.printStackTrace();
errorMsg = "The form data is incorrect";
return false;
}
}
/**
* POST请求提交JSON数据
* @param url
* @param jsonData
* @param responseIsJson
* @return
*/
public boolean sendPostJsonData(String url, String jsonData,
boolean responseIsJson) {
return this.WebapiCallHandler(url, jsonData, null, true, responseIsJson);
}
/**
* POST请求提交数据
* @param url
* @param reqData
* @return
*/
public boolean sendPostJsonData(String url, String reqData) {
return this.WebapiCallHandler(url, reqData, null, false, false);
}
/**
*
* POST请求提交数据
* @param url
* @param reqData
* @return
*/
public boolean sendPostJsonData(String url, String reqData,
boolean requestIsJson, boolean responseIsJson) {
return this.WebapiCallHandler(url, reqData, null, requestIsJson,
responseIsJson);
}
/**
* GET请求数据
* @param url
* @return
*/
public boolean sendGet(String url) {
return this.WebapiCallHandler(url, null, null, false, false);
}
/**
* 自定义请求头json格式数据提交
* @param url
* @param postData
* @param headerMap
* @return
*/
public boolean sendRequest(String url, String postData,
Map<String, String> headerMap) {
return this.WebapiCallHandler(url, postData, headerMap, true, true);
}
/**
* 自定义请求头json格式数据提交
* @param url
* @param headerMap
* @return
*/
public boolean sendRequest(String url, Map<String, String> headerMap) {
return this.WebapiCallHandler(url, null, headerMap, false, true);
}
}用HttpClient实现：
package com.util.httpclient;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 实现Http的Get、Post请求，获取响应内容
* @author zhanglang
* @since 2018-03-15
*/
public class HttpClientService {
private static final Logger logger = LoggerFactory.getLogger(HttpClientService.class);
private final String USER_AGENT = "Mozilla/5.0";
// 请求的地址
private String url;
// 发送请求的类型：GET、POST
private String requestType = "GET";
// 请求参数
private Map<String, Object> paramsMap;
// 请求参数使用的编码，默认UTF-8
private String charset = "UTF-8";
// Get请求拼接的参数
private String getParameters = "?";
// Post请求的参数
private List<NameValuePair> postParameters = new ArrayList<NameValuePair>();
// Header
private Map<String, String> requestHeaders = null;
// 请求响应码
private int responseCode;
//保留换行符
private boolean keepLineBreak = false;
public HttpClientService() {
}
/**
* 构造函数
* @param url 请求地址
* @param requestType 参数传递方式：GET、POST
* @param paramsMap 请求参数名及参数值
* @param charset 对方要求的参数字符编码
*/
public HttpClientService(String url, String requestType,
Map<String, Object> paramsMap, String charset) {
this.url = url;
this.requestType = requestType.toUpperCase();
this.paramsMap = paramsMap;
this.charset = charset;
}
/**
* 构造函数，默认参数传递方式为GET
* @param url 请求地址
* @param paramsMap 请求参数名及参数值
* @param charset 对方要求的参数字符编码
*/
public HttpClientService(String url, Map<String, Object> paramsMap,
String charset) {
this.url = url;
this.paramsMap = paramsMap;
this.charset = charset;
}
/**
* 构造函数，默认传递参数编码为UTF-8
* @param url 请求地址
* @param requestType 参数传递方式：GET、POST
* @param paramsMap 请求参数名及参数值
*/
public HttpClientService(String url, String requestType,
Map<String, Object> paramsMap) {
this.url = url;
this.requestType = requestType.toUpperCase();
this.paramsMap = paramsMap;
}
/**
* 构造函数，默认参数传递方式为GET，默认传递参数编码为UTF-8
* @param url 请求地址
* @param paramsMap 请求参数名及参数值
*/
public HttpClientService(String url, Map<String, Object> paramsMap) {
this.url = url;
this.paramsMap = paramsMap;
}
/**
* 设置请求地址
* @param url
*/
public void setUrl(String url) {
this.url = url;
}
/**
* 设置请求参数传递方式：GET、POST
* @param requestType
*/
public void setRequestType(String requestType) {
this.requestType = requestType.toUpperCase();
}
/**
* 设置请求参数名及参数值
* @param paramsMap
*/
public void setParamsMap(Map<String, Object> paramsMap) {
this.paramsMap = paramsMap;
}
/**
* 设置参数传递使用的编码
* @param charset
*/
public void setCharset(String charset) {
this.charset = charset;
}
/**
* 保留换行符
*/
public void setKeepLineBreak(boolean keepLineBreak) {
this.keepLineBreak = keepLineBreak;
}
/**
* 设置请求头
* @param requestHeaders
*/
public void setRequestHeaders(Map<String, String> requestHeaders) {
this.requestHeaders = requestHeaders;
}
/**
* 获取请求的响应码
* @return
*/
public int getResponseCode() {
return this.responseCode;
}
/**
* 发送请求，并返回响应的内容
* @return
*/
public String sendRequest() {
if ((url == null) || "".equals(url)) {
return "invalid url.";
}
String urlcheck = url.toLowerCase();
if (!urlcheck.startsWith("http://") &&
!urlcheck.startsWith("https://")) {
return "invalid url.";
}
String content = "";
try {
String urlParamSep = "";
// 根据请求类型，拼装参数
Set<String> keySets = paramsMap.keySet();
for (String key : keySets) {
// 将参数值转换为指定编码
String val = new String(String.valueOf(paramsMap.get(key))
.getBytes(charset), charset);
if ("GET".equals(requestType)) {
getParameters = getParameters + urlParamSep + key + "=" +
URLEncoder.encode(val, charset);
if ("".equals(urlParamSep)) {
urlParamSep = "&";
}
} else if ("POST".equals(requestType)) {
postParameters.add(new BasicNameValuePair(key, val));
}
}
if ("GET".equals(requestType)) {
content = this.sendGet();
} else if ("POST".equals(requestType)) {
content = this.sendPost();
}
} catch (Exception e) {
e.printStackTrace();
content = "Request Error.";
}
return content;
}
// HTTP GET request
private String sendGet() throws Exception {
String requestUrl = url;
if (!"?".equals(getParameters)) {
requestUrl = requestUrl + getParameters;
}
HttpClient client = HttpClientBuilder.create().build();
HttpGet request = new HttpGet(requestUrl);
// add request header
request.addHeader("User-Agent", USER_AGENT);
if (requestHeaders != null) {
for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
String headerName = entry.getKey();
String headerValue = entry.getValue();
request.addHeader(headerName, headerValue);
}
}
HttpResponse response = client.execute(request);
responseCode = response.getStatusLine().getStatusCode();
logger.info("\nSending 'GET' request to URL : " + requestUrl);
logger.info("Response Code : " + responseCode);
BufferedReader rd = new BufferedReader(new InputStreamReader(
response.getEntity().getContent(), "UTF-8"));
StringBuffer result = new StringBuffer();
if (keepLineBreak == true) {
int size = 0;
char[] cbuf = new char[512];
while ((size = rd.read(cbuf, 0, cbuf.length)) != -1) {
result.append(new String(cbuf, 0, size));
}
} else {
String line = "";
while ((line = rd.readLine()) != null) {
result.append(line);
}
}
String content = result.toString();
logger.info("Response Content : " + content);
return content;
}
// HTTP POST request
private String sendPost() throws Exception {
HttpClient client = HttpClientBuilder.create().build();
HttpPost post = new HttpPost(url);
// add header
post.setHeader("User-Agent", USER_AGENT);
if (requestHeaders != null) {
for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
String headerName = entry.getKey();
String headerValue = entry.getValue();
post.setHeader(headerName, headerValue);
}
}
post.setEntity(new UrlEncodedFormEntity(postParameters));
logger.info("\nSending 'POST' request to URL : " + url);
InputStream in = post.getEntity().getContent();
byte[] b = new byte[512];
StringBuffer params = new StringBuffer();
int size;
while ((size = in.read(b, 0, b.length)) != -1) {
params.append(new String(b, 0, size));
}
logger.info("Post parameters : " + params);
HttpResponse response = client.execute(post);
responseCode = response.getStatusLine().getStatusCode();
logger.info("Response Code : " + responseCode);
BufferedReader rd = new BufferedReader(new InputStreamReader(
response.getEntity().getContent()));
StringBuffer result = new StringBuffer();
if (keepLineBreak == true) {
size = 0;
char[] cbuf = new char[512];
while ((size = rd.read(cbuf, 0, cbuf.length)) != -1) {
result.append(new String(cbuf, 0, size));
}
} else {
String line = "";
while ((line = rd.readLine()) != null) {
result.append(line);
}
}
String content = result.toString();
logger.info("Response Content : " + content);
return content;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
