OkHttpUtils工具类（可上传文件）

已于 2023-04-19 14:34:34 修改
阅读量576 收藏 2
点赞数
分类专栏： java编码相关 文章标签： java
于 2022-06-13 17:15:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45040776/article/details/125263423
版权

声明：本文资源来自网上和博主的再加工，仅供自己学习、修改和分享，如有侵权，请告知，定会及时删除，谢谢。

文章目录

pom依赖

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

代码

import com.alibaba.fastjson.JSON;
import okhttp3.*;
import org.jetbrains.annotations.NotNull;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.File;
import java.io.IOException;
import java.net.URLEncoder;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @ Description okHttp3工具类
 * @ author ＸＸＸ
 * @ date 2021/12/6 17:33
 * @ version 1.0
 */
public class OkHttpUtils {

    private static volatile OkHttpClient okHttpClient = null;
    private static volatile Semaphore semaphore = null;
    private Map<String, String> headerMap;
    private Map<String, Object> paramMap;
    private Map<String, FileInfo> fileMap;
    private String url;
    private Request.Builder request;

    public static class FileInfo {
        private String fileName;
        private File file;

        public FileInfo(String fileName, File file) {
            this.fileName = fileName;
            this.file = file;
        }

        public String getFileName() {
            return fileName;
        }

        public File getFile() {
            return file;
        }
    }

