基于OkHttp网络通信工具类(发送get、post请求、文件上传和下载)

最新推荐文章于 2024-07-26 11:10:37 发布
最新推荐文章于 2024-07-26 11:10:37 发布
阅读量1k 收藏 2
点赞数
文章标签： OkHttp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingbomanbu_lyl/article/details/81266437
版权

一、为什么要用OkHttp?


okhttp是专注于提升网络连接效率的http客户端。
优点：

1、它能实现同一ip和端口的请求重用一个socket，这种方式能大大降低网络连接的时间，和每次请求都建立socket，再断开socket的方式相比，降低了服务器服务器的压力。

2、okhttp 对http和https都有良好的支持。

3、okhttp 不用担心android版本变换的困扰。

4、成熟的网络请求解决方案，比HttpURLConnection更好用。
5、支持异步发送网络请求，响应可在线程处理。


二、其它的网络通信框架：


1、HttpURLConnection:java.util包下的http客户端，对网络请求的封装没有HttpClient那么彻底，api使用起来比较简单，易于扩展。
2、HttpClient:Apache的一个第三方网络框架，api众多，用起来比较方便，实现比较稳定，但不易于扩展。
3、Volley:google推出的网络通信框架，适合处理数据量小、通信频繁的网络操作，内部封装了异步线程，不适合大数据量的请求。


下面对OkHttp做了一个简单的封装，可用于发送get、post请求(支持请求参数格式为键值对、json格式)、文件上传、文件下载。

package com.universe.thirdparty.okhttp;

import java.io.IOException;
import java.nio.charset.Charset;
import java.time.Duration;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;

import com.alibaba.fastjson.JSONObject;
import com.universe.thirdparty.fastjson.CollectionUtils;

import okhttp3.FormBody;
import okhttp3.Headers;
import okhttp3.HttpUrl;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.OkHttpClient.Builder;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;

public class OkHttpUtils {

  public static final MediaType JSON = MediaType.get("application/json;charset=utf-8");
  public static final MediaType OCTET_STREAM = MediaType.get("application/octet-stream");
  /**
   * 超时、读、写时长
   */
  private static final long TIMEOUT_MILLIS = 2000;

  private static final Builder DEFAULT_CLIENT_BUILDER = new OkHttpClient.Builder();

  static {
    DEFAULT_CLIENT_BUILDER.readTimeout(Duration.ofMillis(TIMEOUT_MILLIS));
    DEFAULT_CLIENT_BUILDER.writeTimeout(Duration.ofMillis(TIMEOUT_MILLIS));
    DEFAULT_CLIENT_BUILDER.connectTimeout(Duration.ofMillis(TIMEOUT_MILLIS));
  }

  public static OkHttpClient getOkHttpClient() {
    return DEFAULT_CLIENT_BUILDER.build();
  }

  public static synchronized OkHttpClient getOkHttpClient(long timeoutInMillis) {
    DEFAULT_CLIENT_BUILDER.readTimeout(Duration.ofMillis(timeoutInMillis));
    DEFAULT_CLIENT_BUILDER.writeTimeout(Duration.ofMillis(timeoutInMillis));
    DEFAULT_CLIENT_BUILDER.connectTimeout(Duration.ofMillis(timeoutInMillis));
    return DEFAULT_CLIENT_BUILDER.build();
  }

  public static OkHttpResp sendGet(String url, Map<String, Object> reqHeaders, Map<String, Object> params) throws IOException {
    return sendGet(url, reqHeaders, params, TIMEOUT_MILLIS);
  }

  public static OkHttpResp sendGet(String url, Map<String, Object> reqHeaders, Map<String, Object> params, long timeoutInMillis)
      throws IOException {
    OkHttpClient client = getOkHttpClient(timeoutInMillis);
    HttpUrl.Builder urlBuilder = HttpUrl.get(url).newBuilder();
    // 拼接参数
    if (!CollectionUtils.isEmpty(params)) {
      params.forEach((key, value) -> {
        urlBuilder.addEncodedQueryParameter(key, String.valueOf(value));
      });
    }

    HttpUrl httpUrl = urlBuilder.build();
    Request.Builder reqBuilder = new Request.Builder().url(httpUrl);
    addHeaders(reqHeaders, reqBuilder);
    Request request = reqBuilder.get().build();

    return getResponse(client, request);
  }

