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

最新推荐文章于 2024-04-14 21:21:36 发布
最新推荐文章于 2024-04-14 21:21:36 发布
阅读量2.4k 收藏 9
点赞数
文章标签： 中间件 java spring http 接口
原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247557758&idx=2&sn=67f5e83262059f490d04083f8223895f&chksm=fa4b9dcfcd3c14d9fa438bb04721aa52e8fe94e53312fdb2c4cef639b1a1cf7c02d0b570f896&scene=126&&sessionid=0
版权

点击上方“芋道源码”，选择“设为星标”

管她前浪，还是后浪？

能浪的浪，才是好浪！

每天 10:33 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：blog.csdn.net/qq_16504067/

article/details/121114404

05e7d9d7d8f55681712d776961174ce2.jpeg

一、概述

在实际开发过程中，我们经常需要调用对方提供的接口或者自己写的接口是否有接口。短信、天气等）。

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

  • 通过JDK网络类Java.net.HttpURLConnection；

  • 通过common封装好HttpClient；

  • 通过 Apache 封装好CloseableHttpClient；

  • 通过SpringBoot-RestTemplate；

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

二、Java调用http接口的方式

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

原始比较的一种调用方法，这里get请求和post请求都可以找到一个方法里面。

实现过程：

得到：

  1. 创建远程连接

  2. 设置连接方式（get、post、put。。。）

  3. 设置连接时间

  4. 设置响应读取时间

  5. 发起请求

  6. 获取请求数据

  7. 关闭连接

邮政：

  1. 创建远程连接

  2. 设置连接方式（get、post、put。。。）

  3. 设置连接时间

  4. 设置响应读取时间

  5. 当向远程服务器传送数据/写入数据时，需要设置为true（setDoOutput）

  6. 当前向远程服务读取数据时，设置为true，该参数可有可无（setDoInput）

  7. 设置参数格式的属性：（请求参数）

  8. 设置鉴权信息：授权：（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.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
 
/**
 * @author riemann
 */
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);
    }
}

运行结果：

38d078f05e54261d1b55f7cecce1e7a9.png
2.2 通过apache通用封装好的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>3.1</version>
</dependency>
 
<!--fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.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对应的网页实现步骤：
     * 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");
        //必须设置下面这个Header
        postMethod.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));
    }
}

运行结果：

0771dc24e25c2dd14d634a21f8d853b4.pngpost请求的jsonObject参数也成功写入

2.3 通过Apache封装好的CloseableHttpClient

CloseableHttpClient是在HttpClient的基础上修改可以更新而来的，这里还涉及到请求头的设置（请求），利用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>

代码如下：

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/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数据需要设置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("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数据需要设置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("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");
    }
}
2.4 通过SpringBoot-RestTemplate

springBoot-RestTemple是这些代码的集合的大成者，编写简单，目前可以采用的调用接口有：

  • delete() HTTP DELETE在特定操作的 URL 上对资源执行

  • exchange() 在URL上执行特定的HTTP方法，返回包含对象的ResponseEntity，这个对象是从请求体中映射到的

  • execute() 在上执行特定的HTTP方法，返回一个从响应体映射到的对象

  • get) 发送一个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 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(15000);
        factory.setReadTimeout(5000);
        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 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;
    }
}
2.5 通过okhttp

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

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("三方接口返回异常");
        }
    }
 
}

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

070802a12e28921c6166bbbe02483a38.png

已在知识星球更新源码解析如下：

184d6f7c4d9a1132656a26b02068ebf6.jpeg

f1eddecac249276b6eb376d3b2e22321.jpeg

c1186758e27c37361976de57b3cfe45d.jpeg

