安卓OkHttp项目级别使用

最新推荐文章于 2025-06-19 21:33:32 发布
原创 最新推荐文章于 2025-06-19 21:33:32 发布 · 327 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

该博客详细介绍了如何在安卓项目中使用OkHttp进行网络请求，包括底层的监听方法、请求方法的抽象实现、数据传输封装、Activity中如何调用请求任务以及对网络请求的处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 底层Okhttp请求方法Listener
public class OkhttpListener<T> {
    public static Handler mMainHandler = new Handler(Looper.getMainLooper());
    private Type mType;
    private AsyncTaskListener<T> mListener;
    
    public OkhttpListener(Type type, AsyncTaskListener<T> listener) {
        this.mListener = listener;
        this.mType = type;
        mListener.onStart();
    }
    public void onProgress(float progress, long total) {
    }
    public void onError(final Call call, final Exception e) {

        mMainHandler.post(new Runnable() {
            @Override
            public void run() 
                Log.e("Okhttp onError--->", "error");
                mListener.onFinish();
                e.printStackTrace();
            }
        });
    }
    public void onSeccess(Call call, final Response response) {
        //final T obj = onParseResponse(call, response);
        String json = "";
        try {
            json = response.body().string();
            Log.e("okhttp  ", "   " + response.code() + json.toString());

            if (response.code() == 200) {
                final T bean;
                try {
                    bean = GsonUtils.getInstance().fromJson(json, mType);

                    mMainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            mListener.onSuccess(bean);
                            // Log.e("Okhttp  ---->", json);
                            mListener.onFinish();
                        }
                    });
                } catch (Exception e) {
                    Log.e("Okhttp  ---->", "解析异常");
                    mListener.onFailure(new FailureBean(FailureBean.ERROR_PARSE, "数据解析异常"));
                }
            } else {
                try {
                    final FailureBean bean = GsonUtils.getInstance().fromJson(json, FailureBean.class);
                    mMainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            mListener.onFailure(bean);
                            mListener.onFinish();
                        }
                    });
                    Log.e("Okhttp  ---->Error", "      " + response.code() + "  msg" + response.message());
                } catch (final Exception e) {
                    mMainHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            mListener.onFailure(new FailureBean(FailureBean.ERROR_PARSE, "数据获取失败"));
                            e.printStackTrace();
                        }
                    });
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        response.close(); //无论任何情况都要关闭该对象
    }
}
  • Okhttps请求方法抽象类实现
public abstract class AsyncTaskListener<T> {
    public void onStart() {
    }

    public abstract void onSuccess(T bean);

    public void onFailure(FailureBean bean) {

        try {
            if (System.currentTimeMillis() - MyApplication.HTTPfailTime > 10000) {
                MyApplication.HTTPfailTime = System.currentTimeMillis();
                if (APIConstant.FAIL_CODE_RELODE == bean.getCode()) {
//                    if (UserManager.getInstance().hasLoginUser() != null) {
                    if (MyApplication.mApplication.getCurContext() != null) {
                        //UserManager.getInstance().logout();
                        Intent intent = new Intent(MyApplication.mApplication.getCurContext(), LoginActivity.class);
                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
                        MyApplication.mApplication.getCurContext().startActivity(intent);
                    }
                }
//                }
            }
        } catch (Exception e) {
        }
    }

    public void onFinish() {
    }
}
  • okhttps请求方式以及数据传输方式封装
public class OkhttpUtil {

    public static final String METHOD_GET = "GET";
    public static final String METHOD_POST = "POST";
    public static final String METHOD_PUT = "PUT";
    public static final String METHOD_DELETE = "DELETE";

    /**
     * get要求
     *
     * @param url：url
     * @param okhttpListener：回调接口，onFailure方法在要求失败时调用，onResponse方法在要求成功后调用，这两个方法都执行在UI线程。
     */
    public static void okHttpGet(String url, OkhttpListener okhttpListener) {
        okHttpGet(url, null, null, okhttpListener);
    }

    /**
     * get要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param okhttpListener
     */
    public static void okHttpGet(String url, Map<String, Object> paramsMap, OkhttpListener okhttpListener) {
        okHttpGet(url, paramsMap, null, okhttpListener);
    }

