Android OkHttp Retrofit RxJava

最新推荐文章于 2024-03-22 08:54:46 发布
最新推荐文章于 2024-03-22 08:54:46 发布
阅读量1.2k 收藏 7
点赞数 3
分类专栏： Android Android成长之路 文章标签： Android OkHttp Retrofit RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuyuxing24/article/details/78019745
版权

一，概述

Android移动端开发网络框架有很多种，最常用的有Volley、OkHttp、Retrofit(Retrofit底层也是默认使用OkHttp实现)。Volley之前有分析过(Android Volley 简单分析)，接下来就来看下OkHttp，Retrofit的使用，以及使用OkHttp、Retrofit、RxJava对网络请求做第二次封装。

二，OkHttp

OkHttp是Android端最火热的轻量级网络请求框架。

2.1，网络请求的简单介绍

       每次网络请求都是一次数据交互的过程：客户端和服务端建立连接->客户端发送请求都服务端->服务器应答内部做一些列的处理再把数据返回给客户端->客户端接收到数据断开连接。这是最简单的一次网络数据交互请求。作为客户端就两件事第一件就是封装网络请求Request，第二件就是解析网络请求Response。

       网络请求Request由三个部分组成：

  • 请求行：包括请求类型（GET、POST、PUT、DELETE、OPTION、PATCH、TRACE、CONNECT）、请求url、HTTP协议以及版本。
  • 请求头：网络请求过程中制定的一些约束，键值对的形式表现，每个key都有它特定的意义（比如key：Content-Type约定请求和响应的HTTP body内容编码类型、key：Accept约定请求接受的媒体类型），
  • 请求体body：有些请求类型是没有网络请求体比如DELETE、GET、OPTIONS等等。请求体和请求头里面Content-Type要一一对应，客户端发送请求到服务端的时候服务端会按照请求头里面的Content-Type类型来解码请求体body内容。
    注：Content-Type用于约束HTTP请求body和应答body的编码格式，常见的Content-Type类型有：application/x-www-form-urlencoded :body被编码成键值对的形式（表单提交）、multipart/form-data：body被编码成二进制的形式（多用于文件上传） 、application/json：body被编码成json字符串形式。
           （个人觉得对用GET请求，Content-Type没啥大的用处，如果服务端没有检查的时候可以不传递）

       网络应答Response也是由三个部分组成：

  • 响应行：包括两个部分：HTTP协议类型以及版本、HTTP状态码以及状态描述。
  • 响应头：和请求头类似也是以键值对的形式出现，里面会放服务端要告诉客户端的一些信息，比如缓存相关一些列的规则(key：Cache-Control)，响应体body的编码格式(key：Content-Type)。
  • 响应体body：这个才是我们每次网络请求最终要得到的干货（解析要根据响应头里面Content-Type设置的格式）。
2.2，OkHttp里面一些常用的类，api

       上面简单的了解了下网络请求和应答的组成部分。接下来咱们就来看下OkHttp使用过程中接触最多的类：OkHttpClient、Call、Request、RequestBody、Response、ResponseBody、Interceptor、CookieJar。

  • OkHttpClient：设置一些统一的参数，比如超时设置、拦截器的添加等等。OkHttpClient使用的是建造者模式，那得瞧下OkHttpClient.Builder都有那些public方法了。
    /**
     * 设置connect超时时间
     */
    public OkHttpClient.Builder connectTimeout(long timeout, TimeUnit unit);

    /**
     * 数据read超时时间
     */
    public OkHttpClient.Builder readTimeout(long timeout, TimeUnit unit);

    /**
     * 数据write超时时间
     */
    public OkHttpClient.Builder writeTimeout(long timeout, TimeUnit unit);

    /**
     * 设置HTTP代理连接(通过别的地址去上网)
     */
    public OkHttpClient.Builder proxy(Proxy proxy);

    /**
     * 设置HTTP的自动代理选择器(有时候需要根据不同的网址旋转不同的代理)
     */
    public OkHttpClient.Builder proxySelector(ProxySelector proxySelector);

    /**
     * 设置cookie持久化的处理
     */
    public OkHttpClient.Builder cookieJar(CookieJar cookieJar);

    /**
     * 设置缓存
     */
    public OkHttpClient.Builder cache(Cache cache);

    /**
     * 设置DNS解析服务器
     */
    public OkHttpClient.Builder dns(Dns dns);

    /**
     * SocketFactory创建socket的工厂类，可以自己去实现(咱们一般很少会去改变这个)
     */
    public OkHttpClient.Builder socketFactory(SocketFactory socketFactory);

    /**
     * SSLSocketFactory创建加密socket的工厂类(咱们一般很少会去改变这个)https时候用到
     */
    public OkHttpClient.Builder sslSocketFactory(SSLSocketFactory sslSocketFactory);

    /**
     * X509TrustManager
     */
    public OkHttpClient.Builder sslSocketFactory(SSLSocketFactory sslSocketFactory, X509TrustManager trustManager);

    /**
     * 设置服务器验证我们访问的IP地址方式
     */
    public OkHttpClient.Builder hostnameVerifier(HostnameVerifier hostnameVerifier);

    /**
     * 设置那些证书是可以信任的
     */
    public OkHttpClient.Builder certificatePinner(CertificatePinner certificatePinner);

    /**
     * http值401的时候，会调用设置类里面的方法(比如token过期之类的，然后咱们可以在这里面重新设置新的token)
     */
    public OkHttpClient.Builder authenticator(Authenticator authenticator);

    /**
     * 代理服务器需要确认身份
     */
    public OkHttpClient.Builder proxyAuthenticator(Authenticator proxyAuthenticator);

    /**
     * 自定义链接池线程数量啥的，
     */
    public OkHttpClient.Builder connectionPool(ConnectionPool connectionPool);

    /**
     * 是否允许https重定向
     */
    public OkHttpClient.Builder followSslRedirects(boolean followProtocolRedirects);

    /**
     * 是否允许http重定向
     */
    public OkHttpClient.Builder followRedirects(boolean followRedirects);

    /**
     * 是否自动重连
     */
    public OkHttpClient.Builder retryOnConnectionFailure(boolean retryOnConnectionFailure);

    /**
     * 异步任务的Call会放到Dispatcher调度器里面去处理，咱们可以自己去处理调度的逻辑
     */
    public OkHttpClient.Builder dispatcher(Dispatcher dispatcher);

    /**
     * OkHttp支持的协议类型
     */
    public OkHttpClient.Builder protocols(List<Protocol> protocols);

    /**
     * HTTPS具体的安全与连接的决定是由ConnectionSpec接口实现(可以用一组自定义TLS版本和密码套件建立自己的连接规格)
     */
    public OkHttpClient.Builder connectionSpecs(List<ConnectionSpec> connectionSpecs);

    /**
     * 获取应用拦截器
     */
    public List<Interceptor> interceptors();

    /**
     * 添加应用拦截器
     */
    public OkHttpClient.Builder addInterceptor(Interceptor interceptor);

    /**
     * 获取网络拦截器
     */
    public List<Interceptor> networkInterceptors();

    /**
     * 添加网络拦截器
     */
    public OkHttpClient.Builder addNetworkInterceptor(Interceptor interceptor);

