精华内容
下载资源
问答
  • 最近工作中,需要在okgo的基础上做网络请求的链式调用,然后就查看了一些资料捣鼓了一下。 OkGo github 地址 1.添加的依赖库 compile 'com.lzy.net:okgo:3.0.4' compile 'com.lzy.net:okrx2:2.0.2' 2.因为OkGo ...

    最近工作中,需要在okgo的基础上做网络请求的链式调用,然后就查看了一些资料捣鼓了一下。

    OkGo github 地址

    1.添加的依赖库

    compile 'com.lzy.net:okgo:3.0.4'
    compile 'com.lzy.net:okrx2:2.0.2'

    2.因为OkGo 3.+版本支持Rxjava2 ,所以使用Rxjava2的flatmap操作符就能完成链式调用的

    需求。首先做第一次请求,代码如下:

     OkGo.<String>post("http://route.showapi.com/9-9")
                            .params("area","北京")
                            .converter(new StringConvert())
                            .adapt(new ObservableResponse<String>())
                            .subscribeOn(Schedulers.io())
                            .flatMap(new Function<Response<String>, ObservableSource<Response<String>>>() {
                                @Override
                                public ObservableSource<Response<String>> apply(Response<String> stringResponse) throws Exception {
                                
                                    return  null
                                }
                            })

    这样在flatMap中拿到第一个请求的回调数据  Response<String>。

    一般链式调用的场景是第一个请求的返回数据来做第二个请求的参数。flatMap 中我们可以把拿到的数据处理一下,

    然后做第二次请求,并返回一个Observable,如下:

     OkGo.<String>post("http://route.showapi.com/9-9")
                            .params("area","北京")
                            .converter(new StringConvert())
                            .adapt(new ObservableResponse<String>())
                            .subscribeOn(Schedulers.io())
                            .flatMap(new Function<Response<String>, ObservableSource<Response<String>>>() {
                                @Override
                                public ObservableSource<Response<String>> apply(Response<String> stringResponse) throws Exception {
                                JsonFormat.printJson("第一次请求数据:",stringResponse.body(),"***");
                                    //假装使用第一个请求返回的数据
                                    io.reactivex.Observable<Response<String>> observable = OkGo.<String>post("http://route.showapi.com/9-9")
                                            .params("area", "上海")
                                            .converter(new StringConvert())
                                            .adapt(new ObservableResponse<String>())
                                            .subscribeOn(Schedulers.io());
                                    return  observable;
                                }
                            })
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(new ApiObserver<Response<String>>(this) {
                                @Override
                                public void onSuccess(Response<String> apiResult) {
                                    JsonFormat.printJson("第二次请求数据:",apiResult.body(),"***");
                                }
    
                                @Override
                                public void onFailed(Throwable e) {
    
                                }
                            });

    这样其实两次请求的链式调用已经完成,在 Observer的 回调中处理第二次回调的结果就可以了。文中的ApiObserver 是我对Observer的扩展。执行这段代码,Log日志如下:

     

    数据太长,其实可以看到是顺序执行的。

    如果想要进行多次的链式调用,则在flatMap继续使用flatMap来处理回调,就可以N到N+1的继续,不过最后需要subscribe来结尾。

    除了flatMap,类似concatMap也可以有这样的效果,不过concatMap是保证从第一个请求到第二个请求的有序性,如果

    第一个发射器(Observable)多次发射数据,concatMap可以按照顺序做第二步的请求,flatMap则是无序的。

    更多相关的操作符可以自行搜集Rxjava2相关的资料学习。

    展开全文
  • OkGo

    千次阅读 2019-08-06 20:01:47
    OkGo一:OkGo介绍作用:网络请求的框架(okhttp)功能:上传,下载(图片,文件MP3,字符...支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持...

    一:OkGo介绍

    该库是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和自签名证书,支持cookie自动管理,支持四种缓存模式缓存网络数据,支持301、302重定向,扩展了统一的上传管理和下载管理功能

    作用:网络请求的框架(okhttp)

    功能:上传,下载(图片,文件MP3,字符串)

    添加依赖

    implementation 'com.lzy.net:okgo:3.0.4'
    

    二:get请求

    下载json

    在这里插入图片描述

    public void downjson(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkGo.<String>get("https://news-at.zhihu.com/api/4/news/latest").execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        final String body = response.body();
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(MainActivity.this, body, Toast.LENGTH_SHORT).show();
                            }
                        });
                    }
    
                    @Override
                    public void downloadProgress(Progress progress) {
                        super.downloadProgress(progress);
                        //progress.fraction 获得当前上传进度 范围0-1
                        progressId.setProgress((int) (progress.fraction*100));
                    }
    
                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                    }
                });
            }
        }).start();
    }
    

    下载图片

    在这里插入图片描述

    public void downphoto(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkGo.<Bitmap>get("http://i.kinja-img.com/gawker-media/image/upload/s--B7tUiM5l--/gf2r69yorbdesguga10i.gif").execute(new BitmapCallback() {
                    @Override
                    public void onSuccess(Response<Bitmap> response) {
                        Bitmap bitmap = response.body();
                        Log.i(TAG, "onSuccess: 图片大小"+bitmap.getByteCount());
                        imageId.setImageBitmap(bitmap);
                    }
    
                    @Override
                    public void downloadProgress(Progress progress) {
                        super.downloadProgress(progress);
                        progressId.setProgress((int) (progress.fraction*100));
                    }
                });
            }
        }).start();
    }
    

    下载MP4

    public void downmp3(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkGo.<File>get("http://uvideo.spriteapp.cn/video/2019/0512/56488d0a-7465-11e9-b91b-1866daeb0df1_wpd.mp4").execute(new FileCallback("/mnt/sdcard","jiat.mp4") {
                    @Override
                    public void onSuccess(Response<File> response) {
    
                    }
                    @Override
                    public void downloadProgress(Progress progress) {
                        super.downloadProgress(progress);
                        //如何拿到当前的下载进度
                        progressId.setProgress((int)(progress.fraction*100));
                    }
                });
            }
        }).start();
    }
    

    post请求

    public void upLoade(){
        OkGo.<String>post("http://10.1.2.121/text/").isMultipart(true).params("file",new File("mnt/sdcard/aaa.mp3"),"huolai.mp3").execute(new StringCallback() {
            @Override
            public void onSuccess(Response<String> response) {
                Log.d(TAG, "onSuccess: "+response.body());
            }
    
            @Override
            public void uploadProgress(Progress progress) {
                super.uploadProgress(progress);
            }
        });
    }
    
    展开全文
  • OKGO

    2017-03-10 15:31:17
    OKGO okHttpUtils二次封装的网络请求框架,自动管理cookies


    转载自:http://blog.csdn.net/sky_pjf。


    1.支持的常用功能

    • 一般的 get,post,put,delete,head,options请求
    • 基于Post的大文本数据上传,postString(),postJson()等
    • 多文件和多参数统一的表单上传(允许监听上传进度)
    • 支持一个key上传一个文件,也可以一个Key上传多个文件
    • 大文件下载和下载进度回调
    • 大文件上传和上传进度回调
    • 支持cookie的内存存储和持久化存储,支持传递自定义cookie
    • 提供网络缓存功能,默认支持304缓存协议,并额外扩展了三种本地缓存模式
    • 支持301、302重定向
    • 支持链式调用
    • 支持可信证书和自签名证书的https访问
    • 支持根据Tag取消网络请求
    • 支持自定义泛型Callback,自动根据泛型返回对象

    2.支持的扩展功能

    • 统一的文件下载管理(DownloadManager)
      默认使用的是 get 请求,同时下载数量为3个,支持断点下载,断点信息使用ORMLite数据库框架保存,默认下载路径/storage/emulated/0/download,下载路径和下载数量都可以在代码中配置,下载管理使用了服务提高线程优先级,避免后台下载时被系统回收。
      当你的项目需要做大量的下载的时候,并且多个页面需要监听下载进度,使用该扩展让你更方便。原生支持下载任务的开始、暂停、停止、出错、完成五个状态,当同时下载任务数量超过3个(可代码动态设置)时,后续任务自动等待,当有任务下载完成时,等待任务按照优先级自动开始下载。
    • 统一的文件上传管理(UploadManager)
      默认使用的是 post 上传请求,该上传管理为简单管理,不支持断点续传和分片上传,只是简单的将所有上传任务使用线程池进行了统一管理,默认同时上传数量为1个。由于断点分片上传的技术需要大量的服务端代码配合,同时也会极大的增加客户端代码量,所以综合考虑,该框架不做实现。如果确实有特殊需要,可以自己做扩展。

    2.2 统一的文件上传管理(UploadManager)

    • 结合OkHttpUtils 的request进行网络请求,支持与OkHttpUtils 保持相同的全局公共参数,同时支持请求传递参数
    • 上传只能使用PostPutDeleteOptions 这四种请求,不支持GetHead
    • 该上传管理为简单管理,不支持断点续传或分片上传,只是简单的将所有上传任务使用线程池进行了统一管理
    • 默认同时上传数量为1个,该数列可以在代码中配置修改
    • 由于断点分片上传的技术需要大量的服务端代码配合,同时也会极大的增加客户端代码量,所以综合考虑,该框架不做实现。如果确实有特殊需要,可以自己做扩展。

    项目的效果图如下:


    项目主页

    请求详细信息

    下载管理列表页

    下载管理详情页

    上传管理和图片选择

    3.如何选择网络框架

    说了这么多功能,我们来看看为什么要使用OkHttpUtils这个框架。
    首先目前主流的几个网络框架

    • android-async-http
    • xUtils
    • volley
    • retrofit
    • okhttp

    在此引用知乎上Stay Zhang的回答:

    我们来先说一个常识性的错误:volley, retrofit, Android-async-http 帮你封装了具体的请求,线程切换以及数据转换。而OkHttp 是基于http协议封装的一套请求客户端,虽然它也可以开线程,但根本上它更偏向真正的请求,跟HttpClient, HttpUrlConnection的职责是一样的。

    所以不要混淆。

    -----以下纯个人主观见解
    首先,我想即使你单纯使用OkHttp,还是会再包一层的,这样就等价于Volley之流的框架,只是封装的好与坏而已。

    android-async-http内部实现是基于HttpClient, 想必你肯定知道6.0之后HttpClient是不是系统自带的了,不过它在最近的更新中将HttpClient的所有代码copy了一份进来,所以还能使用。

    Volley是官方出的,volley在设计的时候是将具体的请求客户端做了下封装:HurlStack,也就是说可以支持HttpUrlConnection, HttpClient, OkHttp,相当于模版模式吧,这样解耦还是非常方便的,可以随意切换,如果你之前使用过Volley,并习惯使用,那直接写个OkHttp扩展就行了。

    Retrofit因为也是square出的,所以大家可能对它更崇拜些。Retrofit的跟Volley是一个套路,但解耦的更彻底:比方说通过注解来配置请求参数,通过工厂来生成CallAdapter,Converter,你可以使用不同的请求适配器(CallAdapter), 比方说RxJava,Java8, Guava。你可以使用不同的反序列化工具(Converter),比方说json, protobuff, xml, moshi等等。关键是想要用好这个框架,最好是和RxJava联用,否者和普通的网络框架也没什么区别,而对于RxJava,特别team人数多的情况下,总得有个完全精通的吧,万一掉坑里了呢。。。

    4.OkHttpUtils的优势

    • 优势一:性能高,专注于简单易用的网络请求,使用主流的okhttp进行封装,对于okhttp大家都知道,在Android4.4的源码中可以看到HttpURLConnection已经替换成OkHttp实现了,并且支持HTTP2/SPDY黑科技,支持socket自动选择最好路线,并支持自动重连,拥有自动维护的socket连接池,减少握手次数,拥有队列线程池,轻松写并发。
    • 优势二:特有的网络缓存模式,是大多数网络框架所不具备的,说一个应用场景,老板说我们的app不仅需要在有网的情况下展示最新的网络数据,还要在没网的情况下使用缓存数据,这时候是不是项目中出现了大量的代码判断当前网络状况,根据不同的状态保存不同的数据,然后决定是否使用缓存。细想一下,这是个通用的写法,于是OkHttpUtils提供了四种缓存模式,让你不用关心缓存的实现,而专注于数据的处理。(具体缓存的使用方法请看最后第四章节)。
    • 优势三:方便易用的扩展接口,可以添加全局的公共参数,全局拦截器,全局超时时间,更可以对单个请求定制拦截器,超时时间,请求参数修改等等,在使用上更是方便,原生支持的链式调用让你的请求更加清晰。
    • 优势四:强大的Cookie保持策略,我们知道在客户端对cookie的获取是个不太简单的事情,特别是还要处理cookie的过期时间,持久化策略等等,OkHttpUtils帮你彻底解决Cookie的难题,默认拥有内存存储和持久化存储两种实现,cookie全程自动管理,并且提供了额外的addCookie方式,允许介入到自动管理的过程中,添加你想创建的任何cookie。

    所以就说这么多啦,选最适合项目的,选大多数人选择的,选简单易用的,就这么个标准,而OkHttpUtils正是在这种情况下诞生啦!!

    5.使用方法

    • 对于Android Studio的用户,可以选择添加:

        compile 'com.lzy.net:okhttputils:1.8.1'  //可以单独使用,不需要依赖下方的扩展包
        compile 'com.lzy.net:okhttpserver:1.0.3' //扩展了下载管理和上传管理,根据需要添加
      
        compile 'com.lzy.net:okhttputils:+'  //版本号使用 + 可以自动引用最新版
        compile 'com.lzy.net:okhttpserver:+' //版本号使用 + 可以自动引用最新版
    • 为了方便大家使用,更加通俗的理解http的网络协议,建议做网络请求的时候,对每个请求抓包后查看请求信息和响应信息。
    • 如果是 Windows 操作系统,可以使用 Fiddler 对手机的请求进行抓包查看。
    • 如果是 Mac OS 操作系统,可以使用 Charles 对手机的请求进行抓包查看。
    • 具体的下载地址和抓包配置方法,我这就不提供了,请自行百度或谷歌。

    6.使用注意事项

    • okhttputils使用的okhttp的版本是最新的 3.4.1 版本,和以前的 2.x 的版本可能会存在冲突。
    • okhttpserver是对okhttputils的扩展,统一了下载管理和上传管理,对项目有需要做统一下载的可以考虑使用该扩展,不需要的可以直接使用okhttputils即可。
    • 对于缓存模式使用,需要与返回对象相关的所有javaBean必须实现Serializable接口,否者会报NotSerializableException
    • 使用缓存时,如果不指定cacheKey,默认是用url带参数的全路径名为cacheKey
    • 使用该网络框架时,必须要在 Application 中做初始化 OkHttpUtils.init(this);

    一、全局配置

    一般在 Aplication,或者基类中,只需要调用一次即可,可以配置调试开关,全局的超时时间,公共的请求头和请求参数等信息,所有的请求参数都支持中文,

        @Override
        public void onCreate() {
            super.onCreate();
    
            HttpHeaders headers = new HttpHeaders();
            headers.put("commonHeaderKey1", "commonHeaderValue1");    //所有的 header 都 不支持 中文
            headers.put("commonHeaderKey2", "commonHeaderValue2");
            HttpParams params = new HttpParams();
            params.put("commonParamsKey1", "commonParamsValue1");     //所有的 params 都 支持 中文
            params.put("commonParamsKey2", "这里支持中文参数");
    
            //必须调用初始化
            OkHttpUtils.init(this);
            //以下都不是必须的,根据需要自行选择
            OkHttpUtils.getInstance()//
                    .debug("OkHttpUtils")                                              //是否打开调试
                    .setConnectTimeout(OkHttpUtils.DEFAULT_MILLISECONDS)               //全局的连接超时时间
                    .setReadTimeOut(OkHttpUtils.DEFAULT_MILLISECONDS)                  //全局的读取超时时间
                    .setWriteTimeOut(OkHttpUtils.DEFAULT_MILLISECONDS)                 //全局的写入超时时间
                  //.setCookieStore(new MemoryCookieStore())                           //cookie使用内存缓存(app退出后,cookie消失)
                  //.setCookieStore(new PersistentCookieStore())                       //cookie持久化存储,如果cookie不过期,则一直有效
                    .addCommonHeaders(headers)                                         //设置全局公共头
                    .addCommonParams(params);                                          //设置全局公共参数
        }

    二、普通请求

    1.基本的网络请求

    OkHttpUtils.get(Urls.URL_METHOD)     // 请求方式和请求url
        .tag(this)                       // 请求的 tag, 主要用于取消对应的请求
        .cacheKey("cacheKey")            // 设置当前请求的缓存key,建议每个不同功能的请求设置一个
        .cacheMode(CacheMode.DEFAULT)    // 缓存模式,详细请看缓存介绍
        .execute(new JsonCallback<RequestInfo>(RequestInfo.class) {
            @Override
            public void onResponse(boolean isFromCache, RequestInfo requestInfo, Request request, @Nullable Response response) {
                // requestInfo 对象即为所需要的结果对象
            }
        });

    2.请求 Bitmap 对象

    OkHttpUtils.get(Urls.URL_IMAGE)//
        .tag(this)//
        .execute(new BitmapCallback() {
            @Override
            public void onResponse(boolean isFromCache, Bitmap bitmap, Request request, @Nullable Response response) {
            // bitmap 即为返回的图片数据
            }
        });

    3.请求 文件下载

    OkHttpUtils.get(Urls.URL_DOWNLOAD)//
        .tag(this)//
        .execute(new FileCallback("/sdcard/temp/", "file.jpg") {  //文件下载时,需要指定下载的文件目录和文件名
            @Override
            public void onResponse(boolean isFromCache, File file, Request request, @Nullable Response response) {
            // file 即为文件数据,文件保存在指定布幕
            }
        });

    4.普通Post,直接上传String类型的文本

    一般此种用法用于与服务器约定的数据格式,当使用该方法时,params中的参数设置是无效的,所有参数均需要通过需要上传的文本中指定,此外,额外指定的header参数仍然保持有效。

    OkHttpUtils.post(Urls.URL_TEXT_UPLOAD)//
        .tag(this)//
        .postString("这是要上传的长文本数据!")//
        .execute(new StringCallback() {
            @Override
            public void onResponse(boolean isFromCache, String s, Request request, @Nullable Response response) {
                //上传成功
            }
        });

    5.普通Post,直接上传Json类型的文本

    该方法与postString没有本质区别,只是数据格式是json,一般来说,需要自己创建一个实体bean或者一个map,把需要的参数设置进去,然后通过三方的Gson或者fastjson转换成json字符串,最后直接使用该方法提交到服务器。

    OkHttpUtils.post(Urls.URL_TEXT_UPLOAD)//
        .tag(this)//
        .postJson("{\"des\": \"这里面要写标准的json格式数据\"}")//
        .execute(new StringCallback() {
            @Override
            public void onResponse(boolean isFromCache, String s, Request request, @Nullable Response response) {
                //上传成功
            }
        });

    6.请求功能的所有配置讲解

    以下代码包含了以下内容:

    • 一次普通请求所有能配置的参数,真实使用时不需要配置这么多,按自己的需要选择性的使用即可
    • 多文件和多参数的表单上传,同时支持进度监听
    • 自签名网站https的访问,调用setCertificates方法即可
    • 为单个请求设置超时,比如涉及到文件的需要设置读写等待时间多一点。
    • Cookie一般情况下只需要在初始化的时候调用setCookieStore即可实现cookie的自动管理,如果特殊业务需要,需要手动额外向服务器传递自定义的cookie,可以在每次请求的时候调用addCookie方法,该方法提供了3个重载形式,可以根据自己的需要选择使用。
    OkHttpUtils.get(Urls.URL_METHOD) // 请求方式和请求url, get请求不需要拼接参数,支持get,post,put,delete,head,options请求
        .tag(this)               // 请求的 tag, 主要用于取消对应的请求
        .connTimeOut(10000)      // 设置当前请求的连接超时时间
        .readTimeOut(10000)      // 设置当前请求的读取超时时间
        .writeTimeOut(10000)     // 设置当前请求的写入超时时间
        .cacheKey("cacheKey")    // 设置当前请求的缓存key,建议每个不同功能的请求设置一个
        .cacheMode(CacheMode.FIRST_CACHE_THEN_REQUEST) // 缓存模式,详细请看第四部分,缓存介绍
        .setCertificates(getAssets().open("srca.cer")) // 自签名https的证书,可变参数,可以设置多个
        .addInterceptor(interceptor)            // 添加自定义拦截器
        .headers("header1", "headerValue1")     // 添加请求头参数
        .headers("header2", "headerValue2")     // 支持多请求头参数同时添加
        .params("param1", "paramValue1")        // 添加请求参数
        .params("param2", "paramValue2")        // 支持多请求参数同时添加
        .params("file1", new File("filepath1")) // 可以添加文件上传
        .params("file2", new File("filepath2")) // 支持多文件同时添加上传
        .addUrlParams("key", List<String> values)  //这里支持一个key传多个参数
        .addFileParams("key", List<File> files)    //这里支持一个key传多个文件
        .addFileWrapperParams("key", List<HttpParams.FileWrapper> fileWrappers) //这里支持一个key传多个文件
        .addCookie("aaa", "bbb")                // 这里可以传递自己想传的Cookie
        .addCookie(cookie)                      // 可以自己构建cookie
        .addCookies(cookies)                    // 可以一次传递批量的cookie
         //这里给出的泛型为 RequestInfo,同时传递一个泛型的 class对象,即可自动将数据结果转成对象返回
        .execute(new DialogCallback<RequestInfo>(this, RequestInfo.class) {
            @Override
            public void onBefore(BaseRequest request) {
                // UI线程 请求网络之前调用
                // 可以显示对话框,添加/修改/移除 请求参数
            }
    
            @Override
            public RequestInfo parseNetworkResponse(Response response) throws Exception{
                // 子线程,可以做耗时操作
                // 根据传递进来的 response 对象,把数据解析成需要的 RequestInfo 类型并返回
                // 可以根据自己的需要,抛出异常,在onError中处理
                return null;
            }
    
            @Override
            public void onResponse(boolean isFromCache, RequestInfo requestInfo, Request request, @Nullable Response response) {
                // UI 线程,请求成功后回调
                // isFromCache 表示当前回调是否来自于缓存
                // requestInfo 返回泛型约定的实体类型参数
                // request     本次网络的请求信息,如果需要查看请求头或请求参数可以从此对象获取
                // response    本次网络访问的结果对象,包含了响应头,响应码等,如果数据来自于缓存,该对象为null
            }
    
            @Override
            public void onError(boolean isFromCache, Call call, @Nullable Response response, @Nullable Exception e) {
                // UI 线程,请求失败后回调
                // isFromCache 表示当前回调是否来自于缓存
                // call        本次网络的请求对象,可以根据该对象拿到 request
                // response    本次网络访问的结果对象,包含了响应头,响应码等,如果网络异常 或者数据来自于缓存,该对象为null
                // e           本次网络访问的异常信息,如果服务器内部发生了错误,响应码为 400~599之间,该异常为 null
            }
    
            @Override
            public void onAfter(boolean isFromCache, @Nullable RequestInfo requestInfo, Call call, @Nullable Response response, @Nullable Exception e) {
                // UI 线程,请求结束后回调,无论网络请求成功还是失败,都会调用,可以用于关闭显示对话框
                // isFromCache 表示当前回调是否来自于缓存
                // requestInfo 返回泛型约定的实体类型参数,如果网络请求失败,该对象为 null
                // call        本次网络的请求对象,可以根据该对象拿到 request
                // response    本次网络访问的结果对象,包含了响应头,响应码等,如果网络异常 或者数据来自于缓存,该对象为null
                // e           本次网络访问的异常信息,如果服务器内部发生了错误,响应码为 400~599之间,该异常为 null
            }
    
            @Override
            public void upProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
                // UI 线程,文件上传过程中回调,只有请求方式包含请求体才回调(GET,HEAD不会回调)
                // currentSize  当前上传的大小(单位字节)
                // totalSize   需要上传的总大小(单位字节)
                // progress     当前上传的进度,范围 0.0f ~ 1.0f
                // networkSpeed 当前上传的网速(单位秒)
            }
    
            @Override
            public void downloadProgress(long currentSize, long totalSize, float progress, long networkSpeed) {
                // UI 线程,文件下载过程中回调
                //参数含义同 上传相同
            }
        });

    7.取消请求

    每个请求前都设置了一个参数tag,取消则通过OkHttpUtils.cancel(tag)执行。
    例如:在Activity中,当Activity销毁取消请求,可以在onDestory里面统一取消。

        @Override
        protected void onDestroy() {
            super.onDestroy();
    
            //根据 Tag 取消请求
            OkHttpUtils.getInstance().cancelTag(this);
        }

    8.同步的请求

    execute方法不传入callback即为同步的请求,返回Response对象,需要自己解析

        Response response = OkHttpUtils.get("http://www.baidu.com")//
                                        .tag(this)//
                                        .headers("aaa", "111")//
                                        .params("bbb", "222")
                                        .execute();

    三、自定义CallBack使用

    目前内部提供的包含AbsCallbackStringCallBack ,BitmapCallback ,FileCallBack ,可以根据自己的需求去自定义Callback

    • AbsCallback: 所有回调的父类,抽象类
    • StringCallBack:如果返回值类型是纯文本数据,即可使用该回调
    • BitmapCallback:如果请求的是图片数据,则可以使用该回调
    • FileCallBack:如果要做文件下载,则必须使用该回调,内部封装了关于文件下载进度回调的方法

    该网络框架的核心使用方法即为Callback的继承使用,详细请看 Demo 源码中callback包下的代码。

    因为不同的项目需求,可能对数据格式进行了不同的封装,于是在 Demo 中的进行了详细的代码示例,以下是详细介绍:

    • CommonCallback:继承自AbsCallback,主要作用是做全局共同请求参数的添加,同样也可以在第一步全局配置的时候设置,效果一样。
    • EncryptCallback:继承自CommonCallback,主要功能是做 Url 参数加密,对每个请求的参数进行编码,防止拦截数据包,篡改数据。
    • JsonCallback:继承自EncryptCallback,一般来说,服务器返回的响应码都包含 code,msg,data 三部分,在此根据自己的业务需要完成相应的逻辑判断,并对数据进行解析,可以使用 Gson 或者 fastjson,将解析的对象返回。
    • DialogCallback:继承自JsonCallback,对需要在网络请求的时候显示对话框,使用该回调。
    • StringDialogCallback:继承自EncryptCallback,如果网络返回的数据只是纯文本,使用该回调
    • BitmapDialogCallback :继承自BitmapCallback,如果网络返回的是Bitmap对象,使用该回调
    • DownloadFileCallBack :继承自FileCallback,如果需要做文件下载,使用该回调

    以上基本是包含了大部分的业务逻辑,具体情况请参照demo示例,根据业务需求修改!

    四、缓存的使用

    使用缓存前,必须让缓存的数据javaBean对象实现Serializable接口,否者会报NotSerializableException

    因为缓存的原理是将对象序列化后直接写入 数据库中,如果不实现Serializable接口,会导致对象无法序列化,进而无法写入到数据库中,也就达不到缓存的效果。

    目前提供了四种CacheMode缓存模式

    • DEFAULT: 按照HTTP协议的默认缓存规则,例如有304响应头时缓存
    • REQUEST_FAILED_READ_CACHE:先请求网络,如果请求网络失败,则读取缓存,如果读取缓存失败,本次请求失败。该缓存模式的使用,会根据实际情况,导致onResponse,onError,onAfter三个方法调用不只一次,具体请在三个方法返回的参数中进行判断。
    • IF_NONE_CACHE_REQUEST:如果缓存不存在才请求网络,否则使用缓存。
    • FIRST_CACHE_THEN_REQUEST:先使用缓存,不管是否存在,仍然请求网络,如果网络顺利,会导致onResponse方法执行两次,第一次isFromCache为true,第二次isFromCache为false。使用时根据实际情况,对onResponse,onError,onAfter三个方法进行具体判断。

    无论对于哪种缓存模式,都可以指定一个cacheKey,建议针对不同需要缓存的页面设置不同的cacheKey,如果相同,会导致数据覆盖。



    文/廖子尧(简书作者)
    原文链接:http://www.jianshu.com/p/4c17956fe3b4
    著作权归作者所有,转载请联系作者获得授权,并标注“简书作者”。

    文/廖子尧(简书作者)
    原文链接:http://www.jianshu.com/p/4c17956fe3b4
    著作权归作者所有,转载请联系作者获得授权,并标注“简书作者”。
    展开全文
  • OkGO

    千次阅读 2019-07-09 19:31:40
    支持链式调用 支持https访问,支持双向认证 支持根据tag取消请求,也可全部取消 支持自定义Callback,自动解析网络数据 //导入依赖  implementation 'com.lzy.net:okgo:3.0.4' okgo依赖 ...
    • 基本的get、post、put、delete、head、options、trace、patch八种请求
    • 支持upString,upJson,upBytes,upFile等up类方法上传特定数据
    • 支持一个key上传一个文件,也可以一个key上传多个文件,也可以多文件和多参数一起上传
    • 大文件下载和下载进度回调
    • 大文件上传和上传进度回调
    • 支持cookie的自动管理,并可自定义cookie管理策略
    • 支持缓存模式,不仅支持http缓存协议,也支持自定义缓存策略
    • 支持重定向
    • 支持自定义超时自动重连次数
    • 支持链式调用
    • 支持https访问,支持双向认证
    • 支持根据tag取消请求,也可全部取消
    • 支持自定义Callback,自动解析网络数据
    • //导入依赖
    •   implementation 'com.lzy.net:okgo:3.0.4'  okgo依赖

    • 这里演示的是一次普通请求所有能配置的参数,真实使用时不需要配置这么多,按自己的需要选择性的使用即可
    • 第一行的泛型一定要特别注意,这个表示你请求网络的数据类型是什么,必须指定,否则无法解析网络数据。
    • .post(url):这个表示当前请求是post请求,当然一共支持GET,HEAD,OPTIONS,POST,PUT,DELETE, PATCH, TRACE这8种请求方式,你只需要改改这个方法名就行了,很方便。
    • 另外,每个请求都有一个.client()方法可以传递一个OkHttpClient对象,表示当前这个请求将使用外界传入的这个OkHttpClient对象,其他的请求还是使用全局的保持不变。那么至于这个OkHttpClient你想怎么配置,或者配置什么东西,那就随意了是不,改个超时时间,加个拦截器什么的统统都是可以的,看你心情喽。

      特别注意: 如果你的当前请求使用的是你传递的OkHttpClient对象的话,那么当你调用OkGo.getInstance().cancelTag(tag)的时候,是取消不了这个请求的,因为OkGo只能取消使用全局配置的请求,不知道你这个请求是用你自己的OkHttpClient的,如果一定要取消,可以是使用OkGo提供的重载方法,详细看下方的取消请求的部分

    • .params():添加参数的时候,最后一个isReplace为可选参数,默认为true,即代表相同key的时候,后添加的会覆盖先前添加的。
    • .tag(this):请求的tag,用于标识当前的请求,方便后续取消对应的请求,如果你不需要取消请求,也可以不用设置。
    • .isMultipart():该方法表示是否强制使用multipart/form-data表单上传,因为该框架在有文件的时候,无论你是否设置这个参数,默认都是multipart/form-data格式上传,但是如果参数中不包含文件,默认使用application/x-www-form-urlencoded格式上传,如果你的服务器要求无论是否有文件,都要使用表单上传,那么可以用这个参数设置为true。
    • .isSpliceUrl():该方法表示是否强制将params的参数拼接到url后面,默认false不拼接。一般来说,post、put等有请求体的方法应该把参数都放在请求体中,不应该放在url上,但是有的服务端可能不太规范,url和请求体都需要传递参数,那么这时候就使用该参数,他会将你所有使用.params()方法传递的参数,自动拼接在url后面。
    • .retryCount():该方法是配置超时重连次数,也可以在全局初始化的时候设置,默认使用全局的配置,即为3次,你也可以在这里为你的这个请求特殊配置一个,并不会影响全局其他请求的超时重连次数。
    • .cacheKey() .cacheTime() .cacheMode():这三个是缓存相关的配置,详细请看缓存介绍
    • .headers():该方法是传递服务端需要的请求头,如果你不知道什么是请求头,看wiki首页关于网络抓包中的http协议链接
    • .params():该方法传递键值对参数,格式也是http协议中的格式,详细参考上面的http协议连接。
    • .addUrlParams() .addFileParams() .addFileWrapperParams():这里是支持一个key传递多个文本参数,也支持一个key传递多个文件参数,详细也看上面的http协议连接。
    •  

      • .Response对象介绍

    • body:当前返回的数据,T即为数据的泛型。使用方法body()获取该值。如果请求成功,回调onSuccess(),该字段为convertResponse()解析数据后返回的数据。如果发生异常,回调onError(),该字段值为null
    • throwable:如果发生异常,回调onError(),该字段保存了当前的异常信息。如果请求成功,回调onSuccess(),该字段为null。使用方法getException()获取该值。
    • isFromCache:表示当前的数据是来自哪里,true:来自缓存,false:来自网络。使用方法isFromCache()获取该值。
    • rawCall:表示当前请求的真正okhttp3.Call对象。使用方法getRawCall()获取该值。
    • rawResponse:表示当前请求服务端真正返回的okhttp3.Response对象,注意:如果数据来自缓存,该对象为null,如果来自网络,该对象才有值。使用方法getRawResponse()获取该值。
    • 另外,该对象还有以下几个方法:

    • code():http协议的响应状态码,如果数据来自网络,无论成功失败,该值都为真实的响应码,如果数据来自缓存,该值一直为-1。
    • message():http协议对响应状态码的描述信息,如果数据来自网络,无论成功失败,该值都为真实的描述信息,如果数据来自缓存,该值一直为null
    • headers():服务端返回的响应头信息,如果数据来自网络,无论成功失败,该值都为真实的头信息,如果数据来自缓存,该值一直为null
    • isSuccessful():本次请求是否成功,判断依据是是否发生了异常。
    • 如果你要下载文件,可以这么写。

      FileCallback具有三个重载的构造方法,分别是

      FileCallback():空参构造
      FileCallback(String destFileName):可以额外指定文件下载完成后的文件名
      FileCallback(String destFileDir, String destFileName):可以额外指定文件的下载目录和下载完成后的文件名

      文件目录如果不指定,默认下载的目录为 sdcard/download/,文件名如果不指定,则按照以下规则命名:

      1.首先检查用户是否传入了文件名,如果传入,将以用户传入的文件名命名
      2.如果没有传入,那么将会检查服务端返回的响应头是否含有Content-Disposition=attachment;filename=FileName.txt该种形式的响应头,如果有,则按照该响应头中指定的文件名命名文件,如FileName.txt
      3.如果上述响应头不存在,则检查下载的文件url,例如:http://image.baidu.com/abc.jpg,那么将会自动以abc.jpg命名文件
      4.如果url也把文件名解析不出来,那么最终将以"unknownfile_" + System.currentTimeMillis()命名文件

      这里面有个新对象叫Progress,关于这个对象的解释,看这里我进行了专门的讲解

      6.上传String类型的文本

      一般此种用法用于与服务器约定的数据格式,当使用该方法时,params中的参数设置是无效的,所有参数均需要通过需要上传的文本中指定,此外,额外指定的header参数仍然保持有效。

      默认会携带以下请求头

      Content-Type: text/plain;charset=utf-8

      如果你对请求头有自己的要求,可以使用这个重载的形式,传入自定义的content-type

      // 比如上传xml数据,这里就可以自己指定请求头 upString("这是要上传的长文本数据!", MediaType.parse("application/xml"))

      7.上传JSON类型的文本

      该方法与upString没有本质区别,只是数据格式是json,一般来说,需要自己创建一个实体bean或者一个map,把需要的参数设置进去,然后通过三方的Gson或者fastjson转换成json对象,最后直接使用该方法提交到服务器。

      默认会携带以下请求头,请不要手动修改,okgo也不支持自己修改

      Content-Type: application/json;charset=utf-8

      8.上传文件

      上传文件支持文件与参数一起同时上传,也支持一个key上传多个文件,以下方式可以任选

      特别要注意的是

      1). 很多人会说需要在上传文件到时候,要把Content-Type修改掉,变成multipart/form-data,就像下面这样的。其实在使用OkGo的时候,只要你添加了文件,这里的的Content-Type不需要你手动设置,OkGo自动添加该请求头,同时,OkGo也不允许你修改该请求头。

      Content-Type: multipart/form-data; boundary=f6b76bad-0345-4337-b7d8-b362cb1f9949

      2). 如果没有文件,那么OkGo将自动使用以下请求头,同样OkGo也不允许你修改该请求头。

      Content-Type: application/x-www-form-urlencoded

      3). 如果你的服务器希望你在没有文件的时候依然使用multipart/form-data请求,那么可以使用.isMultipart(true)这个方法强制修改,一般来说是不需要强制的。

      有人说他有很多文件,不知道数量,又要一个文件对应一个key该怎么办,其实很简单,把调用链断开,用循环添加就行了嘛。 

      9.取消请求

      之前讲到,我们为每个请求前都设置了一个参数tag,取消就是通过这个tag来取消的。通常我们在Activity中做网络请求,当Activity销毁时要取消请求否则会发生内存泄露,那么就可以在onDestory()里面写如下代码:

      注意以下取消的请求不要全部用,自己按需要写,我只是写出来,告诉你有这么几个方法。 

      10.同步请求

      同步请求有两种方式,第一种是返回原始的Response对象,自行解析网络数据,就像这样: 

      或者可以返回解析解析完成的对象,如果你使用过Retrofit,那么你对这个Call对象一定不会陌生,这里面有个方法是converter(),需要传递一个Converter接口,作用其实就是解析网络返回的数据,你也可以自定义Converter代码如下: 

      11. https请求

      https的请求和http请求一模一样,只需要在初始化配置一下,详细的https配置方法点击这里

      12.参数的顺序

      添加headersparams的方法各有三处,在提交的时候,他们是有顺序的,如果对提交顺序有需要的话,请注意这里

    • 第一个地方,全局初始化时添加 

    • 第二个地方,CallbackonStart()方法中添加 

    • 第三个地方,执行网络请求的时候添加 

    • 那么,最终执行请求的参数的添加顺序为

      Header顺序: HKAAA -> HKBBB -> HKEEE -> HKFFF -> HKCCC -> HKDDD
      Params顺序: PKAAA -> PKBBB -> PKEEE -> PKFFF -> PKCCC -> PKDDD

      总结一句话就是,全局添加的在最开始,callback添加的在最后,请求添加的在中间

      如果你觉得好,对你有过帮助,请给我一点打赏鼓励吧,一分也是爱呀!

       

       

    展开全文
  • OkGo详解

    千次阅读 2020-09-08 09:19:22
    什么是OkGo OkGo,基于okhhttp的封装类,你会发现他真的比okhttp简单的多,一个专注于让网络请求更简单的框架,与 RxJava 完美结合,比 Retrofit 更简单易用。 二.主要功能 1)基本的 get、post、put、delete、...
  • OkGo的详解

    万次阅读 2018-12-19 16:05:01
    okgo的简介 该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,...
  • OkGo的封装和基本使用

    万次阅读 2019-06-29 10:43:19
    支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和自签名证书,支持cookie自动管理,支持四种缓存模式缓存网络数据,支持301、302...
  • android okgo 网络请求框架

    千次阅读 2018-10-11 10:25:38
    OkGo - OkHttpUtils-2.0.0升级后改名 OkGo,全新完美支持RxJava 项目地址:https://github.com/jeasonlzy,欢迎star,欢迎issue 该库是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。...
  • 使用说明参考:https://github.com/jeasonlzy/okhttp-OkGo 实测相当不错,推荐给大家 该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传...
  • Android框架之路——OkGo的使用

    万次阅读 多人点赞 2017-05-10 22:26:59
    支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和自签名证书,支持超时自动重连,支持cookie与session的自动管理,支持四种缓存...
  • okhttp-OkGo

    千次阅读 2017-01-12 11:09:08
    OkGo - OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持RxJava 该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,...
  • OkGo与Glide

    2019-09-03 20:43:31
    OkGo框架 用来处理网络请求的框架 功能:上传,下载 OkGo主要功能 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString,upJson,upBytes,upFile等up类方法上传特定数据 支持一个key...
  • OkGO使用详解

    千次阅读 2018-02-27 14:59:12
    优势三:方便易用的扩展接口,可以添加全局的公共参数,全局拦截器,全局超时时间,更可以对单个请求定制拦截器,超时时间,请求参数修改等等,在使用上更是方便,原生支持的链式调用让你的请求更加清晰。...
  • OkGo请求数据

    2019-07-16 09:12:53
    OkGo主要功能 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString,upJson,upBytes,upFile等up类方法上传特定数据 支持一个key上传一个文件,也可以一个key上传多个文件,也...
  • Android--OKGO使用

    千次阅读 2019-02-27 22:41:35
    支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和自签名证书,支持超时自动重连,支持cookie与session的自动管理,支持四种缓存...
  • OKGO&Glide框架

    2019-12-03 19:29:46
    OKGO&Glide框架OKGOOKGO主要功能依赖、注意事项依赖:注意:GET&POST&UPLOAD&DOWNLOAD&GETIMGPOST请求数据POST上传文件GET请求JSONGET请求图片下载文件Glide框架三层缓存机制加载本地SD卡图片/...
  • OkGo是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和...
  • OKgo的主要功能

    2019-07-09 21:19:34
    OkGo主要功能 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString,upJson,upBytes,upFile等up类方法上传特定数据 支持一个key上传一个文件,也可以一个key上传多个文件,也...
  • 网络请求框架——OkGo解读(一)——数据的缓存

    千次阅读 多人点赞 2016-10-31 11:50:13
    OkGo —— OkHttpUtils-2.0.0升级后改名 OkGo,全新完美支持RxJava。 该库是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传...
  • OkGo框架 用来处理网络请求的框架 功能:上传,下载 OkGo主要功能 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString,upJson,upBytes,upFile等up类方法上传特定数据 ...
  • OkGo框架 用来处理网络请求的框架 功能:上传,下载 OkGo主要功能 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString,upJson,upBytes,upFile等up类方法上传特定数据 支持一个...
  • OkHttpUtils | okhttp-OkGo的使用,完美支持RxJava

    万次阅读 多人点赞 2016-10-10 20:39:10
    OkGo - OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持RxJava 该库是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多...
  • 所有请求的基类,其中泛型R主要用于属性设置方法后,返回对应的子类型,以便于实现链式调用 public abstract class BaseRequestR extends BaseRequest> { protected String url; protected String baseUrl; ...
  • OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持 RxJava,比 Retrofit 更简单易用。
  • Android okHttp封装库(2) -- okhttp-OkGo

    千次阅读 2016-12-08 14:34:17
    OkGo - OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持RxJava 该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度...
  • 支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数一起上传),链式调用,可以自定义返回对象,支持Https和自签名证书,支持cookie自动管理,支持四种缓存模式缓存网络数据,支持301、302...
  • OkGo - OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持RxJava该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,...
  • OkGo - OkHttpUtils-2.0.0 升级后改名 OkGo,全新完美支持RxJava 该库是封装了okhttp的网络框架,可以与RxJava完美结合,比Retrofit更简单易用。支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 187
精华内容 74
关键字:

okgo链式