  public static OkHttpResp sendPostInHtmlForm(String url, Map<String, Object> headers, Map<String, Object> params) throws IOException {
    return sendPostInHtmlForm(url, headers, params, TIMEOUT_MILLIS);
  }

  public static OkHttpResp sendPostInHtmlForm(String url, Map<String, Object> reqHeaders, Map<String, Object> params, long timeoutInMillis)
      throws IOException {
    OkHttpClient client = getOkHttpClient(timeoutInMillis);
    Request.Builder reqBuilder = new Request.Builder().url(url);
    addHeaders(reqHeaders, reqBuilder);

    FormBody.Builder formBuilder = new FormBody.Builder(Charset.forName("UTF-8"));
    FormBody formBody = formBuilder.build();

    if (!CollectionUtils.isEmpty(params)) {
      params.forEach((paramName, paramValue) -> {
        formBuilder.add(paramName, String.valueOf(paramValue));
      });
    }

    Request request = reqBuilder.post(formBody).build();
    return getResponse(client, request);
  }

  public static OkHttpResp sendPostInJsonFormat(String url, Map<String, Object> reqHeaders, Map<String, Object> params) throws IOException {
    return sendPostInJsonFormat(url, reqHeaders, params, TIMEOUT_MILLIS);
  }

  public static OkHttpResp sendPostInJsonFormat(String url, Map<String, Object> reqHeaders, Map<String, Object> params,
      long timeoutInMillis) throws IOException {
    OkHttpClient client = getOkHttpClient(timeoutInMillis);
    Request.Builder reqBuilder = new Request.Builder().url(url);
    addHeaders(reqHeaders, reqBuilder);

    RequestBody requestBody = RequestBody.create(JSON, JSONObject.toJSONString(params));
    Request request = reqBuilder.post(requestBody).build();

    return getResponse(client, request);
  }

  public static OkHttpResp uploadFile(String url, List<MultipartFile> files) throws IOException {
    return uploadFile(url, files, TIMEOUT_MILLIS);
  }

  public static OkHttpResp uploadFile(String url, List<MultipartFile> files, long timeoutInMillis) throws IOException {
    OkHttpClient client = getOkHttpClient(timeoutInMillis);
    MultipartBody.Builder multiBuilder = new MultipartBody.Builder();
    multiBuilder.setType(MultipartBody.FORM);
    if (!CollectionUtils.isEmpty(files)) {
      files.forEach(multipartFile -> {
        String fieldName = multipartFile.getFieldName();
        String fileName = multipartFile.getFileName();
        byte[] content = multipartFile.getContent();
        multiBuilder.addFormDataPart(fieldName, fileName, RequestBody.create(OCTET_STREAM, content));
      });
    }

    MultipartBody requestBody = multiBuilder.build();
    Request request = new Request.Builder().url(url).post(requestBody).build();
    return getResponse(client, request);
  }

  public static byte[] downloadFile(String url) throws IOException {
    return downloadFile(url, TIMEOUT_MILLIS);
  }

  public static byte[] downloadFile(String url, long timeoutInMillis) throws IOException {
    OkHttpClient client = getOkHttpClient(timeoutInMillis);
    Request request = new Request.Builder().url(url).get().build();
    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) {
        return null;
      }

