当前位置：首页 > news >正文

java实现Http请求方式的几种常见方式

news 来源：原创 2025/5/18 21:35:34

背景

在实际开发过程中，我们经常需要调用对方提供的接口或测试自己写的接口是否合适。很多项目都会封装规定好本身项目的接口规范，所以大多数需要去调用对方提供的接口或第三方接口（短信、天气等）。若是普通java工程推荐使用OkHttpClient，若是spring工程推荐使用RestTemplate。，若是springcloud微服务可以用openFeign或Dubbo

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

1、通过JDK网络类Java.net.HttpURLConnection；

2、通过common封装好的HttpClient；

3、通过Apache封装好的CloseableHttpClient；

4、通过SpringBoot-RestTemplate；

5、通过Feign服务调用

一、Java调用第三方http接口几种方式总结

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、关闭连接

直接上代码：

import org.springframework.lang.Nullable;import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;public class HttpURLConnectionUtil {/*** Http get请求* @param httpUrl 连接* @return 响应数据*/public static String doGet(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(15000);//开始连接connection.connect();//获取响应数据if (connection.getResponseCode() == 200) {//获取返回的数据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(15000);//设置读取超时时间connection.setReadTimeout(15000);//DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个//设置是否可读取connection.setDoOutput(true);connection.setDoInput(true);//设置通用的请求属性connection.setRequestProperty("accept", "*/*");connection.setRequestProperty("connection", "Keep-Alive");connection.setRequestProperty("user-agent", "Mozilla/4.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.getOutputStream();//拼装参数os.write(param.getBytes("UTF-8"));}//设置权限//设置请求头等//开启连接//connection.connect();//读取响应if (connection.getResponseCode() == 200) {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("\r\n");}}}} 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("https://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=13026194071", "");System.out.println(message);}
}

运行结果：

2. 通过apache common封装好的HttpClient

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

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

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

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 allen* @Description TODO* @Date 2023-10-18 18:25* @Version 1.0*/
public class HttpClientUtil {/*** httpClient的get请求方式* 使用GetMethod来访问一个URL对应的网页实现步骤：* 1.生成一个HttpClient对象并设置相应的参数；* 2.生成一个GetMethod对象并设置响应的参数；* 3.用HttpClient生成的对象来执行GetMethod生成的Get方法；* 4.处理响应状态码；* 5.若响应正常，处理HTTP响应内容；* 6.释放连接。** @param url* @param charset* @return*/public static String doGet(String url, String charset) {//1.生成HttpClient对象并设置参数HttpClient httpClient = new HttpClient();//设置Http连接超时为5秒httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);//2.生成GetMethod对象并设置参数GetMethod getMethod = new GetMethod(url);//设置get请求超时为5秒getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);//设置请求重试处理，用的是默认的重试处理：请求三次getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());String response = "";//3.执行HTTP GET 请求try {int statusCode = httpClient.executeMethod(getMethod);//4.判断访问的状态码if (statusCode != HttpStatus.SC_OK) {System.err.println("请求出错：" + getMethod.getStatusLine());}//5.处理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 {//6.释放连接getMethod.releaseConnection();}return response;}/*** post请求** @param url* @param json* @return*/public static String doPost(String url, JSONObject 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");//必须设置下面这个HeaderpostMethod.addRequestHeader("User-Agent", "Mozilla/5.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 == 200) {res = postMethod.getResponseBodyAsString();System.out.println(res);}} catch (IOException e) {e.printStackTrace();}return res;}public static void main(String[] args) {System.out.println(doGet("http://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=13026194071", "GBK"));System.out.println("-----------分割线------------");System.out.println("-----------分割线------------");System.out.println("-----------分割线------------");JSONObject jsonObject = new JSONObject();jsonObject.put("commentId", "13026194071");System.out.println(doPost("http://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=13026194071", jsonObject));}
}

3. 通过Apache封装好的CloseableHttpClient

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

导入如下jar包：

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

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;/*** @Author allen* @Description TODO* @Date 2023-10-18 18:31* @Version 1.0*/
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/5.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/5.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-8");//发送json数据需要设置contentTypese.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("http://localhost/login");httpPost.addHeader("User-Agent", "Mozilla/5.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-8");//发送json数据需要设置contentTypese.setContentType("application/x-www-form-urlencoded");//设置请求参数httpPost.setEntity(se);HttpResponse response = httpClient.execute(httpPost);//这里可以把返回的结果按照自定义的返回数据结果，把string转换成自定义类//ResultTokenBO result = JSONObject.parseObject(response, ResultTokenBO.class);//把response转为jsonObjectJSONObject 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);//首先获取tokentokenString = getToken();String response = doPost("http://localhost/searchUrl", object);//如果返回的结果是list形式的，需要使用JSONObject.parseArray转换//List<Result> list = JSONObject.parseArray(response, Result.class);System.out.println(response);}public static void main(String[] args) {test("12345678910");}
}

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>2.0.4.RELEASE</version></parent><dependencies><!--CloseableHttpClient--><dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.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 java.io.IOException;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;import com.fasterxml.jackson.databind.ObjectMapper;/*** @Author allen* @Description TODO* @Date 2023-10-18 18:41* @Version 1.0*/
@Configuration
public class RestTemplateConfig {@Autowiredprivate ObjectMapper objectMapper;@Beanpublic RestTemplate restTemplate() {RestTemplate template = new RestTemplate();// 设置 http 超时时间HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory();// 获取链接超时时间httpRequestFactory.setConnectionRequestTimeout(6000);// 链接超时时间 6ShttpRequestFactory.setConnectTimeout(6000);// 读取超时 6ShttpRequestFactory.setReadTimeout(6000);template.setRequestFactory(httpRequestFactory);//		template.getInterceptors().add((request,body,execution) -> {
//			final RequestAttributes requestAttributes=RequestContextHolder.getRequestAttributes();
//			if(requestAttributes!=null&&requestAttributes instanceof ServletRequestAttributes){
//				final HttpServletRequest servletRequest = ((ServletRequestAttributes) requestAttributes).getRequest();
//				request.getHeaders().add("token", servletRequest.getHeader("token"));
//				request.getHeaders().add("location", servletRequest.getHeader("location"));
//				request.getHeaders().add("appId", servletRequest.getHeader("appId"));
//			}
//			return execution.execute(request, body);
//		});template.setErrorHandler(new ResponseErrorHandler() {@Overridepublic boolean hasError(ClientHttpResponse response) throws IOException {System.out.println("RestTemplateConfig------------------hasError");return response.getRawStatusCode() >= 400;}@Overridepublic void handleError(ClientHttpResponse response) throws IOException {System.out.println("RestTemplateConfig----------handleError--------异常");String result = objectMapper.readValue(response.getBody(), String.class);throw new RuntimeException(result);}});//        template.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));return template;}}

然后在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;@Service
public class RestTemplateToInterface {@Autowiredprivate RestTemplate restTemplate;/*** 以get方式请求第三方http接口 getForEntity* @param url* @return*/public User doGetWith1(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 doGetWith2(String url){User user  = restTemplate.getForObject(url, User.class);return user;}/*** 以post方式请求第三方http接口 postForEntity* @param url* @return*/public String doPostWith1(String url){User user = new User("小白", 20);ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, user, String.class);String body = responseEntity.getBody();return body;}/*** 以post方式请求第三方http接口 postForEntity* @param url* @return*/public String doPostWith2(String url){User user = new User("小白", 20);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 = "asdfaf2322";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;}
}

5 通过okhttp

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

pom文件引入依赖包

<dependency><groupId>com.squareup.okhttp3</groupId><artifactId>okhttp</artifactId><version>3.10.0</version>
</dependency>

@Slf4j
public class OkHttpClient {private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");private volatile static okhttp3.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 okhttp3.OkHttpClient getInstance() {if (client == null) {synchronized (okhttp3.OkHttpClient.class) {if (client == null) {client = new okhttp3.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("三方接口返回异常");}}}

https://blog.csdn.net/qq_16504067/article/details/121114404

6 通过openFeign

可以参考博主的这篇文章

Feign实战-Springboot集成OpenFeign Demo以及参数详解_Alex_81D的博客-CSDN博客

二、方案扩展

我用的这个：

HttpUtils如下：

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpDelete;
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.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.UnsupportedCharsetException;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;/*** Http tool class*/
public class HttpUtils {public static String INTERFACE_CALL_ERROR = "接口调用错误";private static Logger logger = LoggerUtil.getLogger();/*** "post" request to transfer "json" data** @param url* @param json* @param timeOutMS (Millisecond)* @return*/public static String doPostParmaMap(String url, Map<?, ?> json, Integer timeOutMS) {if (null == json) {return doPost(url, null, timeOutMS);}String formatJson = JsonUtils.toFormatJsonNoException(json);return doPost(url, formatJson, timeOutMS);}/*** "post" request to transfer "json" data** @param url* @param json* @param timeOutMS (Millisecond)* @return*/public static String doPost(String url, String json, Integer timeOutMS) {String result = "";// Create an "httpclient" objectCloseableHttpClient httpClient = null;// Create a "post" mode request objectHttpPost httpPost = null;try {// Create an "httpclient" objecthttpClient = HttpClients.createDefault();// Create a "post" mode request objecthttpPost = new HttpPost(url);logger.debug("afferent json param:" + json);// Set parameters to the request objectif (StringUtils.isNotBlank(json)) {StringEntity stringEntity = new StringEntity(json.toString(), ContentType.APPLICATION_JSON);stringEntity.setContentEncoding("utf-8");httpPost.setEntity(stringEntity);}httpPost.setProtocolVersion(HttpVersion.HTTP_1_1);if (null != timeOutMS) {// Set timeoutRequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(1000).setSocketTimeout(timeOutMS).build();httpPost.setConfig(requestConfig);}logger.info("call '" + url + "' start");// Perform the request operation and get the result (synchronous blocking)CloseableHttpResponse response = httpClient.execute(httpPost);logger.info("call succeeded,return msg:" + response.toString());// Get result entity// Determine whether the network connection status code is normal (0--200 are normal)switch (response.getStatusLine().getStatusCode()) {case HttpStatus.SC_OK:result = EntityUtils.toString(response.getEntity(), "utf-8");logger.info("call succeeded,return msg:" + result);break;case HttpStatus.SC_CREATED:result = EntityUtils.toString(response.getEntity(), "utf-8");logger.info("call succeeded,return msg:" + result);break;default:result = INTERFACE_CALL_ERROR + ":" + EntityUtils.toString(response.getEntity(), "utf-8");logger.warn("call failed,return msg:" + result);break;}} catch (UnsupportedCharsetException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":UnsupportedCharsetException");} catch (ClientProtocolException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ClientProtocolException");} catch (ParseException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ParseException");} catch (IOException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":IOException");} finally {// Close the connection and release the resourcehttpPost.releaseConnection();}return result;}/*** Get request to transfer data** @param url* @param map       Request incoming parameters ("key" is the parameter name, "value" is the parameter value) "map" can be empty* @param timeOutMS (Millisecond)* @return*/public static String doGet(String url, Map<String, String> map, Integer timeOutMS) {String result = "";if (StringUtils.isNotBlank(url)) {try {// Create an "httpclient" objectCloseableHttpClient httpClient = HttpClients.createDefault();// Create a "get" mode request objectHttpGet httpGet = null;// Determine whether to add parametersif (null != map && !map.isEmpty()) {// Since the parameters of the "GET" request are all assembled behind the "URL" address, we have to build a "URL" with parameters.URIBuilder uriBuilder = new URIBuilder(url);List<NameValuePair> list = new LinkedList<>();for (String key : map.keySet()) {BasicNameValuePair param = new BasicNameValuePair(key, map.get(key));list.add(param);}uriBuilder.setParameters(list);// Construct a "GET" request object from a "URI" object with parametershttpGet = new HttpGet(uriBuilder.build());} else {httpGet = new HttpGet(url);}// Add request header information// Browser representation// httpGet.addHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1;// en-US; rv:1.7.6)");// Type of transmission// httpGet.addHeader("Content-Type", "application/x-www-form-urlencoded");// Type of transmissionhttpGet.addHeader("Content-type", "application/json");if (null != timeOutMS) {// Set timeoutRequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(1000).setSocketTimeout(timeOutMS).build();httpGet.setConfig(requestConfig);}logger.info("call '" + url + "' start");// Get the response object by requesting the objectCloseableHttpResponse response = httpClient.execute(httpGet);//logger.info("call succeeded,return msg:" + response.toString());logger.info("call succeeded");// Get result entity// Determine whether the network connection status code is normal (0--200 are normal)switch (response.getStatusLine().getStatusCode()) {case HttpStatus.SC_OK:result = EntityUtils.toString(response.getEntity(), "utf-8");//logger.info("call succeeded,return msg:" + result);logger.info("call succeeded");break;case HttpStatus.SC_CREATED:result = EntityUtils.toString(response.getEntity(), "utf-8");logger.info("call succeeded,return msg:" + result);break;default:result = INTERFACE_CALL_ERROR + ":" + EntityUtils.toString(response.getEntity(), "utf-8");logger.warn("call failed,return msg:" + result);break;}// Release linkresponse.close();} catch (ClientProtocolException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ClientProtocolException");} catch (ParseException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ParseException");} catch (IOException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":IOException");} catch (URISyntaxException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":URISyntaxException");}}return result;}public static String getHtml(String urlStr) {// Define links to be accessedString url = urlStr;// Define a string to store web contentString result = "";// Define a buffered character input streamBufferedReader in = null;try {// Convert string to url objectURL realUrl = new URL(url);// Initialize a link to the "url" linkURLConnection connection = realUrl.openConnection();// Start the actual connectionconnection.connect();// Initialize the "BufferedReader" input stream to read the response of the "URL"in = new BufferedReader(new InputStreamReader(connection.getInputStream()));// Used to temporarily store data for each fetched rowString line;while ((line = in.readLine()) != null) {// Traverse each row that is fetched and store it in "result"result += line + "\n";}} catch (Exception e) {logger.error("send get request is abnormal!" + e);e.printStackTrace();} // Use "finally" to close the input streamfinally {try {if (in != null) {in.close();}} catch (Exception e2) {e2.printStackTrace();}}logger.debug("html info:" + result);return result;}/*** "post" request to transfer "json" data** @param url* @param timeOutMS (Millisecond)* @return*/public static String doDelete(String url, Integer timeOutMS) {String result = "";// Create an "httpclient" objectCloseableHttpClient httpClient = null;// Create a "post" mode request objectHttpDelete httpDelete = null;try {// Create an "httpclient" objecthttpClient = HttpClients.createDefault();// Create a "post" mode request objecthttpDelete = new HttpDelete(url);httpDelete.setProtocolVersion(HttpVersion.HTTP_1_1);if (null != timeOutMS) {// Set timeoutRequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(1000).setSocketTimeout(timeOutMS).build();httpDelete.setConfig(requestConfig);}logger.info("call '" + url + "' start");// Perform the request operation and get the result (synchronous blocking)CloseableHttpResponse response = httpClient.execute(httpDelete);logger.info("call succeeded,return msg:" + response.toString());// Get result entity// Determine whether the network connection status code is normal (0--200 are normal)switch (response.getStatusLine().getStatusCode()) {case HttpStatus.SC_OK:result = EntityUtils.toString(response.getEntity(), "utf-8");logger.info("call succeeded,return msg:" + result);break;case HttpStatus.SC_CREATED:result = EntityUtils.toString(response.getEntity(), "utf-8");logger.info("call succeeded,return msg:" + result);break;default:result = INTERFACE_CALL_ERROR + ":" + EntityUtils.toString(response.getEntity(), "utf-8");logger.warn("call failed,return msg:" + result);break;}} catch (UnsupportedCharsetException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":UnsupportedCharsetException");} catch (ClientProtocolException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ClientProtocolException");} catch (ParseException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":ParseException");} catch (IOException e) {logger.error(INTERFACE_CALL_ERROR, e);result = (INTERFACE_CALL_ERROR + ":IOException");} finally {// Close the connection and release the resourcehttpDelete.releaseConnection();}return result;}
}

JsonUtils.java

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;/*** Json utils*/
@SuppressWarnings("deprecation")
public class JsonUtils {private static final ObjectMapper objectMapper;private static Logger logger = LoggerUtil.getLogger();static {objectMapper = new ObjectMapper();// Remove the default timestamp formatobjectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);// Set to Shanghai time zone in ChinaobjectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);// Null value not serializedobjectMapper.setSerializationInclusion(Include.NON_NULL);// Compatible processing when attributes are not present during deserializationobjectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);// Uniform format of dates when serializingobjectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));// It is forbidden to deserialize "Enum" with "int" on behalf of "Enum"objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, true);objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);// objectMapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY,// true);objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);// Single quote processingobjectMapper.configure(com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);// objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);}public static <T> T toObjectNoException(String json, Class<T> clazz) {try {return objectMapper.readValue(json, clazz);} catch (JsonParseException e) {logger.error(e.getMessage(), e);} catch (JsonMappingException e) {logger.error(e.getMessage(), e);} catch (IOException e) {logger.error(e.getMessage(), e);}return null;}public static <T> String toJsonNoException(T entity) {try {return objectMapper.writeValueAsString(entity);} catch (JsonGenerationException e) {logger.error(e.getMessage(), e);} catch (JsonMappingException e) {logger.error(e.getMessage(), e);} catch (IOException e) {logger.error(e.getMessage(), e);}return null;}public static <T> String toFormatJsonNoException(T entity) {try {return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(entity);} catch (JsonGenerationException e) {logger.error(e.getMessage(), e);} catch (JsonMappingException e) {logger.error(e.getMessage(), e);} catch (IOException e) {logger.error(e.getMessage(), e);}return null;}public static <T> T toCollectionNoException(String json, TypeReference<T> typeReference) {try {return objectMapper.readValue(json, typeReference);} catch (JsonParseException e) {logger.error(e.getMessage(), e);} catch (JsonMappingException e) {logger.error(e.getMessage(), e);} catch (IOException e) {logger.error(e.getMessage(), e);}return null;}/*** Object to "json" string** @param object* @return* @throws JsonProcessingException*/public static String toString(Object object) throws JsonProcessingException {return objectMapper.writeValueAsString(object);}/*** "json" string to object** @param jsonString* @param rspValueType* @return* @throws JsonParseException* @throws JsonMappingException* @throws IOException*/public static <T> T toObject(String jsonString, Class<T> rspValueType)throws JsonParseException, JsonMappingException, IOException {return objectMapper.readValue(jsonString, rspValueType);}public static JsonNode readJsonNode(String jsonStr, String fieldName) {if (StringUtils.isEmpty(jsonStr)) {return null;}try {JsonNode root = objectMapper.readTree(jsonStr);return root.get(fieldName);} catch (IOException e) {logger.error("parse json string error:" + jsonStr, e);return null;}}@SuppressWarnings("unchecked")public static <T> T readJson(JsonNode node, Class<?> parametrized, Class<?>... parameterClasses) throws Exception {JavaType javaType = objectMapper.getTypeFactory().constructParametricType(parametrized, parameterClasses);return (T) objectMapper.readValue(toString(node), javaType);}/*** When converting "JSON" when using "Jackson", the date format setting "Jackson" two methods set the date format of the output* <p>* 1. Ordinary way: The default is to convert to "timestamps" form, you can cancel "timestamps" by the following way.* objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS,* false); This will cause the time generation to use the so-called use a [ISO-8601]-compliant notation, which outputs a time similar to the following:* "1970-01-01T00:00:00.000+0000". Of course, you can also customize the output format:* objectMapper.getSerializationConfig().setDateFormat(myDateFormat);* The myDateFormat object is java.text.DateFormat, which uses the annotation method of checking java API 2.annotaion:* First define the format you need as follows* <p>* Then find the date get method on your POJO** @JsonSerialize(using = CustomDateSerializer.class) public Date getCreateAt()* { return createAt; }* <p>* "java" date object converted to "JSON" date formatted custom class via "Jackson" library* @date 2010-5-3*/public class CustomDateSerializer extends JsonSerializer<Date> {@Overridepublic void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)throws IOException, JsonProcessingException {SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");String formattedDate = formatter.format(value);jgen.writeString(formattedDate);}}
}

调用示例：

post请求

String doPost = HttpUtils.doPost("url", formatJson,  5 * 1000); //5秒
JSONObject obj = JSONObject.fromObject(doPost).getJSONObject("test");

get请求

Map<String, String> map = new HashMap<>();
map.put("parms", parms);
String doGet = HttpUtils.doGet("url", map, 10 * 1000); //10秒
String jsonResult = JSONObject.fromObject(doGet).getString("test");
JSONObject obj = JSONObject.fromObject(jsonResult);

以前工具仅供参考！！

背景