OkHttpClient相对于OkHttpClient.Builder来说最常用的就多了两个比较重要的方法。

    /**
     * 通过传入网络请求的封装，返回一个Call调用，通过Call来发起或者取消网络请求。
     * @param request 网络请求的封装
     * @return 返回一个Call调用
     */
    public Call newCall(Request request);

    /**
     * 获取该OkHttpClient对应的Builder(为了保证OkHttpClient在整个应用中共用一个连接池和缓存)
     * @return OkHttpClient.Builder
     */
    public OkHttpClient.Builder newBuilder();
  • Request：OkHttp网络请求的封装，包含 url，method，headers，body，CacheControl ，tag。发送给服务器的时候会按照HTTP协议要求的格式组成对应的报文发送。
    /**
     * 设置当前request的url
     */
    public Request.Builder url(HttpUrl url);

    /**
     * 设置当前request的url
     */
    public Request.Builder url(String url);

    /**
     * 设置当前request的url
     */
    public Request.Builder url(URL url);

    /**
     * 添加当前请求header(key-value的形式如果当前header的key存在则会替换)
     */
    public Request.Builder header(String name, String value);

    /**
     * 添加当前请求header(允许存在多个相同的key)
     */
    public Request.Builder addHeader(String name, String value);

    /**
     * 移除当前请求header
     */
    public Request.Builder removeHeader(String name);

    /**
     * 设置请求头(之前设置的无效)
     */
    public Request.Builder headers(Headers headers);

    /**
     * 设置cache相关的请求头(Cache-Control)
     */
    public Request.Builder cacheControl(CacheControl cacheControl);

    /**
     * GET请求
     */
    public Request.Builder get();

    /**
     * HEAD请求
     */
    public Request.Builder head();

    /**
     * POST请求+BODY
     */
    public Request.Builder post(RequestBody body);

    /**
     * DELETE请求+BODY
     */
    public Request.Builder delete(RequestBody body);

    /**
     * DELETE请求+无BODY
     */
    public Request.Builder delete();

    /**
     * PUT请求+BODY
     */
    public Request.Builder put(RequestBody body);

    /**
     * PATCH请求+BODY
     */
    public Request.Builder patch(RequestBody body);

    /**
     * 自己写请求方式+BODY
     */
    public Request.Builder method(String method, RequestBody body);

    /**
     * 设置当前请求的tag
     */
    public Request.Builder tag(Object tag);
  • RequestBody：用来组装Request请求的body。有些请求的Request是需要body（POST）。
    /**
     * 告诉body的编码格式，和请求头里面的Content-Type对应
     */
    public abstract MediaType contentType();

    /**
     * 告诉body的长度
     */
    public long contentLength() throws IOException {
        return -1;
    }

    /**
     * 通过BufferedSink把body具体的内容写入
     */
    public abstract void writeTo(BufferedSink sink) throws IOException;

    /**
     * static 函数返回RequestBody，body是字符串的形式
     */
    public static RequestBody create(MediaType contentType, String content);

    /**
     * static 函数返回RequestBody，body是ByteString形式
     */
    public static RequestBody create(final MediaType contentType, final ByteString content);

    /**
     * static 函数返回RequestBody，body是byte[]形式
     */
    public static RequestBody create(final MediaType contentType, final byte[] content);

    /**
     * static 函数返回RequestBody，body是byte[]形式,多了个byte[]的起始位置和写入的长度
     */
    public static RequestBody create(final MediaType contentType, final byte[] content, final int offset, final int byteCount);

    /**
     * static 函数返回RequestBody,body的内容是File
     */
    public static RequestBody create(final MediaType contentType, final File file);