    /**
     * 初始化okHttpClient，并且允许https访问
     */
    private OkHttpUtils() {
        if (okHttpClient == null) {
            synchronized (OkHttpUtils.class) {
                if (okHttpClient == null) {
                    TrustManager[] trustManagers = buildTrustManagers();
                    okHttpClient = new OkHttpClient.Builder()
                            .connectTimeout(15, TimeUnit.SECONDS)
                            .writeTimeout(20, TimeUnit.SECONDS)
                            .readTimeout(20, TimeUnit.SECONDS)
                            .sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager) trustManagers[0])
                            .hostnameVerifier((hostName, session) -> true)
                            .retryOnConnectionFailure(true)
                            .build();
                    addHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");
                }
            }
        }
    }

    /**
     * 用于异步请求时，控制访问线程数，返回结果
     *
     * @return Semaphore
     */
    private static Semaphore getSemaphoreInstance() {
        //只能1个线程同时访问
        synchronized (OkHttpUtils.class) {
            if (semaphore == null) {
                semaphore = new Semaphore(0);
            }
        }
        return semaphore;
    }

    /**
     * 创建OkHttpUtils
     *
     * @return OkHttpUtils
     */
    public static OkHttpUtils builder() {
        return new OkHttpUtils();
    }

    /**
     * 添加url
     *
     * @param url 请求路径
     * @return OkHttpUtils
     */
    public OkHttpUtils url(String url) {
        this.url = url;
        return this;
    }

    /**
     * 添加参数
     *
     * @param key   参数名
     * @param value 参数值
     * @return OkHttpUtils
     */
    public OkHttpUtils addParam(String key, Object value) {
        if (paramMap == null) {
            paramMap = new LinkedHashMap<>(16);
        }
        paramMap.put(key, value);
        return this;
    }

    /**
     * 添加请求头
     *
     * @param key   参数名
     * @param value 参数值
     * @return OkHttpUtils
     */
    public OkHttpUtils addHeader(String key, String value) {
        if (headerMap == null) {
            headerMap = new LinkedHashMap<>(16);
        }
        headerMap.put(key, value);
        return this;
    }

    /**
     * 初始化get方法
     *
     * @return OkHttpUtils
     */
    public OkHttpUtils get() {
        request = new Request.Builder().get();
        StringBuilder urlBuilder = new StringBuilder(url);
        if (paramMap != null) {
            urlBuilder.append("?");
            try {
                for (Map.Entry<String, Object> entry : paramMap.entrySet()) {
                    urlBuilder.append(URLEncoder.encode(entry.getKey(), "utf-8")).
                            append("=").
                            append(entry.getValue()).
                            append("&");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            urlBuilder.deleteCharAt(urlBuilder.length() - 1);
        }
        request.url(urlBuilder.toString());
        return this;
    }

    /**
     * 上传文件
     *
     * @param file     文件对象
     * @param fileName 文件名
     * @return OkHttpUtils
     */
    public OkHttpUtils addFile(String key, String fileName, File file) {
        if (fileMap == null) {
            fileMap = new LinkedHashMap<>(16);
        }
        fileMap.put(key, new FileInfo(fileName, file));
        return this;

    }

    /**
     * 初始化post方法
     *
     * @param isJsonPost true等于json的方式提交数据，类似postman里post方法的raw
     *                   false等于普通的表单提交
     * @return OkHttpUtils
     */
    public OkHttpUtils post(boolean isJsonPost) {
        RequestBody requestBody;
        if (isJsonPost) {
            String json = "";
            if (paramMap != null) {
                json = JSON.toJSONString(paramMap);
            }
            requestBody = RequestBody.Companion.create(json, MediaType.parse("application/json; charset=utf-8"));
        } else {
            if (fileMap != null) {
                MultipartBody.Builder multipartBody = new MultipartBody.Builder();
                multipartBody.setType(MultipartBody.FORM);
                fileMap.forEach((s, o) -> multipartBody.addFormDataPart(s, o.getFileName(), RequestBody.Companion.create(o.getFile(), MediaType.parse("multipart/form-data"))));
                if (paramMap != null) {
                    paramMap.forEach((s, o) -> multipartBody.addFormDataPart(s, o.toString()));
                }
                requestBody = multipartBody.build();
            } else {
                FormBody.Builder formBody = new FormBody.Builder();
                if (paramMap != null) {
                    paramMap.forEach((s, o) -> formBody.add(s, o.toString()));
                }
                requestBody = formBody.build();
            }
        }
        request = new Request.Builder().post(requestBody).url(url);
        return this;
    }


    /**
     * 初始化put方法
     */
    public OkHttpUtils put() {
        RequestBody requestBody;
        FormBody.Builder formBody = new FormBody.Builder();
        if (paramMap != null) {
            paramMap.forEach((s, o) -> formBody.add(s, o.toString()));
        }
        requestBody = formBody.build();
        request = new Request.Builder().put(requestBody).url(url);
        return this;
    }

    /**
     * 同步请求
     *
     * @return String
     */
    public String sync() {
        setHeader(request);
        try {
            Response response = okHttpClient.newCall(request.build()).execute();
            assert response.body() != null;
            return response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
            return "请求失败：" + e.getMessage();
        }
    }

    /**
     * 异步请求，有返回值
     *
     * @return String
     */
    public String async() {
        StringBuilder buffer = new StringBuilder("");
        setHeader(request);
        okHttpClient.newCall(request.build()).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                buffer.append("请求出错：").append(e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                assert response.body() != null;
                buffer.append(response.body().string());
                getSemaphoreInstance().release();
            }
        });
        try {
            getSemaphoreInstance().acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return buffer.toString();
    }

    /**
     * 异步请求，带有接口回调
     *
     * @param callBack 回调
     */
    public void async(ICallBack callBack) {
        setHeader(request);
        okHttpClient.newCall(request.build()).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                callBack.onFailure(call, e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                assert response.body() != null;
                callBack.onSuccessful(call, response.body().string());
            }
        });
    }

    /**
     * 为request添加请求头
     *
     * @param request 请求体
     */
    private void setHeader(Request.Builder request) {
        if (headerMap != null) {
            try {
                for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                    request.addHeader(entry.getKey(), entry.getValue());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 生成安全套接字工厂，用于https请求的证书跳过
     */
    private static SSLSocketFactory createSSLSocketFactory(TrustManager[] trustAllCerts) {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ssfFactory;
    }

    private static TrustManager[] buildTrustManagers() {
        return new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType) {
                    }

                    @Override
                    public void checkServerTrusted(X509Certificate[] chain, String authType) {
                    }

                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        return new X509Certificate[]{};
                    }
                }
        };
    }

    /**
     * 自定义一个接口回调
     */
    public interface ICallBack {

        void onSuccessful(Call call, String data);

        void onFailure(Call call, String errorMsg);

    }

    public static void main(String[] args) {
        // get请求，方法顺序按照这种方式，切记选择post/get一定要放在倒数第二，同步或者异步倒数第一，才会正确执行
        OkHttpUtils.builder().url("请求地址，http/https都可以")
                // 有参数的话添加参数，可多个
                .addParam("参数名", "参数值")
                .addParam("参数名", "参数值")
                // 也可以添加多个请求头
                .addHeader("Content-Type", "application/json; charset=utf-8")
                .get()
                // 可选择是同步请求还是异步请求
                //.async();
                .sync();

        // post请求，分为两种，一种是普通表单提交，一种是json提交
        OkHttpUtils.builder().url("请求地址，http/https都可以")
                // 有参数的话添加参数，可多个
                .addParam("参数名", "参数值")
                .addParam("参数名", "参数值")
                // 也可以添加多个请求头
                .addHeader("Content-Type", "application/json; charset=utf-8")
                // 可以添加文件
                .addFile("参数名", "文件名称", new File("文件"))
                // 如果是true的话，会类似于postman中post提交方式的raw，用json的方式提交，不是表单
                // 如果是false的话传统的表单提交
                .post(true)
                .sync();

        // 选择异步有两个方法，一个是带回调接口，一个是直接返回结果
        OkHttpUtils.builder().url("")
                .post(false)
                .async();

        OkHttpUtils.builder().url("").post(false).async(new OkHttpUtils.ICallBack() {
            @Override
            public void onSuccessful(Call call, String data) {
                // 请求成功后的处理
            }

            @Override
            public void onFailure(Call call, String errorMsg) {
                // 请求失败后的处理
            }
        });
    }
}

