Java实现调用HTTP请求的几种常见方式

最新推荐文章于 2025-04-17 15:47:30 发布
最新推荐文章于 2025-04-17 15:47:30 发布
阅读量2.4k 收藏 4
点赞数 2
分类专栏： java 文章标签： java http 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Andy19891117/article/details/134981402
版权

一、概述

在实际开发过程中，我们经常需要调用对方提供的接口或测试自己写的接口是否合适。很多项目都会封装规定好本身项目的接口规范，所以大多数需要去调用对方提供的接口或第三方接口（短信、天气等）。

在 Java 项目中调用第三方接口的方式有：

  • 通过 JDK 网络类 Java.net.HttpURLConnection ；
  • 通过 common 封装好的 httpClient ；
  • 通过 apache 封装好的 CloseableHttpClient ；
  • 通过 SpringBoot-RestTemplate ；
  • 使用hutool工具进行http接口调用；

二、 Java调用第三方http接口的方式

2.1、通过JDK网络类Java.net.HttpURLConnection

比较原始的一种调用做法，这里把get请求和post请求都统一放在一个方法里面。

实现过程：

GET:

  1. 创建远程连接
  2. 设置连接方式（get、post、put。。。）
  3. 设置连接超时时间
  4. 设置响应读取时间
  5. 发起请求
  6. 获取请求数据
  7. 关闭连接

POST:

  1. 创建远程连接
  2. 设置连接方式（get、post、put。。。）
  3. 设置连接超时时间
  4. 设置响应读取时间
  5. 当向远程服务器传送数据/写数据时，需要设置为true（setDoOutput）
  6. 当前向远程服务读取数据时，设置为true，该参数可有可无（setDoInput）
  7. 设置传入参数的格式:（setRequestProperty）
  8. 设置 鉴权 信息：Authorization:（setRequestProperty）
  9. 设置参数
  10. 发起请求
  11. 获取请求数据
  12. 关闭连接

直接上代码：

 