RequestBody有两个经常用到的子类FormBody（RequestBody是表单的形式，键值对的形式。通过FormBody.Builder来构造）、MultipartBody（RequestBody包含多段数据，多用于文件的上传通过MultipartBody.Builder来构造）。

  • Call：OkHttp网络请求的执行类，或者请求的动作说由他发起。里面的api也非常的简单。
    /**
     * 获取request(网络请求参数的封装)
     */
    Request request();

    /**
     * 同步请求
     * @throws IllegalStateException 当这个Call已经在请求的时候抛出IllegalStateException
     */
    Response execute() throws IOException;

    /**
     * 异步请求数据
     * @throws IllegalStateException 当这个Call已经在请求的时候抛出IllegalStateException
     */
    void enqueue(Callback responseCallback);

    /**
     * 取消当前请求
     */
    void cancel();

    /**
     * 网络请求是否在进行(可以在请求之前判断下)
     */
    boolean isExecuted();

    /**
     * 网络请求是否取消
     */
    boolean isCanceled();
  • Response：OkHttp网络应答的封装。网络请求获取到服务器应答的内容或者缓存的内容之后会解析到Response里面去。Response里面比较重要的应该是Headers、ResponseBody。
    /**
     * 获取当前请求的request
     */
    public Request request();

    /**
     * 获取当前请求的协议例如{@link Protocol#HTTP_1_1} or {@link Protocol#HTTP_1_0}.
     */
    public Protocol protocol();

    /**
     * 获取当前请求的状态码
     */
    public int code();

    /**
     * 当前请求是否成功[状态码200..300)
     */
    public boolean isSuccessful();

    /**
     * 当前请求状态码对应的message
     */
    public String message();

    /**
     * 获取当前请求SSL/TLS握手协议验证时的信息
     */
    public Handshake handshake();

    /**
     * 获取当前请求返回的header
     */
    public List<String> headers(String name);

    /**
     * 获取当前请求返回的header
     */
    public String header(String name);

    /**
     * 获取当前请求返回的header(如果不存在返回默认值)
     */
    public String header(String name, String defaultValue);

    /**
     *  取出当前请求返回的body(设置字节的长度)
     */
    public ResponseBody peekBody(long byteCount) throws IOException;

    /**
     * 取出当前请求返回的body
     */
    public ResponseBody body();

    /**
     * 是否重定向了
     */
    public boolean isRedirect();

    /**
     * 网络返回的原声数据(如果未使用网络，则为null)
     */
    public Response networkResponse();

    /**
     * 从cache中读取的网络原生数据
     */
    public Response cacheResponse();

    /**
     * 网络重定向后的,存储的上一次网络请求返回的数据
     */
    public Response priorResponse();

    /**
     * 获得所有当前response所有支持的认证
     */
    public List<Challenge> challenges();

    /**
     * response里面header Cache-Control 里面的信息
     */
    public CacheControl cacheControl();

    /**
     * 发起请求的时间
     */
    public long sentRequestAtMillis();

    /**
     * 收到返回数据时的时间
     */
    public long receivedResponseAtMillis();
  • ResponseBody：Response里面的body数据封装。
    /**
     * response对应body的Content-Type，response(body的编码类型)
     */
    public abstract MediaType contentType();

    /**
     * response对应body的长度
     */
    public abstract long contentLength();

    /**
     * 获取response对应body的输入流用来读取数据流
     */
    public final InputStream byteStream();

    /**
     * 获取response对应body的BufferedSource(类似于InputStream的输入流用来读取数据)
     */
    public abstract BufferedSource source();

    /**
     * 获取response对应body的byte数组
     */
    public final byte[] bytes() throws IOException;

    /**
     * 获取response对应body的Reader(所有字符输入流的父类)
     */
    public final Reader charStream();

    /**
     * 获取response对应body的String
     */
    public final String string() throws IOException;

    /**
     * 关闭输入流
     */
    public void close();

    /**
     * static函数返回ResponseBody，数据源是String
     */
    public static ResponseBody create(MediaType contentType, String content);

    /**
     * static函数返回ResponseBody，数据源是byte数组
     */
    public static ResponseBody create(final MediaType contentType, byte[] content);

    /**
     * static函数返回ResponseBody，数据源是BufferedSource
     */
    public static ResponseBody create(final MediaType contentType, final long contentLength, final BufferedSource content);
  • Interceptor：拦截器是OkHttp的精髓所在，是一种能够监控，重写，重试调用的强大机制。拦截器在OkHttp里面是以链式的形式调用的。在intercept（）函数里面先charin.request()得到Request做网络请求之前的处理，然后char.proceed(request) 得到Response做网络请求之后的处理。OkHttp里面拦截器两种：应用拦截器、网络拦截器。按照我的理解应用拦截器提供给我们设置一些全局的处理比如网络请求之前我们先判断网络是否连接等等，应用拦截器是每次请求都会被调用到并且只会调用一次。网络拦截器确不同，当从缓存里面拿到数据的时候网络拦截器都不会被调用到，重连的情况网络拦截器可能调用多次。当有些错误要重连的时候就可以用网络拦截器来实现。
    /**
     * 自定义拦截器的时候需要重写的方法
     * 1. 调用charin.request() 得到Request做网络请求之前的处理。
     * 2. char.proceed(request) 得到Response
     * 3. 得到Response做网络请求之后的处理，把Response返回
     */
    Response intercept(Chain chain) throws IOException;

    interface Chain {
        Request request();

        Response proceed(Request request) throws IOException;

        /**
         * Returns the connection the request will be executed on. This is only available in the chains
         * of network interceptors; for application interceptors this is always null.
         */
        @Nullable
        Connection connection();
    }
  • CookieJar：OkHttp提供给我们处理cookie信息的类，里面就两个方法，一个用来保存url对应的Cookie，一个用来获取url对应的Cookie。会通过BridgeInterceptor拦截器把Cookie加到对应Request的请求头里去。