    /**
     * get要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param headerMap：map集合，封装要求头键值对
     * @param okhttpListener
     */
    public static void okHttpGet(String url, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener okhttpListener) {
        new RequestUtil(METHOD_GET, url, paramsMap, headerMap, okhttpListener).enqueue();
    }

    /**
     * post要求
     *
     * @param url：url
     * @param okhttpListener
     */
    public static void okHttpPost(String url, OkhttpListener okhttpListener) {
        okHttpPost(url, null, okhttpListener);
    }

    /**
     * post要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap
     * @param okhttpListener
     */
    public static void okHttpPost(String url, Map<String, Object> paramsMap, OkhttpListener okhttpListener) {
        okHttpPost(url, paramsMap, null, okhttpListener);
    }

    /**
     * post要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param headerMap：map集合，封装要求头键值对
     * @param okhttpListener
     */
    public static void okHttpPost(String url, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener okhttpListener) {
        new RequestUtil(METHOD_POST, url, paramsMap, headerMap, okhttpListener).enqueue();
    }

    /**
     * Put要求
     *
     * @param url：url
     * @param callBack
     */
    public static void okHttpPut(String url, OkhttpListener callBack) {
        okHttpPut(url, null, callBack);
    }

    /**
     * Put要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param okhttpListener
     */
    public static void okHttpPut(String url, Map<String, Object> paramsMap, OkhttpListener okhttpListener) {
        okHttpPut(url, paramsMap, null, okhttpListener);
    }

    /**
     * Put要求，可以传递参数
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param headerMap：map集合，封装要求头键值对
     * @param okhttpListener
     */
    public static void okHttpPut(String url, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener okhttpListener) {
        new RequestUtil(METHOD_PUT, url, paramsMap, headerMap, okhttpListener).enqueue();
    }

    /**
     * Delete
     *
     * @param url：url
     * @param okhttpListener
     */
    public static void okHttpDelete(String url, OkhttpListener okhttpListener) {
        okHttpDelete(url, null, okhttpListener);
    }

    /**
     * Delete
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param okhttpListener
     */
    public static void okHttpDelete(String url, Map<String, Object> paramsMap, OkhttpListener okhttpListener) {
        okHttpDelete(url, paramsMap, null, okhttpListener);
    }

    /**
     * Delete
     *
     * @param url：url
     * @param paramsMap：map集合，封装键值对参数
     * @param headerMap：map集合，封装要求头键值对
     * @param okhttpListener
     */
    public static void okHttpDelete(String url, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener okhttpListener) {
        new RequestUtil(METHOD_DELETE, url, paramsMap, headerMap, okhttpListener).enqueue();
    }

    /**
     * post要求，json传参方式
     *
     * @param url：url
     * @param jsonStr：json格式的键值对参数
     * @param okhttpListener
     */
    public static void okHttpPostJson(String url, String jsonStr, OkhttpListener okhttpListener) {
        okHttpPostJson(url, jsonStr, null, okhttpListener);
    }

    /**
     * post要求，json传参方式
     *
     * @param url：url
     * @param jsonStr：json格式的键值对参数
     * @param headerMap：map集合，封装要求头键值对
     * @param okhttpListener
     */
    public static void okHttpPostJson(String url, String jsonStr, Map<String, Object> headerMap, OkhttpListener okhttpListener) {
        new RequestUtil(METHOD_POST, url, jsonStr, headerMap, okhttpListener).enqueue();
    }

    /**
     * 判断网络是否连接
     *
     * @param context
     * @return
     */
    public static boolean isConnected(Context context) {

        ConnectivityManager connectivity = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);