      return response.body().bytes();
    } catch (IOException e) {
      throw e;
    }
  }

  private static OkHttpResp getResponse(OkHttpClient client, Request request) throws IOException {
    OkHttpResp resp = new OkHttpResp();
    // 确保Response和ResponseBody关闭
    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) {
        resp.setSuccessful(false);
      }
      ResponseBody body = response.body();
      resp.setSuccessful(true);
      resp.setRespStr(body.string());
      resp.setRespHeaders(response.headers());
      resp.setContentType(body.contentType());
      resp.setContentLength(body.contentLength());
      return resp;
    } catch (IOException e) {
      throw e;
    }
  }

  private static void addHeaders(Map<String, Object> reqHeaders, Request.Builder reqBuilder) {
    if (CollectionUtils.isEmpty(reqHeaders)) {
      return;
    }

    reqHeaders.forEach((headerName, headerValue) -> {
      reqBuilder.addHeader(headerName, String.valueOf(headerValue));
    });
  }

  public static class MultipartFile {

    /**
     * 文件域名，相当于表单中文件域名
     */
    private String fieldName;
    private String fileName;
    private byte[] content;

    public MultipartFile() {
    }

    public MultipartFile(String fieldName, String fileName, byte[] content) {
      this.fieldName = fieldName;
      this.fileName = fileName;
      this.content = content;
    }

    public String getFieldName() {
      return fieldName;
    }

    public void setFieldName(String fieldName) {
      this.fieldName = fieldName;
    }

    public String getFileName() {
      return fileName;
    }

    public void setFileName(String fileName) {
      this.fileName = fileName;
    }

    public byte[] getContent() {
      return content;
    }

    public void setContent(byte[] content) {
      this.content = content;
    }
  }

  public static class OkHttpResp {

    private String respStr;
    private Headers respHeaders;
    private MediaType contentType;
    private long contentLength;
    private boolean successful;

    public String getRespStr() {
      return respStr;
    }

    public Headers getRespHeaders() {
      return respHeaders;
    }

    public MediaType getContentType() {
      return contentType;
    }

    public long getContentLength() {
      return contentLength;
    }

    public boolean isSuccessful() {
      return successful;
    }

    public void setRespStr(String respStr) {
      this.respStr = respStr;
    }

    public void setRespHeaders(Headers respHeaders) {
      this.respHeaders = respHeaders;
    }

    public void setContentType(MediaType contentType) {
      this.contentType = contentType;
    }

    public void setContentLength(long contentLength) {
      this.contentLength = contentLength;
    }

    public void setSuccessful(boolean successful) {
      this.successful = successful;
    }

    @Override
    public String toString() {
      return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
    }

  }
}


对阿里FastJSONj进行JavaBean到json字符串映射的简单封装。

package com.universe.thirdparty.fastjson;

import java.util.List;
import java.util.Map;
import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;

public class JsonUtils {

  public static String toJsonString(Object obj, SerializeFilter... filters) {
    return toJsonString(obj, null, false, false, filters);
  }

  public static String toJsonStringWithNullValue(Object obj, SerializeFilter... filters) {
    return toJsonString(obj, null, true, false, filters);
  }

  public static String toPrettyJsonString(Object obj, SerializeFilter... filters) {
    return toJsonString(obj, null, false, true, filters);
  }

  public static String toPrettyJsonStringWithNullValue(Object obj, SerializeFilter... filters) {
    return toJsonString(obj, null, true, true, filters);
  }

  public static String toJsonStringWithDateFormat(Object obj, String dateFormat, SerializeFilter... filters) {
    return toJsonString(obj, dateFormat, false, false, filters);
  }

  public static String toJsonStringWithDateFormatAndNullValue(Object obj, String dateFormat, SerializeFilter... filters) {
    return toJsonString(obj, dateFormat, true, false, filters);
  }

  public static String toPrettyJsonStringWithDateFormat(Object obj, String dateFormat, SerializeFilter... filters) {
    return toJsonString(obj, dateFormat, false, true, filters);
  }

  public static String toPrettyJsonStringWithDateFormatAndNullValue(Object obj, String dateFormat, SerializeFilter... filters) {
    return toJsonString(obj, dateFormat, true, true, filters);
  }

  public static String toJsonString(Object obj, String dateFormat, boolean writeNullValue, boolean prettyFormat,
      SerializeFilter... filters) {
    if (obj == null) {
      return null;
    }

    int defaultFeature = JSON.DEFAULT_GENERATE_FEATURE;
    if (writeNullValue) {
      return prettyFormat
          ? JSON.toJSONString(obj, SerializeConfig.globalInstance, filters, dateFormat, defaultFeature, SerializerFeature.WriteMapNullValue,
              SerializerFeature.PrettyFormat)
          : JSON.toJSONString(obj, SerializeConfig.globalInstance, filters, dateFormat, defaultFeature,
              SerializerFeature.WriteMapNullValue);
    }

    return prettyFormat
        ? JSON.toJSONString(obj, SerializeConfig.globalInstance, filters, dateFormat, defaultFeature, SerializerFeature.PrettyFormat)
        : JSON.toJSONString(obj, SerializeConfig.globalInstance, filters, dateFormat, defaultFeature);

  }