2.3，OkHttp简单使用

       啰里啰嗦说了一大堆的各个类的api，都是为使用OkHttp做铺垫。OkHttp的简单使用分为五个步骤。

  1. OkHttpClient全局参数的设置（每个应用最好使用一个OkHttpClient实例以减少一些缓存和线程的开支，如果OkHttpClient有变化的时候使用newBuilder()来重新生成OkHttpClient对象）。
  2. Request对象的封装，url、method、编码类型、RequestBody的选择。
  3. OkHttpClient调用newCall（）函数，参数是Request的到Call对象。
  4. Call对象执行网络请求，有异步同步两种方式。
  5. 得到网络应答Response解析出我们需要的结果。

OkHttp最简单的一个post请求（body参数是表单的形式）

        OkHttpClient client = new OkHttpClient();

        RequestBody body = new FormBody.Builder().add("id", "1")
                                                 .build();
        Request request = new Request.Builder()
            .url("http://192.168.5.14:3033")
            .post(body)
            .build();

        client.newCall(request).enqueue(new Callback(){
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {

            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                //TODO:response.body()
            }
        });

OkHttp最简单的一次get请求（参数在url里面）

        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
            .url("http://192.168.5.14:3033/books?id=1")
            .get()
            .build();

        client.newCall(request).enqueue(new Callback(){
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {

            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                //TODO:response.body()
            }
        });

三，Retrofit

Retrofit官网就一句话介绍（Retrofit turns your HTTP API into a Java interface.）通过注解的方式来实现HTTP API。Retrofit底层对网络的访问默认也是使用OkHttp，Retrofit非常适合于restful url格式的请求。

3.1，Retrofit里面注解

  • method annotation （方法注解，写在方法前面的注解）

    名称含义
    @GET表明HTTP请求为GET请求
    @POST表明HTTP请求为POST请求
    @PUT表明HTTP请求为PUT请求
    @DELETE表明HTTP请求为DELETE请求
    @HEAD表明HTTP请求为DELETE请求
    @OPTIONS表明HTTP请求为OPTIONS请求
    @HTTP通过@HTTP注解指定http协议的请求方法,路径，是否允许body。前面几种都可以 用这个实现
    @PATCH表明HTTP请求为PATCH请求
    @Headers静态添加请求头（添加固定的请求头）
    @Multipart表明发起HTTP请求的RequestBody是Multipar方式
    @FormUrlEncoded表明发起HTTP请求的RequestBody是form表单方式

  • parameter annotation(参数注解，写在参数里面的注解)

    名称含义
    @Header动态添加请求Header
    @HeaderMap以map形式传入的多个header键值对
    @BodyHTTP请求的body
    @Field表明此参数用作HTTP请求的form表单参数
    @FieldMap以map形式传入的form表单参数
    @Part表明参数为Http的multipart参数之一
    @PartMap以map形式传入的multipart参数表现
    @Path用于动态替换URL路径中的path_holder
    @Query静态添加请求头（添加固定的请求头）
    @QueryName类比@Query，相当于没有value，只有key
    @QueryMap以map传入的GET方法的query参数
    @Url用来动态指定一个Url地址

    估计参数注解里面最难理解的就是@Url注解了，@Url设置的参数最终会和base url按照一定的规则生成新的url，有下面几种情况。

    Retrofit.Builder() 设置的 base url@Url最终的url解释
    http://192.168.5.14:3033/v1/bookshttp://192.168.5.14:3033/v1/books@url使用的是相对路径，直接连接在base url的scheme host port后面
    http://192.168.5.14:3033/v1//v2/bookshttp://192.168.5.14:3033/v2/books@url使用的是绝对路径，接连接在base url
    http://192.168.5.14:3033/v1/http://192.168.5.14:3033/bookshttp://192.168.5.14:3033/books@url是一个完整的路径，直接替换base url

    @url使用的时候还有几点要注意：1. @Url只能设置一次、2. @Url @Path不能同时使用、3. @Url必须在@Query的前面、4. 使用@Url 就不能在方法注解里面@GET,@POST等里面再写路径。