        if (null != connectivity) {

            NetworkInfo info = connectivity.getActiveNetworkInfo();
            if (null != info && info.isConnected()) {
                if (info.getState() == NetworkInfo.State.CONNECTED) {
                    return true;
                }
            }
        }
        return false;
    }
}
  • 数据处理及调用请求方式
 public void loginPassword(String loginId, String password, String enterpriseId, final AsyncTaskListener<ParentUserBean> listener) {
        Map map = new HashMap();
        map.put(APIConstant.LOGIN_BASIC_LOGIN_ID, loginId);
        map.put(APIConstant.REQUEST_PARAM_PASSWORD, password);
        map.put(APIConstant.LOGIN_BASIC_ENTERPRISE_ID, enterpriseId);
        OkhttpUtil.okHttpGet(APIConstant.LOGIN, map, new OkhttpListener(ParentUserBean.class, listener));
    }
  • Activity重写抽象方法，并调用对应的TASK
 new AccountNewTask().loginPassword(loginID, password, companyCode, new AsyncTaskListener<ParentUserBean>() {
            @Override
            public void onStart() {
                super.onStart();
                progressDialog.setMessage(getString(R.string.login_load));
                progressDialog.show();
                progressDialog.setCanceledOnTouchOutside(false);
            }

            @Override
            public void onSuccess(ParentUserBean bean) {
          
                if ("200".equals(bean.getStatusCode())) {
                    saveCompanyCode(bean);
                    finishActivity(companyCode);
                } else {
                    final AlertDialog alertDialog = new AlertDialog.Builder(LoginActivity.this)
                            .setTitle(getString(R.string.login_error))
                            .setMessage(bean.getMassage())
                            .setNegativeButton(getString(R.string.confirm), new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                }
                            })
                            .create();
                    alertDialog.show();
                    progressDialog.hide();
                }
            }

            @Override
            public void onFailure(FailureBean bean) {
                super.onFailure(bean);
                progressDialog.dismiss();
                Toast.makeText(LoginActivity.this, getString(R.string.loading_network_error), Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onFinish() {
                progressDialog.dismiss();
                super.onFinish();
            }
        });

网络请求

public class RequestUtil {

    private String mMetyodType; //请求方式，get和post
    private String mUrl;
    private Map<String, Object> mParamsMap; //键值对类型的参数，只有这一种情况下区分post和get。
    private String mJsonStr; //json类型的参数，post方式

    private Map<String, Object> mHeaderMap; //头参数
    private OkhttpListener mCallBack;       //回调
    private static OkHttpClient mOkHttpClient;
    private Request.Builder mRequestBuilder;
    private Request mOkHttpRequest;

    RequestUtil(String methodType, String url, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener callBack) {
        this(methodType, url, null, paramsMap, headerMap, callBack);
    }

    RequestUtil(String methodType, String url, String jsonStr, Map<String, Object> headerMap, OkhttpListener callBack) {
        this(methodType, url, jsonStr, null, headerMap, callBack);
    }

    private RequestUtil(String methodType, String url, String jsonStr, Map<String, Object> paramsMap, Map<String, Object> headerMap, OkhttpListener callBack) {
        mMetyodType = methodType;
        mUrl = url;
        mJsonStr = jsonStr;
        mParamsMap = paramsMap;
        mHeaderMap = headerMap;
        mCallBack = callBack;
        getInstance();
    }

    /**
     * 创建OKhttpClient实例。
     */
    private void getInstance() {
        mRequestBuilder = new Request.Builder();
        getClientIns();
        //设置参数
        switch (mMetyodType) {
            case OkhttpUtil.METHOD_GET:
                setGetParams();
                break;
            case OkhttpUtil.METHOD_POST:
                mRequestBuilder.post(getRequestBody());
                break;
            case OkhttpUtil.METHOD_PUT:
                mRequestBuilder.put(getRequestBody());
                break;
            case OkhttpUtil.METHOD_DELETE:
                mRequestBuilder.delete(getRequestBody());
                break;
        }
        mRequestBuilder.url(mUrl);
        if (mHeaderMap != null) {
            setMyHeader();
        } else {
            //setHeader();
        }
        //mRequestBuilder.addHeader("Authorization","Bearer "+"token");可以把token添加到这儿
        mOkHttpRequest = mRequestBuilder.build();
    }

    private OkHttpClient getClientIns() {
        if (mOkHttpClient == null) {
            synchronized (RequestUtil.class) {
                if (mOkHttpClient == null) {
                    mOkHttpClient = new OkHttpClient();
                }
            }
        }
        return mOkHttpClient;
    }

