使用RequestConfig.custom()创建一个RequestConfig.Builder对象，并通过调用setSocketTimeout、setConnectTimeout和setConnectionRequestTimeout方法来设置超时时间。其中，setSocketTimeout方法用于设置请求获取数据的超时时间为15分钟，setConnectTimeout方法用于设置连接超时时间为15分钟，setConnectionRequestTimeout方法用于设置从connect Manager获取Connection超时时间为15分钟。最后，通过调用build方法构建RequestConfig对象，并将其赋值给requestConfig变量。具体代码如下：
/**
* 默认参数设置
* setConnectTimeout：设置连接超时时间，单位毫秒。
* setConnectionRequestTimeout：设置从connect Manager获取Connection超时时间，单位毫秒。
* setSocketTimeout：请求获取数据的超时时间，单位毫秒。访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。暂时定义15分钟。
*/
private RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(600000) // 设置请求获取数据的超时时间为15分钟，单位为毫秒
.setConnectTimeout(600000) // 设置连接超时时间为15分钟，单位为毫秒
.setConnectionRequestTimeout(600000) // 设置从connect Manager获取Connection超时时间为15分钟，单位为毫秒
.build(); // 构建RequestConfig对象
整体格式
@Component
public class HttpClientUtil {
/**
* 默认参数设置
* setConnectTimeout：设置连接超时时间，单位毫秒。
* setConnectionRequestTimeout：设置从connect Manager获取Connection 超时时间，单位毫秒。
* setSocketTimeout：请求获取数据的超时时间，单位毫秒。访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。 暂时定义15分钟
*/
private RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(600000)
.setConnectTimeout(600000)
.setConnectionRequestTimeout(600000).build();
/**
* 静态内部类---作用：单例产生类的实例
* @author Administrator
*
*/
private static class LazyHolder {
private static final HttpClientUtil INSTANCE = new HttpClientUtil();
}
private HttpClientUtil(){}
public static HttpClientUtil getInstance(){
return LazyHolder.INSTANCE;
}
/**
* 发送 post请求
* @param httpUrl 地址
*/
public String sendHttpPost(String httpUrl) {
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
return sendHttpPost(httpPost);
}
/**
* 发送 post请求
* @param httpUrl 地址
* @param params 参数(格式:key1=value1&key2=value2)
*/
public String sendHttpPost(String httpUrl, String params) {
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
try {
//设置参数
StringEntity stringEntity = new StringEntity(params, "UTF-8");
stringEntity.setContentType("application/x-www-form-urlencoded");
httpPost.setEntity(stringEntity);
} catch (Exception e) {
e.printStackTrace();
}
return sendHttpPost(httpPost);
}
/**
* 发送 post请求
* @param httpUrl 地址
* @param maps 参数
*/
public String sendHttpPost(String httpUrl, Map<String, String> maps) {
HttpPost httpPost = new HttpPost(httpUrl);// 创建httpPost
// 创建参数队列
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
for (String key : maps.keySet()) {
nameValuePairs.add(new BasicNameValuePair(key, maps.get(key)));
}
try {
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF-8"));
} catch (Exception e) {
e.printStackTrace();
}
return sendHttpPost(httpPost);
}
/**
* 发送Post请求
* @param httpPost
* @return
*/
private String sendHttpPost(HttpPost httpPost) {
CloseableHttpClient httpClient = null;
CloseableHttpResponse response = null;
HttpEntity entity = null;
String responseContent = null;
try {
// 创建默认的httpClient实例
httpClient = HttpClients.createDefault();
httpPost.setConfig(requestConfig);
// 执行请求
long execStart = System.currentTimeMillis();
response = httpClient.execute(httpPost);
long execEnd = System.currentTimeMillis();
System.out.println("=================执行post请求耗时："+(execEnd-execStart)+"ms");
long getStart = System.currentTimeMillis();
entity = response.getEntity();
responseContent = EntityUtils.toString(entity, "UTF-8");
long getEnd = System.currentTimeMillis();
System.out.println("=================获取响应结果耗时："+(getEnd-getStart)+"ms");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return responseContent;
}
/**
* 发送 get请求
* @param httpUrl
*/
public String sendHttpGet(String httpUrl) {
HttpGet httpGet = new HttpGet(httpUrl);// 创建get请求
return sendHttpGet(httpGet);
}
/**
* 发送 get请求Https
* @param httpUrl
*/
public String sendHttpsGet(String httpUrl) {
HttpGet httpGet = new HttpGet(httpUrl);// 创建get请求
return sendHttpsGet(httpGet);
}
/**
* 发送Get请求
* @param httpGet
* @return
*/
private String sendHttpGet(HttpGet httpGet) {
CloseableHttpClient httpClient = null; // 声明一个CloseableHttpClient对象
CloseableHttpResponse response = null; // 声明一个CloseableHttpResponse对象
HttpEntity entity = null; // 声明一个HttpEntity对象，用于存储响应实体
String responseContent = null; // 声明一个字符串，用于存储响应内容
try {
// 创建默认的httpClient实例
httpClient = HttpClients.createDefault();
httpGet.setConfig(requestConfig); // 设置请求配置
// 执行请求，获取响应
response = httpClient.execute(httpGet);
entity = response.getEntity(); // 获取响应实体
responseContent = EntityUtils.toString(entity, "UTF-8"); // 将响应实体转换为字符串
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return responseContent; // 返回响应内容
}
/**
* 发送Get请求Https
* @param httpGet
* @return
*/
private String sendHttpsGet(HttpGet httpGet) {
CloseableHttpClient httpClient = null;
CloseableHttpResponse response = null;
HttpEntity entity = null;
String responseContent = null;
try {
// 创建默认的httpClient实例.
PublicSuffixMatcher publicSuffixMatcher = PublicSuffixMatcherLoader.load(new URL(httpGet.getURI().toString()));
DefaultHostnameVerifier hostnameVerifier = new DefaultHostnameVerifier(publicSuffixMatcher);
httpClient = HttpClients.custom().setSSLHostnameVerifier(hostnameVerifier).build();
httpGet.setConfig(requestConfig);
// 执行请求
response = httpClient.execute(httpGet);
entity = response.getEntity();
responseContent = EntityUtils.toString(entity, "UTF-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// 关闭连接,释放资源
if (response != null) {
response.close();
}
if (httpClient != null) {
httpClient.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return responseContent;
}
/**
* 发送xml数据
* @param url
* @param xmlData
* @return
* @throws ClientProtocolException
* @throws IOException
*/
public static HttpResponse sendXMLDataByPost(String url, String xmlData)
throws ClientProtocolException, IOException {
HttpClient httpClient = HttpClients.createDefault();
HttpPost httppost = new HttpPost(url);
StringEntity entity = new StringEntity(xmlData);
httppost.setEntity(entity);
httppost.setHeader("Content-Type", "text/xml;charset=UTF-8");
HttpResponse response = httpClient.execute(httppost);
return response;
}
/**
* 获得响应HTTP实体内容
* @param response
* @return
* @throws IOException
* @throws UnsupportedEncodingException
*/
public static String getHttpEntityContent(HttpResponse response) throws IOException, UnsupportedEncodingException {
// 获取HTTP响应实体
HttpEntity entity = response.getEntity();
if (entity != null) {
// 获取实体的输入流
InputStream is = entity.getContent();
// 创建一个读取器，指定使用UTF-8字符编码
BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
// 读取第一行内容
String line = br.readLine();
// 创建一个字符串构建器，用于存储读取到的内容
StringBuilder sb = new StringBuilder();
// 循环读取每一行内容，直到读取完毕
while (line != null) {
// 将每一行内容追加到字符串构建器中
sb.append(line + "\n");
// 继续读取下一行内容
line = br.readLine();
}
// 将字符串构建器中的内容转换为字符串，并返回
return sb.toString();
}
// 如果实体为空，则返回空字符串
return "";
}
}
4564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