3.2，Retrofit Converter

       Retrofit提供的数据转换器，主要转换三种数据，一个是RequestBody数据转换（@Part、@PartMap、@Body里面设置的参数）、一个是ResponseBody数据的转换（服务器的应答数据转换成想要的类型）、一个是对象转换为String（@Path、@Query、@QueryName、@QueryMap、@Header、@HeaderMap、@Field、@FieldMap参数设置的对象转换为String）。和数据转换密切相关的就两个类Converter

    /**
     * 转换必须实现的方法
     */
    T convert(F value) throws IOException;

    /** Creates {@link Converter} instances based on a type and target usage. */
    abstract class Factory {
        /**
         * ResponseBody转换成需要的对象，生成Converter<ResponseBody, ?> -> convert 把ResponseBody转换成需要的对象
         */
        public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit);

        /**
         * 对象装换成RequestBody，生成Converter<?, RequestBody> -> convert 得到RequestBody
         */
        public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
                                                                        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit);

        /**
         * 对象装换成String，生成Converter<?, String> -> convert 得到String
         */
        public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations, Retrofit retrofit);

    }

Retrofit github上已经默认给我们提供了七八种转换了，用的最多的应该就是GsonConverterFactory和ScalarsConverterFactory，一个是转换成JSON一个是转换成字符串，对应的gradle如下。

compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'

当我们要自定义Retrofit Converter的时候可以仿照Retrofit提供的几种Converter来实现。

3.3，Retrofit CallAdapter

       Retrofit底层的实现是OkHttp，OkHttp网络的执行都是通过OkHttp里面的Call来发起的，Retrofit 里面的CallAdapter就是对OkHttp的Call家的一个适配器。通过这种方式咱们上层调用就不用关心内部的实现，完全解耦。密切相关的类就三个CallAdapter.Factory、CallAdapter、Call。实现CallAdapter.Factory里面的get()方法得到CallAdapter对象，CallAdapter对象里面的adapt()函数又把Call适配成了，我们自定义的对象。在自定义的对象里面会调用到Call里面的一些方法(网络访问相关的一些方法)。
CallAdapter.Factory类里面的一些方法。

    /**
     * 返回一个CallAdapter对象, 把Call适配成自定义对象，在自定义对象里面调用Call里面的方法。
     */
    public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
                          Retrofit retrofit);

    /**
     * 举个例子 当Retrofit的注解是这样些时候  
     * @GET("books/{id}")
     * Observable<BookBean> getBookByPath(@Path("id") int id);
     * index = 0 的时候 返回的就是BookBean
     */
    protected static Type getParameterUpperBound(int index, ParameterizedType type);

    /**
     * 
     * 举个例子 当Retrofit的注解是这样些时候  
     * @GET("books/{id}")
     * Observable<BookBean> getBookByPath(@Path("id") int id);
     * 返回的就是Observable 的class
     */
    protected static Class<?> getRawType(Type type);

CallAdapter就两个方法

    /**
     * response最终要得到的类型，举个例子
     * @GET("books/{id}")
     * Observable<BookBean> getBookByPath(@Path("id") int id);
     * BookBean就是最终要得到的类型
     */
    Type responseType();

    /**
     * Call适配成自定义的对象
     */
    T adapt(Call<R> call);

总而言之不管怎么适配，最终都是要用过Call来调用网络请求，自定义的适配对象也是会拿到到Call对象做一些列的动作。Retrofit最常用的应该就是RxJavaCallAdapterFactory RxJava的适配和ExecutorCallAdapterFactory默认自带的适配。当要自定义自己的适配的时候可以参考这两个适配的实现过程。

 //RxJava2.0的适配gradle
 compile 'com.squareup.retrofit2:adapter-rxjava:2.3.0'
3.4，Retrofit 的使用

       上面很简单的介绍了Retrofit的注解，转换器，适配器。接下里就是怎么使用了。Retrofit使用起来就要比OkHttp简单多了，不用自己去设置RequestBody通过注解就会自动生成。最简单的一次使用如下：

注解接口编写

    @GET("books/{id}")
    Call<BookBean> getBookByPath(@Path("id") int id);

Retrofit全局配置

        Retrofit retrofit = new Retrofit.Builder().addConverterFactory(GsonConverterFactory.create())
                                                  .baseUrl("http://192.168.5.14:3033/v1/")
                                                  .build();
        mNetworkApi = retrofit.create(AppRetrofitApi.class);

网络请求

        Call<BookBean> requestCall = mNetworkApi.getBookByPath(0);
        requestCall.enqueue(new Callback<BookBean>() {
            @Override
            public void onResponse(@NonNull Call<BookBean> call, @NonNull Response<BookBean> response) {
                BookBean body = response.body();
                if (body != null) {
                    //TODO:body.toString()
                }
            }

            @Override
            public void onFailure(@NonNull Call<BookBean> call, Throwable t) {

            }
        });

四，RxJava

