备案控制台
开发者社区 开发与运维 文章 正文

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

2023-02-21 276
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： okhttp是专注于提升网络连接效率的http客户端。优点：1、它能实现同一ip和端口的请求重用一个socket，这种方式能大大降低网络连接的时间，和每次请求都建立socket，再断开socket的方式相比，降低了服务器服务器的压力。2、okhttp 对http和https都有良好的支持。3、okhttp 不用担心android版本变换的困扰。4、成熟的网络请求解决方案，比HttpURLConnection更好用。5、支持异步发送网络请求，响应可在线程处理。

一、为什么要用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);
  }
}


文章标签：
Android开发
Apache
API
数据格式
JSON
关键词：
网络下载
网络请求
网络工具类
网络get post请求
网络get请求
凌波漫步&amp;
目录
相关文章
未名编程
|
16天前
|
Python
【干货】Python下载网络小说
【干货】Python下载网络小说
未名编程
15 2
笨笨小乌龟
|
1天前
|
Linux Shell 网络性能优化
Wondershaper网络限制脚本源码分析一（下载速度限制篇）
Wondershaper 是一个简单的 Linux 命令行工具，用于自动管理和控制网络接口的上行和下行带宽，旨在为用户提供稳定的网络体验，尤其是在网络拥塞的情况下。它通过 Traffic Control (tc) 工具集实现这一功能，但与直接使用 tc 相比，Wondersbaper 提供了更简洁易用的界面，特别适合没有深入网络管理知识的用户，但它其实就是由一个bash脚本组成，当然里面的思想非常精华。
笨笨小乌龟
7 0
攒了一袋星辰
|
28天前
网络编程中的互联网协议 , IP地址 , 域名 , 端口 , 架构 , 网页数据请求 , 响应码
网络编程中的互联网协议 , IP地址 , 域名 , 端口 , 架构 , 网页数据请求 , 响应码
攒了一袋星辰
18 1
花开富贵111
|
7天前
|
文字识别 开发工具 Android开发
视觉智能开放平台操作报错合集之使用人脸属性检测接口，出现报错：图片无法下载，请检查链接是否可访问和本地网络情况，该如何解决
在使用视觉智能开放平台时，可能会遇到各种错误和问题。虽然具体的错误代码和消息会因平台而异，但以下是一些常见错误类型及其可能的原因和解决策略的概述，包括但不限于：1. 认证错误、2. 请求参数错误、3. 资源超限、4. 图像质量问题、5. 服务不可用、6. 模型不支持的场景、7. 网络连接问题，这有助于快速定位和解决问题。
花开富贵111
21 0
hnrk7epeorhrk
|
8天前
|
数据采集 JSON 程序员
老程序员分享：Pythonrequests网络数据采集下载视频(ku6)
老程序员分享：Pythonrequests网络数据采集下载视频(ku6)
hnrk7epeorhrk
9 0
tao滔不绝
|
1月前
|
网络协议 前端开发 Java
网络原理 - HTTP / HTTPS(4)——构造http请求
网络原理 - HTTP / HTTPS(4)——构造http请求
tao滔不绝
17 1
tao滔不绝
|
1月前
|
存储 JSON 安全
网络原理 - HTTP / HTTPS(2)——http请求
网络原理 - HTTP / HTTPS(2)——http请求
tao滔不绝
22 1
tao滔不绝
|
1月前
|
前端开发 网络协议 JavaScript
网络原理 - HTTP / HTTPS(1)——http请求
网络原理 - HTTP / HTTPS(1)——http请求
tao滔不绝
15 0
妄北y
|
27天前
|
网络协议 算法 Linux
【嵌入式软件工程师面经】Linux网络编程Socket
【嵌入式软件工程师面经】Linux网络编程Socket
妄北y
43 1
joseph_
|
12天前
|
安全 物联网 Linux
学习Linux对网络安全的重要性
**学习Linux对网络安全至关重要：** 1. 开源操作系统广泛应用于服务器、网络设备，掌握Linux是安全专家必备技能。 2. Linux内置安全特性，如最小权限和防火墙，加上丰富的安全工具，提供强大保障。 3. 可定制性允许灵活配置，满足安全需求，开源社区提供持续更新和教育资源。 4. 学习Linux能提升攻防能力，用于系统加固和渗透测试，适应跨平台安全场景。 5. 随着云计算和物联网发展，Linux在网络安全中的角色日益关键。
joseph_
38 3

热门文章

最新文章

  • 1
    【网络连接】ping不通的常见原因+解决方案，如何在只能访问网关时诊断，并修复IP不通的问题
  • 2
    云计算与网络安全：保障信息安全的新挑战与应对策略
  • 3
    深入理解Docker自定义网络：构建高效的容器网络环境
  • 4
    SPSS大学生网络购物行为研究：因子分析、主成分、聚类、交叉表和卡方检验
  • 5
    R语言软件对房屋价格预测：回归、LASSO、决策树、随机森林、GBM、神经网络和SVM可视化|数据分享
  • 6
    使用Python实现卷积神经网络（CNN）
  • 7
    2023年河南省中等职业教育技能大赛网络建设与运维项目比赛试题（一）
  • 8
    某高校园区网络的规划与建设
  • 9
    2023 金砖国家职业技能大赛网络安全省赛理论题样题（金砖国家未来技能挑战赛）
  • 10
    SSH：加密安全访问网络的革命性协议
  • 1
    LabVIEWCompactRIO 开发指南15 托管和监控网络发布的共享变量
    34
  • 2
    网络入门基础
    16
  • 3
    【威胁情报挖掘-论文阅读】学习图表绘制 基于多实例学习的网络行为提取 SeqMask: Behavior Extraction Over Cyber Threat Intelligence
    32
  • 4
    【网络连接】ping不通的常见原因+解决方案，如何在只能访问网关时诊断，并修复IP不通的问题
    2420
  • 5
    LabVIEW中MAX在我的网络上不显示“远程系统”选项卡或设备
    20
  • 6
    LabVIEW网络服务安全2
    17
  • 7
    LabVIEW网络服务安全
    19
  • 8
    云端防御战线：云计算环境下的网络安全策略与实践
    23
  • 9
    LabVIEW NI网络设备在MAX中不显示或未识别
    45
  • 10
    云端之盾：融合云服务与网络安全的未来之路
    21

    • 相关课程

    更多
  • TCP/IP 网络基础
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》

    • 相关电子书

    更多
  • 可编程网络视角的网络创新研究
  • 可编程网络和SDN3.0
  • 开放促进创新：构建开放网络生态
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）