    /**
     * request post得到body对象
     */
    private RequestBody getRequestBody() {
        if (!TextUtils.isEmpty(mJsonStr)) {
            MediaType JSON = MediaType.parse("application/json; charset=utf-8");//数据类型为json格式，
            return RequestBody.create(JSON, mJsonStr);//json数据，
        }


        FormBody.Builder formBody = new FormBody.Builder();
        if (mParamsMap != null) {
            for (String key : mParamsMap.keySet()) {
                if (mParamsMap.get(key) != null) {
                    formBody.add(key, mParamsMap.get(key).toString());
                }
            }
        }
        return formBody.build();
    }

    /**
     * get请求，只有键值对参数
     */
    private void setGetParams() {
        if (mParamsMap != null) {
            mUrl = mUrl + "?";
            for (String key : mParamsMap.keySet()) {
                mUrl = mUrl + key + "=" + mParamsMap.get(key) + "&";
            }
            mUrl = mUrl.substring(0, mUrl.length() - 1);

            Log.e("okhttp url:  ", mUrl);
        }
    }
    /**
     * 设置请求头，自己传的
     */
    private void setMyHeader() {
        if (mHeaderMap != null) {
            for (Object key : mHeaderMap.keySet()) {
                mRequestBuilder.addHeader(key.toString(), mHeaderMap.get(key).toString());
            }
        }

    }