RxJava总结起来就是异步，简洁。RxJava提供了各种各样的操作符，合适的时机使用合适的操作符会是代码逻辑非常的简单。因为RxJava里面的操作符特别的多，接下来就挑几个OkHttp+Retrofit+RxJava二次封装的时候使用到的一些操作符。

  1. onErrorResumeNext：让原Observable在遇到错误时开始发送第二个Observable的数据序列，我们会用这个操作符做统一的错误处理。原Observable所有的错误都会进入到onErrorResumeNext操作符里面将各种各样的错误转换成自定义的错误。
    这里写图片描述
  2. compose：对 Observable 整体的变换，将源Observable按照自定义的方式转化成另外一个新的Observable，利用传入的 Transformer 对象的 call 方法直接对自身进行处理。可以在这个操作符里面做网络是否连接的判断，当网络未连接的时候直接Observable.error（）结束这个流程。或者配合Rxlifecycle来使用。
  3. subscribeOn：线程变换操作符，指定的是它之前的操作所在的线程（由OnSubscribe指定线程）。
  4. unsubscribeOn：有些 Observable 会依赖一些资源，当该 Observable 完成后释放这些资源。如果释放资源比较耗时的话，可以通过 unsubscribeOn 来指定 释放资源代码执行的线程。
  5. observeOn：线程变换操作符，指定的是它之后的操作所在的线程（由Subscriber指定线程）。
  6. zipWith：把两个Observable发射的数据组合在一起，我们要自己提供Func2告诉两个Observable结果怎么组合成新的结果。实际使用的时候当两个网络请求要都完成的时候我们才能做下一步的动作可以用zipWith操作符。
    这里写图片描述
  7. flatMap：将一个发射数据的Observable变换为多个Observable，然后将它们发射的数据合并后放进一个单独的Observable。我们可以用flatMap来做顺序操作。实际使用的时候当前后两个网络请求有关联的时候，我们可以用flatMap操作符来实现。
    这里写图片描述

五，OkHttp+Retrofit+RxJava

前面介绍了一堆，都是为了更好的对OkHttp+Retrofit+RxJava做二次封装。期间也参考了很多网上其他的写法，在别人的写法之上，二次封装实现的目标：

  • 每个网络请求都可以单独的设置超时（OkHttpClient.newBuilder()的使用）。
  • 每个网络请求都可以单独的设置Converter.Factory。
  • 每个网络请求都可以设置访问等级，wifi访问，数据访问（RxJava compose操作符的使用）。
  • 支持多个网络请求同时完成的情况下做下一步动作的需求（两个请求可以直接使用ProtocolsClient里面protocolsRequestZipWith（）函数实现，超过两个请求就要自己使用RxJava zipWith操作符写链式结构了）。
  • 支持多个网络请求相关联的需求，下一个请求需要上一个请求结果的需求（两个请求可以直接使用ProtocolsClient里面protocolsRequestFlatMap（）函数实现，超过两个请求就要自己使用RxJava flatMap操作符写链式结构了）。

使用起来也相对的简单：1. 每次请求还得像Retrofit一样写个注解的接口（注解的使用）、2. 继承ProtocolsBaseRequest来实现一些不能在注解里面实现的参数（time out 等等）、3. ProtocolsClient里面调用相应的方法（ProtocolsClient是个单利，是请求的入口）。

5.1，单个网络请求的实现
    /**
     * 网络请求
     *
     * @param context              context
     * @param request              request
     * @param callback             callback
     * @param lifecycleTransformer transformer
     * @param <T>                  类型
     */
    public <T> void protocolsRequest(Context context,
                                     ProtocolsBaseRequest<T> request,
                                     ProtocolsBaseCallback<T> callback,
                                     LifecycleTransformer<T> lifecycleTransformer) {
        getProtocolsRequestObservable(context, request, lifecycleTransformer).subscribe(
            new ProtocolsSubscriber<>(context, request, callback));
    }
5.2， 两个网络同时执行完在返回结果的实现（ProtocolsZipFunc告诉两个请求的结果怎么合并成一个新的结果）
    /**
     * 合并两个请求的结果
     *
     * @param context    context
     * @param requestOne request one
     * @param requestTwo request two
     * @param func       合并我们要得到的结果类型
     * @param callback   callback
     * @param <P>        request one 类型
     * @param <N>        request two 类型
     * @param <R>        最终callback返回类型
     */
    public <P, N, R> void protocolsRequestZipWith(Context context,
                                                  ProtocolsBaseRequest<P> requestOne,
                                                  ProtocolsBaseRequest<N> requestTwo,
                                                  final ProtocolsZipFunc<P, N, R> func,
                                                  ProtocolsBaseCallback<R> callback) {

        Func1<Throwable, Observable<R>> mErrorResume = new Func1<Throwable, Observable<R>>() {
            @Override
            public Observable<R> call(Throwable throwable) {
                return Observable.error(transformerException(throwable));
            }
        };

        Observable<P> observableOne = getProtocolsRequestObservable(context, requestOne);
        Observable<N> observableTwo = getProtocolsRequestObservable(context, requestTwo);
        Observable<R> observable = observableOne.zipWith(observableTwo, new Func2<P, N, R>() {
            @Override
            public R call(P p, N n) {
                return func.call(p, n);
            }
        })
                                                //                                              .retryWhen(new RetryNetworkException())
                                                .onErrorResumeNext(mErrorResume)
                                                .subscribeOn(Schedulers.io())
                                                .unsubscribeOn(Schedulers.io())
                                                .observeOn(AndroidSchedulers.mainThread());

        observable.subscribe(new ProtocolsSubscriber<>(context, null, callback));
    }