  public static <T> T toJavaBean(String jsonStr, Class<T> clazz) {
    if (StringUtils.isBlank(jsonStr)) {
      return null;
    }

    return JSON.parseObject(jsonStr, clazz);
  }

  public static <T> List<T> toList(String jsonStr, Class<T> clazz) {
    if (StringUtils.isBlank(jsonStr)) {
      return null;
    }

    return JSON.parseArray(jsonStr, clazz);
  }

  public static Map<String, Object> toMap(String jsonStr) {
    if (StringUtils.isBlank(jsonStr)) {
      return null;
    }

    return JSON.parseObject(jsonStr, new TypeReference<Map<String, Object>>() {});
  }

  public static Map<String, Object> javaBeanToMap(Object obj) {
    if (Objects.isNull(obj)) {
      return null;
    }

    return toMap(toJsonString(obj));
  }

  public static <T> T mapToJavaBean(Map<String, ? extends Object> map, Class<T> clazz) {
    if (CollectionUtils.isEmpty(map)) {
      return null;
    }

    String jsonStr = JSON.toJSONString(map);
    return JSON.parseObject(jsonStr, clazz);
  }

}

 

Nick说说前后端
关注
Java工具类：封装Okhttp实现：Get、Post、上传/下载文件、Stream响应、代理ip
954L
04-17 657
1. 本文代码是引入Okhttp_v4.11.0，在这个基础上进行二次封装 2. 使调用方更加容易，只关注业务，而无需处理各种请求相关的重复性操作，类似文件类型请求体封装或者Form表单构造及body传参等一系列处理 3. 工具代码包括但不限于提供：Get、Post、上传/下载文件、Stream响应、代理ip等多种调用方式，以及后续可在类中按需扩展其他自定义方法
okHttp请求工具类
12-29
android网络框架之OKhttp[1] 一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso)[2] 用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient,现在已经打不出来)
http框架--基于OkHttp 4 封装的http请求工具类
penriver的博客
06-30 2195
1. 基本介绍 OkHttp算是最火的Http第三方库，Retrofit底层也是使用OkHttp 本文将OkHttp请求的相同代码进行封装，简化代码，便捷使用。 2. 源代码 2.1 使用示例 以第三方系统集成海豚调度系统为例，演示http请求工具类的使用 工具类支持http、https协议，以链式进行调用，使用起来非常便捷。 class OkHttpUtilsTest { public static void main(String[] args) { String res = "
使用OkHttp3以Multipart/Form-Data方式上传文件
最新发布
莫翊痕的博客
07-26 1657
ContentType，也称为媒体类型或MIME类型，用于描述网络请求和响应中的内容类型。text/plain：普通文本text/html：HTML文档：JSON数据：XML数据image/jpeg：JPEG图片image/png：PNG图片：用于文件上传本文主要关注，因为它通常用于表单提交，特别是包含文件上传的表单。
工具类 - HttpURLConnectionUtils（支持GET/POST/文件下载）
geaosu的博客
09-09 664
这里写自定义目录标题介绍使用源码 介绍 关于HttpURLConnectionUtils： HttpURLConnectionUtils是一个工具类，简单的封装了HttpURLConnection，使得HttpURLConnection发送get和post请求变得更简单，更便捷，链式调用，一气呵成，支持返回数据监听回调， 回调函数直接运行在主线程中，不用繁琐的线程切换，能做的都帮你做了。 关于studio输出日志： 该工具类在开发过程中，方便查看日志，getInstance方法的第二个参数就是一个t
oktttp3 工具类 支持get，post，https和模拟表单请求
tlimited的博客
02-09 821
本工具类有三个文件，支持get，post请求，还有模拟表单请求，支持https请求 需要用到的jar是 okhttp-3.8.0.jar okio-1.13.0.jar httpclient-4.5.1.jar httpcore-4.4.3.jar https配置类 package com.test.httpclient; import javax.net.ssl.*; imp...
okhttp3简单封装GET和POST请求工具类（https）
z69183787的专栏
02-12 5628
https://blog.csdn.net/fxjzzyo/article/details/78761373   简单封装了okhttp3的工具类以便于以后直接拿来使用。 使用的okhttp版本为： compile 'com.squareup.okhttp3:okhttp:3.8.1' 1 该工具类的功能如下： Get请求，同步方式获取网络数据 Post请求，同步方式获取数据 Get请求...
安卓GET与POST网络请求的三种方式
08-26
安卓GET与POST网络请求的三种方式 安卓GET与POST网络请求是移动应用程序中最常用的操作之一，今天我们将探讨安卓GET与POST网络请求的三种方式。网络请求是移动应用程序中最基本的操作，然而不同的请求方式对应用...
https的get和post请求，去除ssl校验的java工具类
12-04
java的get和post请求，获取json的工具类，https时会存在ssl校验的问题，工具会自动去除ssl校验。
http发送Get和Post请求工具类
10-30
本文将详细介绍一个封装了HTTP GET和POST请求的工具类，以及如何使用此类进行网络请求。该工具类支持HTTPS，确保数据传输的安全性。 首先，我们来看`HttpUtils`类，这是核心的网络请求工具类。在`HttpUtils`中，...
SpringBoot2.1.x，okhttp3网络请求之GET、POST请求
p812438109的专栏
08-10 5330
一）okhttp3简介 okhttp是一个高性能的http库，支持同步、异步请求，并且实现了spdy、http2、websocket协议，api比较简洁易用。 核心工具类： OkHttpClient：用于初始化http请求信息 Request：请求参数信息 Call：回调函数信息 RequestBody：请求报文信息 Response：请求响应信息 二）okhttp3案例 第一步：创建一个maven项目，引入springboot的jar、再引入okhttp3的jar &lt..
okhttp封装上传工具类
06-07
android okhttp封装工具类，实现多张上传图片，多参数上传
OkHttp请求完美封装（并带工具类）
03-16
MD5、RSA、Base64Utils、DialogUtil、ZXingUtils、GlideUtil、、、工具类 自己总结了一些必备的工具类，可直接放入工程，简单调用 对OkHttp进行了封装，简单调用，便于操作 进行了post、get、文件上传等进行封装
HttpUtils 用于进行网络请求的工具类
chinoukin的博客
10-17 1472
用于进行网络请求的工具类，可进行get，post两种请求，值得一提的是这个utils给大家提供了一个回调接口，方便获取下载文件的进度 import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.I
python批量请求（GET | POST）
anan的博客
11-25 8642
本案例为普通的测试案例，主要用于测试通过get请求和post请求产生响应是否一致，主要针对响应码为200的结果进行输出，没有什么技术含量！ #-*- coding:utf-8 -*- import requests def apiRequest(): header = { 'User-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.
python如何并发上千个get_Python+requests+splitter：发出多个并发“get”请求的最快/最佳方法是什么？...
weixin_35573869的博客
03-02 1004
在这种情况下，由于服务器似乎是一个限制因素，并发性并没有多大帮助。一种解决方案是发送带有超时间隔的请求，如果超过了该间隔，则在几秒钟后重试该请求。然后逐渐增加重试间隔时间，直到获得所需的数据。例如，您的代码可能如下所示：import timeimport requestsdef get_content(url, timeout):# raise Timeout exception if more ...
JupyterDash 项目教程
gitblog_00045的博客
05-28 355
JupyterDash 项目教程 jupyter-dash OBSOLETE - Dash v2.11+ has Jupyter support built in! 项目地址: https://gitcode.com/gh_mirrors/ju/jupyter-d...
OkHttp网络通信
da_xin的博客
04-02 318
1.创建OkHttpClient 对象2.创建Request 对象 发送http请求3.通过.xxx 给Request 对象连缀方法4.newCall 方法 发送请求 和获取服务器返回的数据/** * okHttp发送网络请求 */ public class MainActivity extends AppCompatActivity implements View.OnClickListen...
okHttp和HttpURLConnection下载文件
m0_37724690的博客
04-22 673
1、okHttp下载文件 JsonObject jsonObject = new JsonObject(); jsonObject.addProperty("fileName", getArguments().getString("fileName"));//文件名称 jsonObject.addProperty("filePath", getArguments().getStr...
okttp支持http和https get和post请求工具类
09-04
OkHttp是一个开源的网络请求工具类，它可以提供支持HTTP和HTTPS的GET和POST请求。 首先，OkHttp可以用来发送HTTP GET请求，GET请求是一种用来向服务器获取数据的请求方法。它可以通过OkHttp的GET方法来发送，该方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nick说说前后端

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值