    void enqueue() {
        mOkHttpClient.newCall(mOkHttpRequest).enqueue(new Callback() {
            @Override
            public void onFailure(final Call call, final IOException e) {
                if (mCallBack != null) {
                    mCallBack.onError(call, e);
                }
            }

            @Override
            public void onResponse(final Call call, final Response response) throws IOException {
                if (mCallBack != null) {
                    mCallBack.onSeccess(call, response);
                }
            }

        });
    }
}
OkHttp网络请求框架在Android中的使用
IH_LZH的博客
05-22 5543
OkHttp是square公司推出的一款Android和Java网络请求库，是目前公认的最好用的网络请求框架，OkHttp有以下的特点：支持Http/2，允许对同一主机的所有请求共享同一套接字；使用连接池减少请求延时；透明的GZIP压缩减少响应数据的大小；缓存响应的内容，避免重复请求；
安卓开发中OkHttp的使用——基于Kotlin
m0_66843126的博客
06-07 3261
GET请求、POST请求、图片下载、文件的下载上传
Android-Okhttp的使用解析
01-04
okhttp是Android6.0推出的网络框架。由于谷歌在Android6.0的之后，将HttpClient相关属性取消掉，导致Volley框架不能正常使用。所以才有了今天的Okhttp。  Okhttp进行网络访问通常有两种方式，一种是get请求，还有一种叫做post请求。 1、OKhttp的get请求 通常，我们使用get方式来请求一个网站，是依靠url地址的。Okhttp使用get方式来请求网站通常有如下的步骤： A、创建OkhttpClient的变量，这个变量相当于是一个全局的执行者。主要的网络操作是依靠它来进行的。 B、创建一个builder对象。 C、利用builder对象创建一
Android--OKhttp使用
超宇的博客
03-28 2616
OkHttp官网地址：http://square.github.io/okhttp/ OkHttp GitHub地址：https://github.com/square/okhttp 配置方法 对于Android Studio的用户，可以选择添加: compile 'com.squareup.okhttp:okhttp:2.4.0' Eclipse的用户，可以下载最新
Android OkHttp 全面解析：从原理到实践
最新发布
android开发者的专栏
06-19 764
OkHttp 是 Square 公司开发的一个高效的 HTTP 客户端，它具有以下特点：支持 HTTP/2，允许对同一主机的所有请求共享一个套接字连接池减少了请求延迟（如果 HTTP/2 不可用）透明的 GZIP 压缩减少了下载大小响应缓存完全避免了重复请求的网络传输@Override// 使用自定义拦截器.build();OkHttp 作为 Android 平台上最流行的网络请求库之一，其设计精良、功能强大且易于扩展。
Android 网络请求框架 OkHttp 的使用
热门推荐
baipenggui_bo
03-04 1万+
一.OkHttp的历史和意义一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso)用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient,现在已经打不出来)。尽管Google在大部分安卓版本中推荐使用HttpURLConnection，但是这个类相...
Android的OkHttp使用和原理
qq_44016573的博客
08-15 1956
OkHttp的出现代替了HttpUrlConnection，被谷歌官方收纳为底层的网络框架。当网络出现问题时，OkHttp会静默重新恢复连接，因为是静默的，所以用户无感知。
Android-OkHttp的请求重试拦截器
08-13
网络拦截器则是在请求真正到达服务器之前和响应真正返回给OkHttp之前工作，它们可以看到和修改请求和响应的网络级别表现。 请求重试拦截器的核心功能是处理网络请求失败的情况，例如网络不稳定导致的请求失败。通过...
Android之基于OkHttp的websocket框架
03-22
在`WsManager-master`这个项目中，可能包含了这样一个封装好的WebSocket管理类，提供了更高级别的API供开发者调用。 总之，基于OkHttp的WebSocket框架在Android应用中具有重要的作用，它可以提供实时通信能力，且...
Android OkHttp+Retrofit+RxJava搭建网络访问框架（含源码）
2401_87029380的博客
09-06 1129
week = “昨天”;week = “今天”;week = “明天”;} else {case 1:week = “星期日”;break;case 2:week = “星期一”;break;case 3:week = “星期二”;break;case 4:week = “星期三”;break;case 5:week = “星期四”;break;case 6:week = “星期五”;break;case 7:week = “星期六”;
Android-okhttp详解
袁震的博客
01-26 3105
OkHttp是当下Android使用最频繁的网络请求框架，由Square公司开源。Google在Android4.4以后开始将源码中 的HttpURLConnection底层实现替换为OKHttp，同时现在流行的Retrofit框架底层同样是使用OKHttp的。okhttp的优点是：1，支持Http1、Http2、Quic以及WebSocket2，连接池复用底层TCP(Socket)，减少请求延时3，无缝的支持GZIP减少数据流量4，缓存响应数据减少重复的网络请求。
Android客户端与服务器端交互（okHttp）
08-02
Android中服务器和客户端交互，可上传文件、图片、json数据，也可从服务器端下载图片、文件
java 调用okHttp3进行代码测试（SpringBoot项目)）
02-21
SpringBoot OkHttp3,里面包含了各种测试代码，其中包含了get，post，文件上传等测试
安卓实现 Okhttp https注册登录
12-16
一个简单的demo
okhttp的使用介绍
103style
09-20 567
转载请以链接形式标明出处： 本文出自:103style的博客 目录 简介 分支介绍 使用示例 混淆配置 简介 github地址 官方介绍 okhttp 的优势： 采用连接池技术减少 默认使用 GZIP 数据压缩格式，降低传输内容的大小 采用缓存避免重复的网络请求 支持 SPDY、HTTP/2.0，对于同一主机的请求可共享同一 socket 连接 若 SPDY 或 HTTP/2.0...
Android网络通讯之OkHttp
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-09 7413
OkHttp是安卓上常用的网络请求框架，不止可以发送http请求，还可以发送socket请求等。官网地址：https://square.github.io/okhttp/
Android Okhttp 使用
weixin_37627774的博客
10-27 254
文章目录1.基本使用1.1 字符串读取1.2 文件下载1.3 文件上传2. 参考 1.基本使用 1.1 字符串读取 //这个程序下载一个URL并将其内容返回为字符串 OkHttpClient client = new OkHttpClient(); String getStringFromUrl(String url) throws IOException { Request request = new Request.Builder() .url(url) .build();
Android okhttp使用
qinxuexiang_blog的博客
05-03 984
简介 OKHttp是一个十分常用的网络请求框架了，用于android中请求网络。 除了OKHttp，如今Android中主流的网络请求框架有： Android-Async-Http Volley OkHttp Retrofit 依赖库导入 在build.gradle添加如下依赖 implementation 'com.squareup.okhttp3:okhttp:4.9.0' 添加网络权限 <uses-permission android:name="android.per.
android okhttp使用
09-06
OkHttp是一个处理网络请求的开源项目，是Android使用最广泛的网络框架。它适用于Android 5.0（API级别21）和Java 8。使用OkHttp发送HTTP请求的过程如下： 1. 域名解析（DNS）：将域名解析为IP地址。 2. 建立TCP连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值