5.3， 两个网络请求相互依赖的实现（ProtocolsFlatMapFunc告诉依赖的关系）
    /**
     * 顺序执行两个请求，并且前后有依赖
     *
     * @param context    context
     * @param requestOne request one
     * @param requestTwo request two
     * @param func       上下来两个请求依赖处理
     * @param callback   callback
     * @param <P>        request one 类型
     * @param <N>        request two 类型
     */
    public <P, N> void protocolsRequestFlatMap(final Context context,
                                               final ProtocolsBaseRequest<P> requestOne,
                                               final ProtocolsBaseRequest<N> requestTwo,
                                               final ProtocolsFlatMapFunc<P, N, ProtocolsBaseRequest<N>> func,
                                               ProtocolsBaseCallback<N> callback) {

        final Observable<P> observableOne = getProtocolsRequestObservable(context, requestOne);

        Func1<Throwable, Observable<N>> mErrorResume = new Func1<Throwable, Observable<N>>() {
            @Override
            public Observable<N> call(Throwable throwable) {
                return Observable.error(transformerException(throwable));
            }
        };

        Observable<N> observable = observableOne.flatMap(new Func1<P, Observable<N>>() {
            @Override
            public Observable<N> call(P t) {
                return getProtocolsRequestObservable(context, func.call(t, requestTwo));
            }
        })
                                                //                                              .retryWhen(new RetryNetworkException())
                                                .onErrorResumeNext(mErrorResume)
                                                .subscribeOn(Schedulers.io())
                                                .unsubscribeOn(Schedulers.io())
                                                .observeOn(AndroidSchedulers.mainThread());

        observable.subscribe(new ProtocolsSubscriber<>(context, null, callback));
    }
5.4， 多个网络请求的实现，就要自己去写链式结构了，参考protocolsRequestFlatMap和protocolsRequestZipWith函数的实现（RxJava flatMap、zipWith操作符的使用）

上面只是简单的解释，更加详细的实现过程，都在源码 https://github.com/tuacy/NetworkFrame

代码里面也有很多需要进一步完善的地方，后面有时间会慢慢的完善上来。