EOF

撕鲲巨猿章金莱
关注
专栏目录
okHttp工具类
zangduijian1898的博客
08-13 1889
OKhttp请求重试
OkHttp请求完美封装（并带工具类）
03-16
MD5、RSA、Base64Utils、DialogUtil、ZXingUtils、GlideUtil、、、工具类 自己总结了一些必备的工具类，可直接放入工程，简单调用 对OkHttp进行了封装，简单调用，便于操作 进行了post、get、文件上传等进行封装
Java封装OkHttp3工具类
qq_40812553的博客
05-31 998
Java封装OkHttp3工具类比HttpClient3和4都香废话少说直接上代码 废话少说直接上代码 //引入maven <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.10.0</version> </dependency> <depen
深入理解Okio、OkHttpUtils与OkHttp的集成与应用
最新发布
weixin_28850145的博客
09-03 881
本文还有配套的精品资源，点击获取 简介：Okio、OkHttpUtils和OkHttp是Android开发中的关键网络处理库，共同提供了一套高效的网络请求解决方案。OkHttp作为高效HTTP客户端，减少了延迟并提高了应用程序响应速度，支持HTTP/2和GZIP压缩等特性。Okio是一个低级I/O库，提供高效数据处理和流操作。OkHttpUtils简化了OkHttp的使用，...
JAVA——Okhttp封装工具类
无限迭代中......
09-27 3359
基本概念 OKhttp：一个处理网络请求的开源项目,是安卓端最火热的轻量级框架。 Maven <!--OK HTTP Client--> <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <versi.
OkHttpUtils工具类
06-29
OkHttpUtils工具类是对OkHttp3的进一步封装，它提供了一些便捷的方法来发起GET、POST等常见的HTTP请求，以及上传下载文件、处理Cookie等高级功能。例如，使用OkHttpUtils发起GET请求可能只需要一行代码，极大地简化...
okHttpUtils
10-06
7. **上传和下载**：OkHttpUtils还支持文件上传和下载操作，可以设置上传的文件路径、文件名以及下载的保存路径。 8. **拦截器支持**：OkHttpUtils允许添加自定义的Interceptor，实现请求前的预处理或者响应后的后...
OkHttpUtils
09-11
**OkHttpUtils** 是一个基于 **OkHttp** 库封装的简单工具类，它使得在Android应用中发起HTTP请求变得更加便捷。OkHttp是Square公司开发的一款高效、强大的网络请求库，广泛应用于Android开发中。本篇文章将深入探讨...
OkhttpUtils文件上传
徐代龙的技术专栏
09-12 1155
OkhttpUtils 可以进行单文件上传，也可以进行多文件上传操作。 单文件上传： if (NetUtils.isConnected(context)) { Map&amp;lt;String, String&amp;gt; headers = new HashMap&amp;lt;&amp;gt;(); headers.put(&quot;Content-Disposition&quot;,
okhttp3工具类
06-06
简单进行了二次封装，优化了部分功能，代码量大大减少
okHttp请求工具类
12-29
android网络框架之OKhttp[1] 一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso)[2] 用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient,现在已经打不出来)
okhttp3.0二次封装（独立的3个java文件封装的）
11-13
Androidstudio3.0.1下编译 Gradle gradle-4.4-all 最简单的okhttp封装，CallBack方法执行在UI线程。支持get请求，post请求，支持文件上传和下载。 使用方法： 代码很简单，只有三个Java文件，建议下载后将Java文件拷贝到工程中使用。 封装的功能有： 一般的get请求 一般的post请求 一般的put请求 一般的delete请求 上传单个文件(包含进度) 上传list集合文件 上传map集合文件 文件下载(包含进度) 图片下载(实现了图片的压缩)
okhttp3的封装
tiger_Angle
07-10 2800
https://github.com/hongyangAndroid/okhttputils 此处借鉴鸿洋大神分享的框架：https://github.com/hongyangAndroid/okhttputils 还有鸿洋大神的博客：https://blog.csdn.net/lmj623565791/article/details/47911083 使用前导入： implementation 'com.zhy:okhttputils:2.6.2' ​​​​​​Okhttp3封装_Snow_I.
Java FTP文件上传：实例解析及类定义
以下是一个简单的Java FTP文件上传工具类的示例： ```java package com.fz.common.util; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; import java.io....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值