在对接第三方接口时，需要进行数据交互，于是写了一个 Java 的 Http 请求工具类，该工具类可以调用 Get 请求或者 POST 请求。
根据自己业务需求灵活修改，这里写了两个工具类，自己选一个就可以
直接上代码：
添加依赖:
<!--提供高效的、最新的、功能丰富的支持HTTP协议的客户端-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.2</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.5</version>
</dependency>工具类1：
package com.file.license.utils;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.net.*;
import java.util.Map;
import java.util.Set;
/**
* @ClassName HttpUtils
* @Description 请求工具
* @Author msx
* @Date 2021-08-26 17:40
* @Version 1.0
*/
public class HttpUtils {
/**
* @Description get请求，参数k-v形式
* @Author msx
* @Date 2021-08-26 17:41
* @param url-[请求地址] headMap-[请求头参数] paramMap-[请求参数]
* @return String 返回结果
*/
public static String doGet(String url, Map<String, String> headMap, Map<String, String> paramMap) {
System.out.println(" = = 请求地址 = = > > > > > > " + url);
// 创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
String result = "";
CloseableHttpResponse response = null;
try {
//创建uri
URIBuilder builder = new URIBuilder(url);
if (paramMap != null && !paramMap.isEmpty()) {
Set<Map.Entry<String, String>> entrySet = paramMap.entrySet();
for (Map.Entry<String, String> entry : entrySet) {
builder.addParameter(entry.getKey(), entry.getValue());
}
}
URI uri = builder.build();
// 创建http GET请求
HttpGet httpGet = new HttpGet(uri);
//添加请求头
if (headMap != null && !headMap.isEmpty()) {
Set<Map.Entry<String, String>> entries = headMap.entrySet();
System.out.println(" = = 请求头 = = > > > > > > ");
for (Map.Entry<String, String> e : entries) {
System.out.println(e.getKey() + ":" + e.getValue());
httpGet.addHeader(e.getKey(), e.getValue());
}
}
// 执行请求
response = httpClient.execute(httpGet);
// 判断返回状态是否为200
/*if (response.getStatusLine().getStatusCode() == 200) {
result = EntityUtils.toString(response.getEntity(), "UTF-8");
}*/
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, "utf-8");
System.out.println(" = = 请求返回 = = > > > > > > " + result);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeResource(response, httpClient);
}
return result;
}
/**
* @Description post请求，参数k-v形式
* @Author msx
* @Date 2021-08-29 21:13
* @param url-[请求地址] headMap-[请求头参数] paramMap-[请求参数]
* @return String 返回结果
*/
public static String doPost(String url, Map<String, String> headMap, Map<String, String> paramMap) {
System.out.println(" = = 请求地址 = = > > > > > > " + url);
System.out.println(" = = 请求参数 = = > > > > > > " + paramMap);
//创建httpClient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String result = "";
try{
//创建uri
URIBuilder builder = new URIBuilder(url);
if (paramMap != null && !paramMap.isEmpty()) {
Set<Map.Entry<String, String>> entrySet = paramMap.entrySet();
for (Map.Entry<String, String> entry : entrySet) {
builder.addParameter(entry.getKey(), entry.getValue());
}
}
URI uri = builder.build();
//创建http请求
HttpPost httpPost = new HttpPost(uri);
//添加请求头
if (headMap != null && !headMap.isEmpty()) {
System.out.println(" = = 请求头 = = > > > > > > ");
Set<Map.Entry<String, String>> entries = headMap.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey() + ":" + entry.getValue());
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
// 执行请求
response = httpClient.execute(httpPost);
result = EntityUtils.toString(response.getEntity(), "utf-8");
System.out.println(" = = 请求返回 = = > > > > > > " + result);
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭资源
closeResource(response, httpClient);
}
return result;
}
/**
* @Description post请求，请求体为JSON格式
* @Author msx
* @Date 2021-08-27 16:31
* @param url-[请求地址] headMap-[请求头参数] paramMap-[请求参数]
* @return String 返回结果
*/
public static String doPost(String url, Map<String, String> header, String jsonParams){
System.out.println(" = = 请求地址 = = > > > > > > " + url);
System.out.println(" = = 请求参数 = = > > > > > > " + jsonParams);
//创建httpClient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String result = "";
try{
//创建http请求
HttpPost httpPost = new HttpPost(url);
httpPost.addHeader("Content-Type", "application/json");
//创建请求内容
StringEntity entity = new StringEntity(jsonParams, "utf-8");
entity.setContentType("application/json");
httpPost.setEntity(entity);
// 设置请求头
if (null != header && !header.isEmpty()) {
System.out.println(" = = 请求头 = = > > > > > > ");
Set<Map.Entry<String, String>> entries = header.entrySet();
for (Map.Entry<String, String> e : entries) {
System.out.println(e.getKey() + ":" + e.getValue());
httpPost.setHeader(e.getKey(), e.getValue());
}
}
response = httpClient.execute(httpPost);
result = EntityUtils.toString(response.getEntity(), "utf-8");
System.out.println(" = = 请求返回 = = > > > > > > " + result);
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭资源
closeResource(response, httpClient);
}
return result;
}
/**
* @Description 关闭资源
* @Author msx
* @Date 2021/9/8 10:44
*/
private static void closeResource(Closeable ... resources) {
System.out.println("> > > > > > > > > > 关闭流资源 > > > > > > > > > >");
try {
for (Closeable resource : resources) {
if (resource != null) {
resource.close();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试：
package com.ynkbny.web.controller;
import com.ynkbny.util.HttpUtils;
import com.ynkbny.util.Res;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 老狗Api接口-控制层
*
* @author : juzipi123
* @date : 2023-7-17
*/
@Slf4j
@Api(tags = "Api接口")
@RestController
@RequestMapping("/api")
public class LaoGouApiController {
/**
* 登陆
*
* @author : juzipi
* @param username 用户名
* @param password 密码
* @return 结果
*/
@ApiOperation("登陆")
@RequestMapping("/login")
public Res<String> login(String username ,String password) throws Exception {
log.info("请求参数：{},{}",username,password);
String url = "https://api.bknykf.com/api/user/login"+"?username="+username+"&password="+password;
// return Res.ok(HttpUtils.doGet(url, null,null));
return Res.ok(HttpUtils.doPost(url, null,""));
}
}
测试结果：
工具类2：
package com.ynkbny.util;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.*;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* HTTP请求工具
*
* @author Smaple
*/
public class HttpClientUtils {
private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private final static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
/**
* 最大线程池
*/
public static final int THREAD_POOL_SIZE = 5;
public interface HttpClientDownLoadProgress {
public void onProgress(int progress);
}
private static HttpClientUtils httpClientDownload = new HttpClientUtils();
private ExecutorService downloadExcutorService;
private HttpClientUtils() {
downloadExcutorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
}
public static HttpClientUtils getInstance() {
return httpClientDownload;
}
/**
* 下载文件
*
* @param url
* @param filePath
*/
public void download(final String url, final String filePath) {
downloadExcutorService.execute(new Runnable() {
@Override
public void run() {
httpDownloadFile(url, filePath, null, null);
}
});
}
/**
* 下载文件
*
* @param url
* @param filePath
* @param progress 进度回调
*/
public void download(final String url, final String filePath,
final HttpClientDownLoadProgress progress) {
downloadExcutorService.execute(new Runnable() {
@Override
public void run() {
httpDownloadFile(url, filePath, progress, null);
}
});
}
/**
* 下载文件
*
* @param url
* @param filePath
*/
private void httpDownloadFile(String url, String filePath,
HttpClientDownLoadProgress progress, Map<String, String> headMap) {
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpGet httpGet = new HttpGet(url);
setGetHead(httpGet, headMap);
CloseableHttpResponse response1 = httpclient.execute(httpGet);
try {
HttpEntity httpEntity = response1.getEntity();
long contentLength = httpEntity.getContentLength();
InputStream is = httpEntity.getContent();
// 根据InputStream 下载文件
ByteArrayOutputStream output = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int r = 0;
long totalRead = 0;
while ((r = is.read(buffer)) > 0) {
output.write(buffer, 0, r);
totalRead += r;
if (progress != null) {// 回调进度
progress.onProgress((int) (totalRead * 100 / contentLength));
}
}
FileOutputStream fos = new FileOutputStream(filePath);
output.writeTo(fos);
output.flush();
output.close();
fos.close();
EntityUtils.consume(httpEntity);
} finally {
response1.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* get请求
*
* @param url
* @return
*/
public String httpGet(String url) {
return httpGet(url, null);
}
/**
* http get请求
*
* @param url
* @return
*/
public String httpGet(String url, Map<String, String> headMap) {
String responseContent = null;
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpGet httpGet = new HttpGet(url);
CloseableHttpResponse response1 = httpclient.execute(httpGet);
setGetHead(httpGet, headMap);
try {
HttpEntity entity = response1.getEntity();
responseContent = getRespString(entity);
EntityUtils.consume(entity);
} finally {
response1.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return responseContent;
}
public String httpPost(String url, Map<String, String> paramsMap) {
return httpPost(url, paramsMap, null);
}
/**
* http的post请求
*
* @param url
* @param paramsMap
* @return
*/
public String httpPost(String url, Map<String, String> paramsMap,
Map<String, String> headMap) {
String responseContent = null;
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpPost httpPost = new HttpPost(url);
setPostHead(httpPost, headMap);
setPostParams(httpPost, paramsMap);
CloseableHttpResponse response = httpclient.execute(httpPost);
try {
HttpEntity entity = response.getEntity();
responseContent = getRespString(entity);
EntityUtils.consume(entity);
} finally {
response.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return responseContent;
}
/**
* 设置POST的参数
*
* @param httpPost
* @param paramsMap
* @throws Exception
*/
private void setPostParams(HttpPost httpPost, Map<String, String> paramsMap)
throws Exception {
if (paramsMap != null && paramsMap.size() > 0) {
List<NameValuePair> nvps = new ArrayList<NameValuePair>();
Set<String> keySet = paramsMap.keySet();
for (String key : keySet) {
nvps.add(new BasicNameValuePair(key, paramsMap.get(key)));
}
httpPost.setEntity(new UrlEncodedFormEntity(nvps, DEFAULT_CHARSET));
}
}
/**
* 设置http的HEAD
*
* @param httpPost
* @param headMap
*/
private void setPostHead(HttpPost httpPost, Map<String, String> headMap) {
if (headMap != null && headMap.size() > 0) {
Set<String> keySet = headMap.keySet();
for (String key : keySet) {
httpPost.addHeader(key, headMap.get(key));
}
}
}
/**
* 设置http的HEAD
*
* @param httpGet
* @param headMap
*/
private void setGetHead(HttpGet httpGet, Map<String, String> headMap) {
if (headMap != null && headMap.size() > 0) {
Set<String> keySet = headMap.keySet();
for (String key : keySet) {
httpGet.addHeader(key, headMap.get(key));
}
}
}
/**
* 上传文件
*
* @param serverUrl 服务器地址
* @param localFilePath 本地文件路径
* @param serverFieldName
* @param params
* @return
* @throws Exception
*/
public String uploadFileImpl(String serverUrl, String localFilePath,
String serverFieldName, Map<String, String> params)
throws Exception {
String respStr = null;
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpPost httppost = new HttpPost(serverUrl);
FileBody binFileBody = new FileBody(new File(localFilePath));
MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
// add the file params
multipartEntityBuilder.addPart(serverFieldName, binFileBody);
// 设置上传的其他参数
setUploadParams(multipartEntityBuilder, params);
HttpEntity reqEntity = multipartEntityBuilder.build();
httppost.setEntity(reqEntity);
CloseableHttpResponse response = httpclient.execute(httppost);
try {
HttpEntity resEntity = response.getEntity();
respStr = getRespString(resEntity);
EntityUtils.consume(resEntity);
} finally {
response.close();
}
} finally {
httpclient.close();
}
return respStr;
}
public String httpsPost(String url, Map<String, String> heads, Map<String, String> params) throws Exception {
String body = "";
SSLContext sslcontext = createIgnoreVerifySSL();
//设置协议http和https对应的处理socket链接工厂的对象
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", new SSLConnectionSocketFactory(sslcontext))
.build();
PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
HttpClients.custom().setConnectionManager(connManager);
CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
try {
//创建post方式请求对象
HttpPost httpPost = new HttpPost(url);
if (heads != null) {
for (Map.Entry<String, String> head : heads.entrySet()) {
httpPost.setHeader(head.getKey(), head.getValue());
}
}
setPostParams(httpPost, params);
//执行请求操作，并拿到结果（同步阻塞）
CloseableHttpResponse response = client.execute(httpPost);
//获取结果实体
HttpEntity entity = response.getEntity();
if (entity != null) {
//按指定编码转换结果实体为String类型
body = EntityUtils.toString(entity, "UTF-8");
}
EntityUtils.consume(entity);
//释放链接
response.close();
return body;
} finally {
client.close();
}
}
/**
* 绕过验证
*
* @return
* @throws NoSuchAlgorithmException
* @throws KeyManagementException
*/
private SSLContext createIgnoreVerifySSL() throws NoSuchAlgorithmException, KeyManagementException {
SSLContext sc = SSLContext.getInstance("SSLv3");
X509TrustManager trustManager = new X509TrustManager() {
@Override
public void checkClientTrusted(
java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
String paramString) throws CertificateException {
}
@Override
public void checkServerTrusted(
java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
String paramString) throws CertificateException {
}
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sc.init(null, new TrustManager[]{trustManager}, null);
return sc;
}
/**
* 设置上传文件时所附带的其他参数
*
* @param multipartEntityBuilder
* @param params
*/
private void setUploadParams(MultipartEntityBuilder multipartEntityBuilder,
Map<String, String> params) {
if (params != null && params.size() > 0) {
Set<String> keys = params.keySet();
for (String key : keys) {
multipartEntityBuilder
.addPart(key, new StringBody(params.get(key),
ContentType.TEXT_PLAIN));
}
}
}
/**
* 将返回结果转化为String
*
* @param entity
* @return
* @throws Exception
*/
private String getRespString(HttpEntity entity) throws Exception {
if (entity == null) {
return null;
}
InputStream is = entity.getContent();
StringBuffer strBuf = new StringBuffer();
byte[] buffer = new byte[4096];
int r = 0;
while ((r = is.read(buffer)) > 0) {
strBuf.append(new String(buffer, 0, r, "UTF-8"));
}
return strBuf.toString();
}
public static String postTimeout(String url, String requestBody, int millisecondTimeout, TimeOutErrorHandler errorHandler) {
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost httpPost = new HttpPost(url);
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(millisecondTimeout).setConnectionRequestTimeout(millisecondTimeout)
.setSocketTimeout(millisecondTimeout).build();
httpPost.setConfig(requestConfig);
CloseableHttpResponse response = null;
StringEntity reqEntity = null;
HttpEntity respEntity = null;
try {
reqEntity = new StringEntity(requestBody, DEFAULT_CHARSET);
httpPost.setEntity(reqEntity);
response = httpclient.execute(httpPost);
respEntity = response.getEntity();
int stateCode = response.getStatusLine().getStatusCode();
if (200 != stateCode) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 响应码为：{}, 响应失败！", url, stateCode);
}
return null;
}
return EntityUtils.toString(response.getEntity(), DEFAULT_CHARSET);
} catch (SocketTimeoutException e) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 请求超时. 超时设置时间为：{}", url, millisecondTimeout);
}
if (errorHandler != null) errorHandler.handler(e);
return null;
} catch (Exception e) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 请求出错， 错误原因是：{}", url, e.getMessage());
}
return null;
} finally {
try {
EntityUtils.consume(respEntity);
EntityUtils.consume(reqEntity);
} catch (IOException e) {
e.printStackTrace();
}
if (response != null) {
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (httpclient != null) {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static String postProxyTimeout(String proxyIp, int proxyPort, String url, String requestBody, int millisecondTimeout, TimeOutErrorHandler errorHandler) {
CloseableHttpClient httpclient = HttpClients.createDefault();
//设置代理IP、端口
HttpHost proxy = new HttpHost(proxyIp, proxyPort, "http");
HttpPost httpPost = new HttpPost(url);
RequestConfig requestConfig = RequestConfig.custom()
.setProxy(proxy)
.setConnectTimeout(millisecondTimeout).setConnectionRequestTimeout(millisecondTimeout)
.setSocketTimeout(millisecondTimeout).build();
httpPost.setConfig(requestConfig);
CloseableHttpResponse response = null;
StringEntity reqEntity = null;
HttpEntity respEntity = null;
try {
reqEntity = new StringEntity(requestBody, DEFAULT_CHARSET);
httpPost.setEntity(reqEntity);
response = httpclient.execute(httpPost);
respEntity = response.getEntity();
int stateCode = response.getStatusLine().getStatusCode();
if (200 != stateCode) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 响应码为：{}, 响应失败！", url, stateCode);
}
return null;
}
return EntityUtils.toString(response.getEntity(), DEFAULT_CHARSET);
} catch (SocketTimeoutException e) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 请求超时. 超时设置时间为：{}", url, millisecondTimeout);
}
if (errorHandler != null) errorHandler.handler(e);
return null;
} catch (Exception e) {
if (logger.isErrorEnabled()) {
logger.error("请求地址：{}, 请求出错， 错误原因是：{}", url, e.getMessage());
}
return null;
} finally {
try {
EntityUtils.consume(respEntity);
EntityUtils.consume(reqEntity);
} catch (IOException e) {
e.printStackTrace();
}
if (response != null) {
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (httpclient != null) {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public interface TimeOutErrorHandler {
void handler(SocketTimeoutException e);
}
/**
* 向指定 URL 发送POST方法的请求
*
* @param url 发送请求的 URL
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
* @return 所代表远程资源的响应结果
*/
public static String sendPost(String url, String param) {
PrintWriter out = null;
BufferedReader in = null;
String result = "";
try {
URL realUrl = new URL(url);
// 打开和URL之间的连接
URLConnection conn = realUrl.openConnection();
// 设置通用的请求属性
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
// 发送POST请求必须设置如下两行
conn.setDoOutput(true);
conn.setDoInput(true);
// 获取URLConnection对象对应的输出流
out = new PrintWriter(conn.getOutputStream());
// 发送请求参数
out.print(param);
// flush输出流的缓冲
out.flush();
// 定义BufferedReader输入流来读取URL的响应
in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
} catch (Exception e) {
System.out.println("发送 POST 请求出现异常！" + e);
return null;
//e.printStackTrace();
}
// 使用finally块来关闭输出流、输入流
finally {
try {
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return result;
}
/**
* 发送post请求 携带json数据的
* @param url
* @param jsonStr
*/
public static String sendPostMethod(String url, String jsonStr, String authorization) {
String result = "";
//1.创建httpClient
CloseableHttpClient httpClient = HttpClients.createDefault();
//2.创建post请求方式实例
HttpPost httpPost = new HttpPost(url);
//2.1设置请求头 发送的是json数据格式
httpPost.setHeader("Content-type", "application/json;charset=utf-8");
httpPost.setHeader("Connection", "Close");
if (ObjectUtils.isNotEmpty(authorization)) {
httpPost.setHeader("Authorization", authorization);
}
//3.设置参数---设置消息实体 也就是携带的数据
StringEntity entity = new StringEntity(jsonStr.toString(), Charset.forName("UTF-8"));
//设置编码格式
entity.setContentEncoding("UTF-8");
// 发送Json格式的数据请求
entity.setContentType("application/json");
//把请求消息实体塞进去
httpPost.setEntity(entity);
//4.执行http的post请求
CloseableHttpResponse httpResponse = null;
InputStream inputStream = null;
try {
httpResponse = httpClient.execute(httpPost);
// 5.对返回的数据进行处理
// 5.1判断是否成功
System.out.println(httpResponse.getStatusLine().getStatusCode());
// 5.2对数据进行处理
HttpEntity httpEntity = httpResponse.getEntity();
//获取content实体内容
inputStream = httpEntity.getContent();
//封装成字符流来输出
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line = "";
while ((line = bufferedReader.readLine()) != null) {
result += line;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//6.关闭inputStream和httpResponse
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (httpResponse != null) {
try {
httpResponse.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
/**
* 设置代理
*
* @param httpGet
* @param proxyIp
* @param proxyPort
* @return
*/
public CloseableHttpClient setProxy(HttpGet httpGet, String proxyIp, int proxyPort) {
// 创建httpClient实例
CloseableHttpClient httpClient = HttpClients.createDefault();
//设置代理IP、端口
HttpHost proxy = new HttpHost(proxyIp, proxyPort, "http");
//也可以设置超时时间 RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy).setConnectTimeout(3000).setSocketTimeout(3000).setConnectionRequestTimeout(3000).build();
RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy).build();
httpGet.setConfig(requestConfig);
return httpClient;
}
/**
* 设置代理
*
* @param httpPost
* @param proxyIp
* @param proxyPort
* @return
*/
public static CloseableHttpClient setPostProxy(HttpPost httpPost, String proxyIp, int proxyPort) {
// 创建httpClient实例
CloseableHttpClient httpClient = HttpClients.createDefault();
//设置代理IP、端口
HttpHost proxy = new HttpHost(proxyIp, proxyPort, "http");
//也可以设置超时时间 RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy).setConnectTimeout(3000).setSocketTimeout(3000).setConnectionRequestTimeout(3000).build();
RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy).build();
httpPost.setConfig(requestConfig);
return httpClient;
}
}
测试：
package com.ynkbny.web.controller;
import com.ynkbny.util.HttpClientUtils;
import com.ynkbny.util.Res;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* Api接口-控制层
*
* @author : juzipi
*/
@Slf4j
@Api(tags = "Api接口")
@RestController
@RequestMapping("/api")
public class LaoGouApiController {
/**
* 登陆
*
* @author : juzipi
* @param username 用户名
* @param password 密码
* @return 结果
*/
@ApiOperation("登陆")
@RequestMapping("/login")
public Res<String> login(String username ,String password) throws Exception {
log.info("请求参数：{},{}",username,password);
String url = "https://api.bknykf.com/api/user/login"+"?username="+username+"&password="+password;
// return Res.ok(sendPostMethod(url,""));
return Res.ok(sendReq(url,""));
}
private static String sendReq(String reqUrl, String param) throws Exception {
log.info("=====请求地址：" + reqUrl);
log.info("=====请求数据：" + param);
String result = HttpClientUtils.sendPost(reqUrl, param);
log.info("=====响应数据：" + result);
return result;
}
private static String sendPostMethod(String reqUrl, String param) throws Exception {
log.info("=====请求地址：" + reqUrl);
log.info("=====请求数据：" + param);
String result = HttpClientUtils.sendPostMethod(reqUrl, param,null);
log.info("=====响应数据：" + result);
return result;
}
}
测试结果：