tuacy
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-简单封装OKhttpRetrofitRxjava代码支持参数加密解密按需选择库
08-13
简单封装OKhttp Retrofit Rxjava代码,支持参数加密解密,按需选择库,支持日志库按需选择,支持主动取消请求,支持json,表单请求,暂只支持get,post请求方式两种,支持单点登录,一行代码发起请求
Android开发okhttp+retrofit+rxJava 之文件上传下载
zhanghao_Hulk的专栏
03-21 1899
基于上一篇文章实现了基本的okhttp请求基本用法:https://mp.csdn.net/editor/html/115055910 下面结合retrofit和rxJava实现文件上传下载, 带下载进度,. 基本介绍 .Retrofit是基于okhttp基础上进行高度封装或者包装的产物, 结合rxJava, 可以说是如鱼得水,天作之合, 可以很方便实现网络请求的同步异步切换, 摆脱了以前的AsyncTask和Handler机制. 直接链式写法实现网络切换; 1. 基本实现 retrofit的...
Retrofit-+-RxJava-＋-OkHttp-让网络请求变的简单-封装篇
最新发布
I8929545452_VD的博客
03-22 861
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司19年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
Android中OkHttp和Retrofit的使用
晨曦的博客
04-15 4191
1.1 OkHttp的简介 现在Android中的网络请求框架，基本都是OkHttp和Retrofit一统天下，而Retrofit又是以okhttp为基础，所以系统学习okhttp的使用和原理就很有必要了。 OkHttp是由Square公司开发的一个处理网络请求的开源项目，是目前Android使用中公认最好用、最广泛的网络框架，在接口封装上做的简单易用。从Android4.4开始HttpURLConnection的底层实现采用的是OkHttp。 GitHub地址：https://github.com/
Android ⽹络请求库的使⽤okhttp、retrofit、rxjava
weixin_44236034的博客
11-03 638
安卓逆向的必经之路，首先进行app的请求中的基本原理，以及实操！okhttp,retrofit,rxjava 三者的区别总结1、Okhttp底层是socket 而retrofit,rxjava 都是基于okhttp的。2、retrofit,rxjava 相对来说繁琐一些，但是更加安全，对字段进行了规定直接返回序列号对象。3、其他的希望大家也补充一些。
【Android -- 网络请求】Retrofit + RxJava ＋ OkHttp 网络请求
Kevin Learn Android
03-19 2022
Retrofit 负责请求的数据和请求的结果，使用接口的方式呈现，OkHttp 负责请求的过程，RxJava 负责异步，各种线程之间的切换。
Android OkHttp和Retrofit的区别与联系
残风乱了温柔的博客
01-09 6144
一.OkHttp OkHttp是Square开源的轻量级框架，是一款现代、高效、快速的Android版Http client。 1.OkHttp特性： 它的设计和实现的首要目标便是高效，有如下特性： •支持SPDY、连接池、Gzip和Http缓存（记住第一条可直接推及记起下面四条，感觉萌萌哒^_^）; •支持SPDY，因此可以同一IP多个连接共享同一个socket（SPDY并不是一种...
Android OKHttp与Retrofit与RXJava的使用
Happy__snake的博客
08-12 1816
我们项目当中的每个app都需要用到网络和服务器进行交互，在Android项目开发中使用HTTP协议完成 通信的话，基本上都要用到OkHttp或者Retrofit。
OkHttp+Retrofit+RxJava浅入浅出
XiaoRouniao的博客
10-19 81
nextResponseBodyConverter()方法中获取到addConverterFactory设置的converterFactory对象中的responseBodyConverter()方法返回的Converter对象。5. 使用RxJava进行请求。ServiceMethod中的responseConverter对象最后由Retrofit类中的nextResponseBodyConverter()方法进行赋值。6. OkhttpCall中做具体的同步或异步请求，并对请求回来的数据进行解析。
Android整合搭建RxJava+Retrofit+LiveData+OkHttp框架实现MVVM模式开发
01-14
工程目录说明： base:基础类库。 exception:异常类模块。 ... ...model:数据模型，实体类定义。...repository:数据仓库，包括网络接口请求数据，sqlite数据库，文件File存储，SharedPreferences数据存储。...
Android中的Retrofit+OkHttp+RxJava缓存架构使用
01-05
RxJava如何与Retrofit结合 先扔出build.gradle文件的内容 dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) testCompile 'junit:junit:4.12' compile '...
rxjava+retrofit+okhttp实现网络请求
12-24
rxjava+retrofit+okhttp网络封装请求，完整代码包。。。
Android 网络请求：OkHttp + Retrofit + RxJava 工具类详解
weixin_51522235的博客
11-18 938
Android 网络请求：OkHttp + Retrofit + RxJava 工具类详解
Retrofit + RxJava ＋ OkHttp 最佳组合--基础
小猪的博客
10-22 695
有云：“知其然，当知其所以然”。在之前的项目中，都用到了Retrofit + RxJava ＋ OkHttp的组合来进行网络请求，这也是当下主流的网络请求框架，使用起来着实方便高效。但只是停留在了会用的位置，没有真正的去解析理解起内部的实现，或者说其实现原理。所以，接下来准备用几篇文章对这个经典组合进行总结，学习。从这篇的基础用法开始。 先对这三个开源库解释下： OkHttp：网络请求库； Ret...
Android网络框架之Retrofit + RxJava ＋ OkHttp
热门推荐
fengyongge的专栏
07-31 1万+
现在android网络请求大部分已经换成了Retrofit2.0 +RxJava + okHttp3.0，Retrofit 使用接口的方式，负责请求的数据和请求的结果，OkHttp 负责请求的过程，RxJava 负责异步，各种线程之间的切换。毫无疑问这三剑客 已成为当前Android 网络请求最流行的方式。简介Retrofit: Retrofit是Square 公司开发的一款基于restful风格接
Android okHttp网络请求之Retrofit+Okhttp+RxJava组合
05-29 178
前言： 通过上面的学习，我们不难发现单纯使用okHttp来作为网络库还是多多少少有那么一点点不太方便，而且还需自己来管理接口，对于接口的使用的是哪种请求方式也不能一目了然，出于这个目的接下来学习一下Retrofit+Okhttp的搭配使用。 okHttp相关文章地址： Android okHttp网络请求之Get/Post请求 Android okHttp网...
Android网络请求库的使用(okhttp、retrofit、rxjava)
Xzike的博客
05-12 2396
首先新建项目，添加网络权限，这个权限不需要⽤户授权, 默认申请就给, 不添加的话会报错： 然后在gradle中添加一下依赖： dependencies { implementation 'com.squareup.okhttp3:okhttp:4.9.1' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0
Android MVVM框架搭建（二）OKHttp + Retrofit + RxJava
晨曦
11-01 8750
Android MVVM框架搭建（二）Retrofit + RxJava前言正文一、Retrofit使用二、RxJava使用 前言   在上一篇文章中，简单的介绍了MVVM框架的成员和简单使用，一个成熟的框架自然是离不开网络访问的，因此文本将通过Retrofit + RxJava去为MVVM框架增加一个网络请求模块。 正文   让我们开始吧！说实话搭建框架首先要做的是创建一个library，但是我并没有这么做，不是不去做，而是还不成熟。现在这个框架还不完整，还少了很多实际开发中需要的东西。因此一个成熟的框架
android如何通过okhttp retrofit rxjava请求api接口
05-18
首先需要在项目中添加OkHttp、Retrofit和RxJava的依赖。 在build.gradle文件中添加以下代码： ```groovy dependencies { implementation 'com.squareup.okhttp3:okhttp:4.9.0' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'io.reactivex.rxjava2:rxjava:2.2.10' } ``` 然后在代码中创建Retrofit实例和API接口定义： ```java public interface ApiService { @GET("posts") Observable<List<Post>> getPosts(); } Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://jsonplaceholder.typicode.com/") .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .client(new OkHttpClient()) .build(); ApiService apiService = retrofit.create(ApiService.class); ``` 最后在需要请求API接口的地方，使用RxJava的Observable来发起请求： ```java apiService.getPosts() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<List<Post>>() { @Override public void onSubscribe(Disposable d) { // 订阅事件 } @Override public void onNext(List<Post> posts) { // 请求成功，处理返回结果 } @Override public void onError(Throwable e) { // 请求失败，处理异常 } @Override public void onComplete() { // 请求完成 } }); ``` 其中，subscribeOn(Schedulers.io())表示在io线程中发起请求，observeOn(AndroidSchedulers.mainThread())表示在主线程中处理结果。具体的线程调度可以根据实际情况进行修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值