package com.riemann.springbootdemo.util.common.httpConnectionUtil;
import org.springframework.lang.Nullable;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURL Exception ;
import java.net.URL;
import java.net.URLConnection;
/**
* @author riemann
*/public class HttpURLConnectionUtil {
/**
* Http get请求
* @param httpUrl 连接
* @return 响应数据
*/ public static String Do Get(String httpUrl){
//链接
HttpURLConnection connection = null;
InputStream is = null;
BufferedReader br = null;
StringBuffer result = new StringBuffer();
try {
//创建连接
URL url = new URL(httpUrl);
connection = (HttpURLConnection) url.openConnection();
//设置请求方式
connection.setRequestMethod("GET");
//设置连接超时时间
connection.setReadTimeout();
//开始连接
connection.connect();
//获取响应数据
if (connection.getResponseCode() ==) {
//获取返回的数据
is = connection.getInputStream();
if (null != is) {
br = new BufferedReader(new InputStreamReader(is, " UTF-8 "));
String temp = null;
while (null != (temp = br.readLine())) {
result.append(temp);
}
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != is) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//关闭远程连接
connection.disconnect();
}
return result.toString();
}
/**
* Http post请求
* @param httpUrl 连接
* @param param 参数
* @return
*/ public static String doPost(String httpUrl, @Nullable String param) {
StringBuffer result = new StringBuffer();
//连接
HttpURLConnection connection = null;
OutputStream os = null;
InputStream is = null;
BufferedReader br = null;
try {
//创建连接对象
URL url = new URL(httpUrl);
//创建连接
connection = (HttpURLConnection) url.openConnection();
//设置请求方法
connection.setRequestMethod("POST");
//设置连接超时时间
connection.setConnectTimeout();
//设置读取超时时间
connection.setReadTimeout();
//DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
//设置是否可读取
connection.setDoOutput(true);
connection.setDoInput(true);
//设置通用的请求属性
connection.set Request Property("accept", "*/*");
connection.setRequestProperty("connection", "Keep-Alive");
connection.setRequestProperty("user-agent", "Mozilla/.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
connection.setRequestProperty("Content-Type", "application/ JSON ; charset =utf-8");
//拼装参数
if (null != param && param.equals("")) {
//设置参数
os = connection.get Output Stream();
//拼装参数
os.write(param.get byte s("UTF-8"));
}
//设置权限
//设置请求头等
//开启连接
//connection.connect();
//读取响应
if (connection.getResponseCode() ==) {
is = connection.getInputStream();
if (null != is) {
br = new BufferedReader(new InputStreamReader(is, "GBK"));
String temp = null;
while (null != (temp = br.readLine())) {
result.append(temp);
result.append("rn");
}
}
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭连接
if(br!=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (os!=null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//关闭连接
connection.disconnect();
}
return result.toString();
}
public static void main(String[] args) {
String message = doPost("#34;, "");
System.out.println(message);
}
}
 

运行结果：
 

 

 

2.2 通过apache common封装好的HttpClient
 

httpClient的get或post请求方式步骤：
 

  1. 生成一个HttpClient对象并设置相应的参数；
  2. 生成一个GetMethod对象或PostMethod并设置响应的参数；
  3. 用HttpClient生成的对象来执行GetMethod生成的Get方法；
  4. 处理响应状态码；
  5. 若响应正常，处理HTTP响应内容；
  6. 释放连接。
 

导入如下jar包：
 

 

<!--HttpClient-->
<dependency>
<groupId>commons-httpclient</groupId>
<artifactId>commons-httpclient</artifactId>
<version>.1</version>
</dependency>
<!-- fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>.2.32</version>
</dependency>
 

代码如下：
 

 

package com.riemann.springbootdemo.util.common.httpConnectionUtil;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient. params .HttpMethodParams;
import java.io.IOException;
/**
* @author riemann
*/public class HttpClientUtil {
/**
* httpClient的get请求方式
* 使用GetMethod来访问一个URL对应的网页实现步骤：
*.生成一个HttpClient对象并设置相应的参数；
*.生成一个GetMethod对象并设置响应的参数；
*.用HttpClient生成的对象来执行GetMethod生成的Get方法；
*.处理响应状态码；
*.若响应正常，处理HTTP响应内容；
*.释放连接。
* @param url
* @param charset
* @return
*/ public static String doGet(String url, String charset) {
//.生成HttpClient对象并设置参数
HttpClient httpClient = new HttpClient();
//设置Http连接超时为秒
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout();
//.生成GetMethod对象并设置参数
GetMethod getMethod = new GetMethod(url);
//设置get请求超时为秒
getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT,);
//设置请求重试处理，用的是默认的重试处理：请求三次
getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
String response = "";
//.执行HTTP GET 请求
try {
int statusCode = httpClient.executeMethod(getMethod);
//.判断访问的状态码
if (statusCode != HttpStatus.SC_OK) {
System.err.println("请求出错：" + getMethod.getStatusLine());
}
//.处理HTTP响应内容
//HTTP响应头部信息，这里简单打印
Header [] headers = getMethod.getResponseHeaders();
for(Header h : headers) {
System.out.println(h.getName() + "---------------" + h.getValue());
}
//读取HTTP响应内容，这里简单打印网页内容
//读取为字节数组
byte[] responseBody = getMethod.getResponseBody();
response = new String(responseBody, charset);
System.out.println("-----------response:" + response);
//读取为InputStream，在网页内容数据量大时候推荐使用
//InputStream response = getMethod.getResponseBodyAsStream();
} catch (HttpException e) {
//发生致命的异常，可能是协议不对或者返回的内容有问题
System.out.println("请检查输入的URL!");
e.printStackTrace();
} catch (IOException e) {
//发生网络异常
System.out.println("发生网络异常!");
} finally {
//.释放连接
getMethod.releaseConnection();
}
return response;
}
/**
* post请求
* @param url
* @param json
* @return
*/ public static String doPost(String url, json Object json){
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(url);
postMethod.addRequestHeader("accept", "*/*");
postMethod.addRequestHeader("connection", "Keep-Alive");
//设置json格式传送
postMethod.addRequestHeader("Content-Type", "application/json;charset=GBK");
//必须设置下面这个Header
postMethod.addRequestHeader("User-Agent", "Mozilla/.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
//添加请求参数
postMethod.addParameter("commentId", json.getString("commentId"));
String res = "";
try {
int code = httpClient.executeMethod(postMethod);
if (code ==){
res = postMethod.getResponseBodyAsString();
System.out.println(res);
}
} catch (IOException e) {
e.printStackTrace();
}
return res;
}
public static void main(String[] args) {
System.out.println(doGet("#;, "GBK"));
System.out.println("-----------分割线------------");
System.out.println("-----------分割线------------");
System.out.println("-----------分割线------------");
JSONObject jsonObject = new JSONObject();
jsonObject.put("commentId", "");
System.out.println(doPost("#;, jsonObject));
}
}
 

运行结果：
 

 

 

post请求的 jsonObject 的参数也成功写入
 

2.3 通过Apache封装好的CloseableHttpClient
 

CloseableHttpClient 是在 HttpClient 的基础上修改更新而来的，这里还涉及到请求头token的设置（请求验证），利用fastjson转换请求或返回结果字符串为json格式，当然上面两种方式也是可以设置请求头token、json的，这里只在下面说明。
 

导入如下jar包：
 

 

<!--CloseableHttpClient-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>.5.2</version>
</dependency>
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>.2.32</version>
</dependency>
 

代码如下：
 

 

package com.riemann.springbootdemo.util.common.httpConnectionUtil;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
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.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
/**
* @author riemann
*/public class CloseableHttpClientUtil {
private static String tokenString = "";
private static String AUTH_TOKEN_EXPIRED = "AUTH_TOKEN_EXPIRED";
private static CloseableHttpClient httpClient = null;
/**
* 以get方式调用第三方接口
* @param url
* @param token
* @return
*/ public static String doGet(String url, String token) {
//创建HttpClient对象
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
HttpGet httpGet = new HttpGet(url);
if (null != tokenString && !tokenString.equals("")) {
tokenString = getToken();
}
//api_gateway_auth_token自定义header头，用于token验证使用
httpGet.addHeader("api_gateway_auth_token",tokenString);
httpGet.addHeader("User-Agent", "Mozilla/.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
try {
HttpResponse response = httpClient.execute(httpGet);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
//返回json格式
String res = EntityUtils.toString(response.getEntity());
return res;
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 以post方式调用第三方接口
* @param url
* @param json
* @return
*/ public static String doPost(String url, JSONObject json) {
if (null == httpClient) {
httpClient = HttpClientBuilder.create().build();
}
HttpPost httpPost = new HttpPost(url);
if (null != tokenString && tokenString.equals("")) {
tokenString = getToken();
}
//api_gateway_auth_token自定义header头，用于token验证使用
httpPost.addHeader("api_gateway_auth_token", tokenString);
httpPost.addHeader("User-Agent", "Mozilla/.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
try {
StringEntity se = new StringEntity(json.toString());
se.setContentEncoding("UTF-");
//发送json数据需要设置contentType
se.setContentType("application/x-www-form-urlencoded");
//设置请求参数
httpPost.setEntity(se);
HttpResponse response = httpClient.execute(httpPost);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
//返回json格式
String res = EntityUtils.toString(response.getEntity());
return res;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (httpClient != null){
try {
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
/**
* 获取第三方接口的token
*/ public static String getToken() {
String token = "";
JSONObject object = new JSONObject();
object.put("appid", "appid");
object.put("secretkey", "secretkey");
if (null == httpClient) {
httpClient = HttpClientBuilder.create().build();
}
HttpPost httpPost = new HttpPost("#;");
httpPost.addHeader("User-Agent", "Mozilla/.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
try {
StringEntity se = new StringEntity(object.toString());
se.setContentEncoding("UTF-");
//发送json数据需要设置contentType
se.setContentType("application/x-www-form-urlencoded");
//设置请求参数
httpPost.setEntity(se);
HttpResponse response = httpClient.execute(httpPost);
//这里可以把返回的结果按照自定义的返回数据结果，把string转换成自定义类
//ResultTokenBO result = JSONObject.parseObject(response, ResultTokenBO.class);
//把response转为jsonObject
JSONObject result = (JSONObject) JSONObject.parseObject(String.valueOf(response));
if (result.containsKey("token")) {
token = result.getString("token");
}
} catch (IOException e) {
e.printStackTrace();
}
return token;
}
/**
* 测试
*/ public static void test(String telephone) {
JSONObject object = new JSONObject();
object.put("telephone", telephone);
//首先获取token
tokenString = getToken();
String response = doPost("#;, object);
//如果返回的结果是list形式的，需要使用JSONObject.parseArray转换
//List<Result> list = JSONObject.parseArray(response, Result.class);
System.out.println(response);
}
public static void main(String[] args) {
test("");
}
}
 

2.4 通过SpringBoot-RestTemplate
 

springBoot-RestTemple 是上面三种方式的集大成者，代码编写更加简单，目前可以采用的调用第三方接口有：
 

  • delete() 在特定的URL上对资源执行 HTTP DELETE 操作
  • exchange() 在URL上执行特定的HTTP方法，返回包含对象的 ResponseEntity ，这个对象是从响应体中映射得到的
  • execute() 在URL上执行特定的HTTP方法，返回一个从响应体映射得到的对象
  • getForEntity() 发送一个 HTTP GET 请求，返回的 ResponseEntity 包含了响应体所映射成的对象
  • getForObject() 发送一个 HTTP GET 请求，返回的请求体将映射为一个对象
  • postForEntity() POST 数据到一个URL，返回包含一个对象的 ResponseEntity ，这个对象是从响应体中映射得到的
  • postForObject() POST 数据到一个URL，返回根据响应体匹配形成的对象
  • headForHeaders() 发送 HTTP HEAD 请求，返回包含特定资源URL的HTTP头
  • optionsForAllow() 发送 HTTP OPTIONS 请求，返回对特定URL的Allow头信息
  • postForLocation() POST 数据到一个URL，返回新创建资源的URL
  • put() PUT 资源到特定的URL
 

首先导入springboot的web包
 

 

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>.0.4.RELEASE</version>
</parent>
<dependencies>
<!--CloseableHttpClient-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>.5.2</version>
</dependency>
<!--spring restTemplate-->
<!-- @ConfigurationProperties annotation processing (metadata for IDEs)
生成spring-configuration-metadata.json类，需要引入此类-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
 

在启动类同包下创建 RestTemplateConfig.java 类
 

 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
/**
* @author riemann
*/@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory){
return new RestTemplate(factory);
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout();
factory.setReadTimeout();
return factory;
}
}
 

然后在Service类（ RestTemplateToInterface ）中注入使用
 

具体代码如下：
 

 

import com.alibaba.fastjson.JSONObject;
import com.swordfall.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
/**
* @author riemann
*/@Service
public class RestTemplateToInterface {
@Autowired
private RestTemplate restTemplate;
/**
* 以get方式请求第三方http接口 getForEntity
* @param url
* @return
*/ public User doGetWith(String url){
ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class);
User user = responseEntity.getBody();
return user;
}
/**
* 以get方式请求第三方http接口 getForObject
* 返回值返回的是响应体，省去了我们再去getBody()
* @param url
* @return
*/ public User doGetWith(String url){
User user = restTemplate.getForObject(url, User.class);
return user;
}
/**
* 以post方式请求第三方http接口 postForEntity
* @param url
* @return
*/ public String doPostWith(String url){
User user = new User("小白",);
ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, user, String.class);
String body = responseEntity.getBody();
return body;
}
/**
* 以post方式请求第三方http接口 postForEntity
* @param url
* @return
*/ public String doPostWith(String url){
User user = new User("小白",);
String body = restTemplate.postForObject(url, user, String.class);
return body;
}
/**
* exchange
* @return
*/ public String doExchange(String url, Integer age, String name){
//header参数
HttpHeaders headers = new HttpHeaders();
String token = "asdfaf";
headers.add("authorization", token);
headers.setContentType(MediaType.APPLICATION_JSON);
//放入body中的json参数
JSONObject obj = new JSONObject();
obj.put("age", age);
obj.put("name", name);
//组装
HttpEntity<JSONObject> request = new HttpEntity<>(obj, headers);
ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, request, String.class);
String body = responseEntity.getBody();
return body;
}
}
 

2.5 通过okhttp
 

应大家的响应，okhttp 现在也是蛮流行的，基于手机端很火，这里分享一下 OkHttpClient 客户端，业务代码get、post请求直接调用就好哈。
 

pom文件引入依赖包
 

 

<dependency>
<groupId>com.squareup.okhttp</groupId>
<artifactId>okhttp</artifactId>
<version>.10.0</version>
</dependency>
@Slfj
public class OkHttpClient {
private static final MediaType JSON = MediaType.parse("application/json; charset=utf-");
private volatile static okhttp.OkHttpClient client;
private static final int MAX_IDLE_CONNECTION = Integer
.parseInt(ConfigManager.get("httpclient.max_idle_connection"));
private static final long KEEP_ALIVE_DURATION = Long
.parseLong(ConfigManager.get("httpclient.keep_alive_duration"));
private static final long CONNECT_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient.connectTimeout"));
private static final long READ_TIMEOUT = Long.parseLong(ConfigManager.get("httpclient. "));
/**
* 单例模式(双重检查模式) 获取类实例
*
* @return client
*/ private static okhttp.OkHttpClient getInstance() {
if (client == null) {
synchronized (okhttp.OkHttpClient.class) {
if (client == null) {
client = new okhttp.OkHttpClient.Builder()
.connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
.readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
.connectionPool(new ConnectionPool(MAX_IDLE_CONNECTION, KEEP_ALIVE_DURATION,
TimeUnit.MINUTES))
.build();
}
}
}
return client;
}
public static String syncPost(String url, String json) throws IOException {
RequestBody body = RequestBody.create(JSON, json);
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
try {
Response response = OkHttpClient.getInstance().newCall(request).execute();
if (response.isSuccessful()) {
String result = response.body().string();
log.info("syncPost response = {}, responseBody= {}", response, result);
return result;
}
String result = response.body().string();
log.info("syncPost response = {}, responseBody= {}", response, result);
throw new IOException("三方接口返回http状态码为" + response.code());
} catch (Exception e) {
log.error("syncPost() url:{} have a ecxeption {}", url, e);
throw new RuntimeException("syncPost() have a ecxeption {}" + e.getMessage());
}
}
public static String syncGet(String url, Map<String, Object> headParamsMap) throws IOException {
Request request;
final Request.Builder builder = new Request.Builder().url(url);
try {
if (!CollectionUtils.isEmpty(headParamsMap)) {
final Iterator<Map.Entry<String, Object>> iterator = headParamsMap.entrySet()
.iterator();
while (iterator.hasNext()) {
final Map.Entry<String, Object> entry = iterator.next();
builder.addHeader(entry.getKey(), (String) entry.getValue());
}
}
request = builder.build();
Response response = OkHttpClient.getInstance().newCall(request).execute();
String result = response.body().string();
log.info("syncGet response = {},responseBody= {}", response, result);
if (!response.isSuccessful()) {
throw new IOException("三方接口返回http状态码为" + response.code());
}
return result;
} catch (Exception e) {
log.error("remote interface url:{} have a ecxeption {}", url, e);
throw new RuntimeException("三方接口返回异常");
}
}
}
 

2.5使用hutool工具进行http接口调用
 

hutool简单介绍
 

关于hutool工具包其实本人使用的不多哈 ，这里面其实封装处理了大量的开发日常小工具方法：
 

  •  
    时间格式化，时间转换，时间校验
     
  •  
    http 接口调用
     
  •  
    字符串格式化处理
     
  •  
    国标加密....
     
 

对于一个稍微大型的项目来说是一个很好用的封装工具包('宝藏男孩'),更多的好东西需要大家去探索
 

实践
 

这里说明一下hutool封装了httpclient 也是能使用的但是它高度封装了，所以我使用的是
 

 
1
 		 
HttpRequest
 
 

灵活性更高！！！
 

引用依赖
 

 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 		 
<!-- hutool 工具包 -->
 
<dependency>
 
    <groupId>cn.hutool</groupId>
 
    <artifactId>hutool-all</artifactId>
 
    <version>5.7.7</version>
 
</dependency>
 
<!--       测试类-->
 
<dependency>
 
    <groupId>junit</groupId>
 
    <artifactId>junit</artifactId>
 
</dependency>
 
 

post
 

简单接口调用
 

 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
25
 
26
 		 
@Test
 
public void huToolPost() {
 
    System.out.println("--------------------------------post请求-----------------------------------");
 
    HashMap<String, String> paramMaps = new HashMap<>(4);
 
    paramMaps.put("pid", "463669875660294144");
 
    paramMaps.put("mobile", "123456.");
 
    paramMaps.put("name", "123456.");
 
    paramMaps.put("message", "");
 
    HttpResponse response = HttpRequest.post("http://192.168.99.202:8202/thySystem/pg-biz-sae/app/opinion/add")
 
            .header("Content-Type", "application/json")
 
            .header("token", "710515329923024896")
 
            .header("kong-request-id", "710515329923024896")
 
            .body(JSON.toJSONString(paramMaps))
 
            .execute();
 
 
    int status = response.getStatus();
 
    System.out.println("请求响应状态码:" + status);
 
    String body = response.body();
 
    System.out.println(body);
 
    JSONObject jsonObject = JSONObject.parseObject(body);
 
    Object msg = jsonObject.get("msg");
 
    System.out.println(msg);
 
    Object code = jsonObject.get("code");
 
    System.out.println(code);
 
 
}
 
 

文件上传
 

 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 		 
/**
 
 * 文件上传测试
 
 */
 
@Test
 
public void huToolUploadFile(){
 
    File f1 = new File("C:\Users\12043\Desktop\cat.jpeg");
 
    File f2 = new File("C:\Users\12043\Desktop\cat.jpeg");
 
    File[] files = new File[2];
 
    files[0] = f1;
 
    files[1] = f2;
 
    HttpResponse response = HttpRequest.post("url")
 
            .form("param", "test")
 
            .form("key", files)
 
            .execute();
 
}
 
 

get 请求
 

 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 		 
@Test
 
public void huToolGet(){
 
    System.out.println("--------------------------------get请求-----------------------------------");
 
    HashMap<String, Object> getParamMaps = new HashMap<>(5);
 
    getParamMaps.put("sortStr", "recordFlag,baseInfo.createTime");
 
    getParamMaps.put("sortDirection", "ASC");
 
    getParamMaps.put("filterStr", "flowAbleInfo.nodeId==craCheck");
 
    getParamMaps.put("pageSize", 10);
 
    getParamMaps.put("pageNo", 0);
 
    HttpResponse getResponse = HttpRequest.get("http://192.168.99.202:8202/thySystem/pg-biz-sae/sae/list")
 
            .header("Content-Type", "application/json")
 
            .header("token", "710515329923024896")
 
            .header("kong-request-id", "710515329923024896").form(getParamMaps).execute();
 
 
    int status1 = getResponse.getStatus();
 
    System.out.println("请求响应状态码:" + status1);
 
    String body1 = getResponse.body();
 
    System.out.println(body1);
 
    JSONObject jsonObject1 = JSONObject.parseObject(body1);
 
    Object msg1 = jsonObject1.get("msg");
 
    System.out.println(msg1);
 
    Object code1 = jsonObject1.get("code");
 
    System.out.println(code1);
 
}
 
 

 

                

        

    

  



    



                



	

		

			

				
					
java中http调用组件深入详解

				
			

			

				

					congge
				

				

					04-27
					
					8342
					
				

			

		

		

			
				
java中http调用组件深入详解

			
		

	



                

            
              



	

		

			

				
					
Java调用外部REST请求的几种方式

				
			

			

				

					zaihukeji的博客
				

				

					08-19
					
					1905
					
				

			

		

		

			
				
1 restTemplate — spring 提供

特点：

1、RestOperations 提供了各种封装方法，非常方便直接将返回转成实体类。

2、默认使用JDK 的HttpURLConnection进行通信，但是可以通过RestTemplate.setRequestFactory 切换到不同的HTTP源：如Apache HttpComponents、Netty、OkHttp。

3、支持同步、异步请求；

4、支持更多的定制，比如拦截器等。

ps：支持 get 请求，参数是 body 的形式。

			
		

	



              


  
              

                


	

		

			

				
					
java通过HTTP调用接口（Get请求和Post请求）

				
			

			

				

					09-18
				

			

		

		

			
				
java通过HTTP调用接口（Get请求和Post请求）

			
		

	





	

		

			

				
					
Java JDK 17 自带的 java.net.http.HttpClient入门案例

					
最新发布

				
			

			

				

					llg3189609554的博客
				

				

					04-17
					
					576
					
				

			

		

		

			
				
Java JDK 17 自带的 java.net.http.HttpClient是 JDK 11 引入的 HTTP 客户端 API 的增强版本，提供了轻量级、现代且符合标准的 HTTP 请求能力。

			
		

	



		

			
		



	

		

			

				
					
Java调用http接口的几种方式（HttpURLConnection、OKHttp、HttpClient、RestTemplate）

				
			

			

				

					doubiy的博客
				

				

					04-14
					
					5601
					
				

			

		

		

			
				
Java作为后端语言是开发接口实现功能供客户端调用接口，这些客户端中最主要是本项目的前端；但有时候也需要Java请求其他的接口，比如需要长连接转短链接（请求百度的一个接口可以实现）、获取三方OSS签名、微信小程序签名、甚至是本公司其他团队项目的接口等等都需要Java调用其他的接口，这时候就需要用Java发起相应的请求，这里以发起http请求为例介绍几种方式。本文示例涉及的service（被调用方）和client（调用方）的接口代码如下（均以spring boot搭建的项目）：代码：
文件上传参数类：
配置信

			
		

	





	

		

			

				
					
Java 调用 HTTP 接口的 7 种方式：全网最全指南

				
			

			

				

					print_helloword的博客
				

				

					11-26
					
					4078
					
				

			

		

		

			
				
在开发过程中，调用 HTTP 接口是最常见的需求之一。本文将详细介绍 Java 中 7 种主流的调用 HTTP 接口的方式，包括每种工具的优缺点和完整代码实现。 是 Spring 提供的同步 HTTP 客户端，适用于传统项目。尽管从 Spring 5 开始被标记为过时，它仍然是许多开发者的首选。
优缺点

优点： 简单易用，适合快速开发。
缺点： 已过时，不推荐用于新项目。


2. 使用 WebClient
 是 Spring 5 引入的现代化 HTTP 客户端，支持同步和异步调用。
优缺点

优点： 支

			
		

	





	

		

			

				
					
java 模仿http请求_Java模仿http请求工具类

				
			

			

				

					weixin_39908070的博客
				

				

					02-13
					
					347
					
				

			

		

		

			
				
packageln;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.PrintWriter;importjava.util.HashMap;importjava.util.List;importjava.util.Map;/*** 用于模拟HTT...

			
		

	





	

		

			

				
					
java自定义拦截所有请求_Java实现拦截HTTP请求的几种方式

				
			

			

				

					weixin_35681614的博客
				

				

					02-25
					
					5223
					
				

			

		

		

			
				
在Java的服务端开发当中，拦截器是很常见的业务场景，这里对Java开发当中几种常见的拦截器的实现方式进行记录和分析。案例说明基于Spring Boot环境。一：实现javax.servlet.Filter接口(使用过滤器方式拦截请求)import org.springframework.stereotype.Component;import javax.servlet.*;import java...

			
		

	





	

		

			

				
					
Java 调用Restful API接口的几种方式(HTTPS)

				
			

			

				

					08-28
				

			

		

		

			
				
在本文中，我们将介绍 Java 调用 Restful API 接口的几种方式，包括使用 HttpClient、OkHttp 和 Unirest 等常见的方法。  使用 HttpClient 调用 Restful API 接口  HttpClient 是 Apache 的一个开源项目，提供了一个...

			
		

	





	

		

			

				
					
java WebService调用的几种方式详细源代码

				
			

			

				

					11-24
				

			

		

		

			
				
本篇文章将详细介绍Java中调用WebService的几种常见方法，并提供相应的源代码示例。  1. **SOAP（Simple Object Access Protocol）调用**：  SOAP是WebService的主要通信协议，基于XML格式的数据交换。在Java中，...

			
		

	





	

		

			

				
					
JAVA读取HTTP请求

				
			

			

				

					03-29
				

			

		

		

			
				
JAVA读取HTTP请求

			
		

	





	

		

			

				
					
JAVA 调用HTTP接口POST或GET实现方式

				
			

			

				

					01-22
				

			

		

		

			
				
JAVA 调用HTTP接口POST或GET实现方式，java通用

			
		

	





	

		

			

				
					
JAVA发送http get/post请求，调用http接口、方法详解

				
			

			

				

					08-26
				

			

		

		

			
				
主要介绍了Java发送http get/post请求调用接口/方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

			
		

	





	

		

			

				
					
java调用http请求方式

				
			

			

				

					m0_60725291的博客
				

				

					07-03
					
					820
					
				

			

		

		

			
				
URLConnection、HttpURLConnection、HttpClient、OkHttp、ResetTemplate

			
		

	





	

		

			

				
					
Java调用HTTP接口

				
			

			

				

					pk5201314pk的博客
				

				

					07-20
					
					2505
					
				

			

		

		

			
				
Java调用HTTP接口可以使用Java的HttpURLConnection或HttpClient等工具。

			
		

	





	

		

			

				
					
java  http请求工具类

				
			

			

				

					shiyuezhong的专栏
				

				

					11-21
					
					1391
					
				

			

		

		

			
				
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.List

			
		

	





	

		

			

				
					
java程序调用http请求

				
			

			

				

					small__snail__5的博客
				

				

					03-21
					
					448
					
				

			

		

		

			
				
在开发过程中，需要去文件服务器下载歌词文件，将歌词文件流读出并给前端展示，这里做个笔记：


@RequestMapping(value = "/httpString")
    @ResponseBody
    public JSONObject httpString(AccompanyExam accompanyExam) throws Exception{
        JSONObje...

			
		

	





	

		

			

				
					
【java学习】HTTP接口调用：Httpclient、Okhttp、HttpURLConnection、RestTemplate 和 Feign

				
			

			

				

					午后阳光
				

				

					08-26
					
					5571
					
				

			

		

		

			
				
HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 Http 协议的客户端编程工具包，并且它支持 HTTP 协议最新版本和建议。HttpClient 相比传统 JDK 自带的 URLConnection，提升了易用性和灵活性，使客户端发送 HTTP 请求变得容易，提高了开发的效率。首先，对于服务提供者，不需要进行任何配置，feign的访问对于服务提供者其实就是一次http访问。代表一次请求的范围，一般用于请求转发的多个资源中共享数据。

			
		

	





	

		

			

				
					
java远程调用接口http

				
			

			

				

					01-05
				

			

		

		

			
				
### Java中的HTTP远程接口调用

在Java中执行HTTP远程接口调用可以通过多种方式完成，其中最常用的是使用`HttpURLConnection`类或第三方库如Apache HttpClient和OkHttp。下面介绍基于标准库的方式。

#### 使用HttpURLConnection发送GET请求

```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpGetExample {
    private static final String USER_AGENT = "Mozilla/5.0";

    public static void main(String[] args) throws Exception {
        URL url = new URL("http://www.example.com");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("User-Agent", USER_AGENT);

        int responseCode = conn.getResponseCode();
        System.out.println("Response Code : " + responseCode);

        BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        // 打印结果
        System.out.println(response.toString());
    }
}
```

此代码片段展示了如何通过设置URL并打开连接来发起简单的GET请求[^1]。

#### 发送POST请求携带JSON数据

对于更复杂的场景比如提交表单或者传递JSON对象，则可以采用POST方法：

```java
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpPostExample {

    private final String USER_AGENT = "Mozilla/5.0";
    
    public static void sendPost() throws Exception {
        
        String url = "https://selfsolve.apple.com/wcResults.do";
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
  
        // 设置基本属性
        con.setRequestMethod("POST");
        con.setRequestProperty("User-Agent", USER_AGENT);
        con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");

        // 添加请求头
        con.setDoOutput(true);
        String urlParameters = "sn=C02G8416DRJM&cn=&locale=&caller=&num=12345";

        try(OutputStream os = con.getOutputStream()){
            byte[] input = urlParameters.getBytes("utf-8");
            os.write(input, 0, input.length);           
        }

        int responseCode = con.getResponseCode();
        System.out.println("POST Response Code :: " + responseCode);

        if (responseCode == HttpURLConnection.HTTP_OK) { //success
            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            // 输出响应内容
            System.out.println(response.toString());
        } else {
            System.out.println("POST request not worked");
        }
    }
}
```

这段代码说明了怎样构建带有参数的POST请求，并处理服务器返回的数据[^2]。

为了简化开发过程以及提高效率，在实际项目里推荐使用成熟的客户端框架来进行网络通信操作，例如Spring RestTemplate或是Feign等工具，它们提供了更加简洁易读的API设计模式和支持异步非阻塞特性等功能增强。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值