4a6c8d81db87c1c9fea43390fdbaa064.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
公众号-芋道源码
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
调用http请求（包括head头部的请求）
04-15
java后台请求http从而获取数据，这里支持头部参数，比如可以在头部加入orgCode、username、password等必填数据。可以达到postman请求效果
Java 调用Restful API接口的几种方式(HTTPS)
08-28
在本文中，我们将介绍 Java 调用 Restful API 接口的几种方式，包括使用 HttpClient、OkHttp 和 Unirest 等常见的方法。 使用 HttpClient 调用 Restful API 接口 HttpClient 是 Apache 的一个开源项目，提供了一个...
Java调用HTTP接口
pk5201314pk的博客
07-20 2203
Java调用HTTP接口可以使用Java的HttpURLConnection或HttpClient等工具。
使用Java调用http接口
weixin_42591908的博客
02-15 1649
使用Java调用HTTP接口的步骤如下： 创建一个URL对象，指定HTTP接口的地址。 打开URL连接，获取URLConnection对象。 设置URLConnection对象的请求方式、超时时间等参数。 发送请求，并获取服务器返回的响应结果。 处理响应结果，可以将响应结果转换成字符串或其他格式。 下面是一个简单的示例代码，演示如何使用Java调用HTTP接口： import java.net...
Java调用http接口的几种方式（HttpURLConnection、OKHttp、HttpClient、RestTemplate）
最新发布
doubiy的博客
04-14 1605
Java作为后端语言是开发接口实现功能供客户端调用接口，这些客户端中最主要是本项目的前端；但有时候也需要Java请求其他的接口，比如需要长连接转短链接（请求百度的一个接口可以实现）、获取三方OSS签名、微信小程序签名、甚至是本公司其他团队项目的接口等等都需要Java调用其他的接口，这时候就需要用Java发起相应的请求，这里以发起http请求为例介绍几种方式。本文示例涉及的service（被调用方）和client（调用方）的接口代码如下（均以spring boot搭建的项目）：代码： 文件上传参数类： 配置信
java实现http远程调用工具类
weixin_42070672的博客
12-27 524
【代码】java实现http远程调用工具类。
java调用http的几种方式
zhenjingcool的博客
08-10 81
参考：https://blog.csdn.net/qq_16504067/article/details/121114404 1 JDK自带API java核心jar包rt.jar包下为我们提供了java操作http的类。java.net包下面的抽象类HttpURLConnection为我们提供了发起http请求的途径和方法。其具体实现类同样在rt.jar包中，为sun.net.www.prot...
java获取http请求的Header和Body的简单方法
09-01
在Java Web开发中，处理HTTP请求是常见的任务之一。HTTP请求包含了两个主要部分：Header和Body，它们分别存储了请求的元数据和实际传输的数据。本文将详细介绍如何使用Java从HTTP请求中获取Header和Body。 首先，让...
servlet调用的几种方式
08-18
以下是Servlet调用的四种常见方式的详细说明： 1. **通过URL调用** 这是最基础的调用方式，用户在浏览器地址栏输入与Servlet映射的URL，如`http://localhost:8080/myservlet/hello`。服务器接收到请求后，根据`web...
详解Java实现负载均衡的几种算法代码
08-31
Java 实现负载均衡的几种算法主要是为了在分布式系统中有效地分发请求，提高系统的可用性和性能。本文将详细探讨两种常见的 Java 实现：轮询（Round Robin）和加权轮询（Weighted Round Robin）。 1. 轮询算法...
java 发送带Basic Auth认证的http post请求实例代码
09-01
总结起来，Java发送带Basic Auth认证的HTTP POST请求涉及以下几个步骤： 1. 构建认证头，使用Base64编码用户名和密码。 2. 创建HTTP客户端和POST请求对象。 3. 添加认证头到请求。 4. 设置请求体（如JSON数据）。 5....
java通过HTTP调用接口（Get请求和Post请求）
03-29
java调用HTTP接口（Get请求和Post请求）
如何在Java中创建一个简单的HTTP服务器
很酷的站长的博客
09-17 1548
在Java中创建一个简单的HTTP服务器可以通过利用Java内置的com.sun.net.httpserver.HttpServer类来完成。以下将会对此进行详细的介绍。
基于java的仿HTTP协议设计
qq_38474815的博客
08-13 227
Overview课程PJ, 模仿HTTP协议, 并Java Socket编程简单实现协议. 课程设计协议MyHTTP是一个简化版的HTTP协议, 是作为HTTP协议阅读后的一次总结和练手. 文档对Demo运用到的操作进行着重描述, 同时简单描述HTTP其他重要的操作. 本次项目做的Demo, 实现了一个支持HTTP 请求的服务端, 服务端保存了一份学生名单...
java模拟http调用_java里模拟http请求
weixin_33352628的博客
03-02 217
早准备写这个了，因为java里模拟http请求的场景太多了，经常写，每次都百度粘贴。一直想自己完完整整写一个http工具，很多东西又不太明白说不好，现在写接口采用postman，结合着用，以及以前写前端，利用浏览器控制台去调试，稍微对这一块有了一点点认识，现在去写这个，感觉稍微有点自然了。自己的准备工作 http://www.jianshu.com/p/a94ce2c0200bSpring Boo...
java调用第三方http请求接口
weixin_45314035的博客
05-12 598
java调用第三方http请求接口
Java中的HTTP POST请求详解
weixin_73725158的博客
02-28 3409
HTTP POST请求是HTTP协议中的另一种请求方法，通常用于向指定的资源提交数据，以创建或更新资源。与GET请求不同，POST请求会将请求数据包含在请求体中，而不是通过URL参数传递。此外，还有一些流行的第三方库，如Apache HttpClient和OkHttp，它们提供了更强大、更灵活的功能。然后，我们获取一个输出流，将请求数据写入该流，并关闭输出流。然后，我们将这个实体设置为POST请求的实体，并执行请求。接着，我们设置请求方法为"POST"，设置请求体的内容类型为。// 设置请求体内容类型。
java实现调用http请求的几种常见方式
qq_40091033的博客
08-13 285
java实现调用http请求的几种常见方式 Spring 的异步HTTP请求AsyncRestTemplate Spring Boot 之 AsyncRestTemplate 连接池配置 Feign
java自定义拦截所有请求_Java实现拦截HTTP请求的几种方式
05-23
Java实现拦截HTTP请求的几种方式： 1. 使用Servlet Filter拦截请求 可以使用Servlet Filter拦截HTTP请求，通过实现javax....以上是几种常见的Java实现拦截HTTP请求的方式，具体选择哪种方式需要根据实际情况来决定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值