阅读 556

Android小知识-剖析Retrofit中网络请求的两种方式

本平台的文章更新会有延迟,大家可以关注微信公众号-顾林海,包括年底前会更新kotlin由浅入深系列教程,目前计划在微信公众号进行首发,如果大家想获取最新教程,请关注微信公众号,谢谢!

在上一节《Android小知识-剖析Retrofit中ServiceMethod相关参数以及创建过程》介绍了动态代理类中三行核心代码的第一行,通过loadServiceMethod方法获取ServiceMethod对象,在loadServiceMethod方法中先会检查缓存集合中是否有对应网络请求接口方法的ServiceMethod对象,如果不存在就通过Builder模式创建,同时介绍了ServiceMethod内部的一些成员变量,其实ServiceMethod就是对网络请求接口内部一个个方法的封装,通过解析方法内部或方法上的注解来封装ServiceMethod对象。这节来介绍三行核心代码的剩余两行。

  public <T> T create(final Class<T> service) {
    ...
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
            ...
            //核心代码1
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            //核心代码2
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //核心代码3
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }
复制代码

在核心代码2处创建OkHttpCall,OkHttpCall是Call的实现类,在Retrofit中内部是通过OkHttp来进行网络的请求,这个OkHttpCall就是对OkHttp请求的封装。

final class OkHttpCall<T> implements Call<T> {
  ....
  private @Nullable okhttp3.Call rawCall;

  OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }
}
复制代码

在OkHttpCall中可以看到rawCall,它是OkHttp的Call,这也验证之前所说的内部会通过OkHttp来实现网络请求,OkHttpCall构造函数传入两个参数,serviceMethod对象和args网络请求参数,接着看核心代码3。

   return serviceMethod.adapt(okHttpCall);
复制代码

serviceMethod的adapt方法中会调用callAdatper的adapter方法,通过适配器的adapt方法来将OkHttpCall转换成其他平台使用的对象,这个callAdapter是在创建serviceMethod时通过构建者模式创建的,它代表网络请求的适配器,这里使用的RxJava平台。

回到一开始的实例代码:

    private void initRetrofit() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://icould.glh/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();

        NetworkInterface networkInterface = retrofit.create(NetworkInterface.class);

        Map<String, String> params = new HashMap<>();
        params.put("newsId", "1");
        params.put("token", "yud133f");
        Call call = networkInterface.getNewsDetails(params);

        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                System.out.println(response.body());
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                System.out.println("请求错误");
            }
        });
    }
复制代码

通过networkInterface接口调用getNewsDetails是不行的,因此在Retrofit的create获取网络接口的动态代理,在执行networkInterface的getNewDetails方法时,通过动态代理拦截,并执行动态代理对象内InvocationHandler中的invoke方法,将OkHttpCall转换成RxJava平台的适用的Call,而这个OkHttpCall对象是对OkHttp网络库的封装,最后返回OkHttpCall类型的Call对象,有了这个Call对象就可以进行同步或异步请求,OkHttpCall内提供了同步请求方法execute和异步请求方法enqueue,接着下来重点分析这两个方法。

在Retrofit同步请求流程中,首先需要对网络请求接口中方法以及参数进行解析,通过ParameterHandler进行解析,然后根据ServiceMethod对象创建OkHttp的Request对象,ServiceMethod对象内部包含了网络请求的所有信息,它是对网络接口方法的封装,有了Request对象后就可以通过OkHttp这个库来进行网络请求,最后解析服务端给客户端返回的数据,通过converter数据转换器来完成数据的转换。

OkHttpCall的同步请求execute方法:

    @Override public Response<T> execute() throws IOException {
        okhttp3.Call call;

        synchronized (this) {
            if (executed) throw new IllegalStateException("Already executed.");
            executed = true;

            if (creationFailure != null) {
                if (creationFailure instanceof IOException) {
                    throw (IOException) creationFailure;
                } else if (creationFailure instanceof RuntimeException) {
                    throw (RuntimeException) creationFailure;
                } else {
                    throw (Error) creationFailure;
                }
            }

            call = rawCall;
            if (call == null) {
                try {
                    call = rawCall = createRawCall();
                } catch (IOException | RuntimeException | Error e) {
                    throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
                    creationFailure = e;
                    throw e;
                }
            }
        }

        if (canceled) {
            call.cancel();
        }

        return parseResponse(call.execute());
    }
复制代码

下面贴出execute局部代码,方便分析。

    @Override public Response<T> execute() throws IOException {
        okhttp3.Call call;

        synchronized (this) {
            if (executed) throw new IllegalStateException("Already executed.");
            executed = true;

            if (creationFailure != null) {
                if (creationFailure instanceof IOException) {
                    throw (IOException) creationFailure;
                } else if (creationFailure instanceof RuntimeException) {
                    throw (RuntimeException) creationFailure;
                } else {
                    throw (Error) creationFailure;
                }
            }

            ...
        }

       ...
    }
复制代码

上面代码中一开始创建了一个OkHttp的call对象,下面是一个同步代码块,通过判断executed是否执行过通过请求,如果执行过就会抛出异常,接着判断creationFailure,不为null时,判断异常类型并抛出异常,execute方法的前段部分就是对异常的判断。

    @Override public Response<T> execute() throws IOException {
        okhttp3.Call call;
        synchronized (this) {
            ...
            call = rawCall;
            if (call == null) {
                try {
                    call = rawCall = createRawCall();
                } catch (IOException | RuntimeException | Error e) {
                    throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
                    creationFailure = e;
                    throw e;
                }
            }
        }
        ...
    }
复制代码

当没有任何异常时,将rawCall也就是OkHttp的原生call赋值给局部变量call,当call为null时,通过createRawCall方法创建OkHttp的Call对象以及Request。

进入createRawCall方法:

  private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }
复制代码

内部通过serviceMethod的toCall方法将传入的请求参数转换成Call对象。

进入serviceMethod的toCall方法:

  okhttp3.Call toCall(@Nullable Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);

    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

    ...

    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return callFactory.newCall(requestBuilder.build());
  }
复制代码

RequestBuilder内部保存着网络请求的相关参数,接着在for循环中通过ParameterHandler对参数进行解析,最后通过callFactory的newCall创建OkHttp的Call对象,newCall内部传入的是Request对象,通过requestBuilder.build()创建Request对象,到这里将OkHttp的Call对象返回给execute方法内部的成员变量call以及OkHttpCall的成员变量rawCall。

    @Override public Response<T> execute() throws IOException {
        okhttp3.Call call;
        ...
        if (canceled) {
            call.cancel();
        }
        return parseResponse(call.execute());
    }
复制代码

有了OkHttp的Call之后,就通过call.execute()进行阻塞式的同步请求,并将返回的Response传入parseResponse方法中。

进入parseResponse方法:

    Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
        ...
        try {
            T body = serviceMethod.toResponse(catchingBody);
            return Response.success(body, rawResponse);
        } catch (RuntimeException e) {
            ...
        }
    }
复制代码

只看核心代码,通过调用serviceMethod的toResponse方法返回body,进入toResponse方法,看它到底做了哪些操作。

  R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }
复制代码

原来是调用了数据转换器将OkHttp返回的Response转换成Java对象,这里我们使用的Gson,也就是通过Gson将服务器返回的数据转换成我们需要的Java对象,最后通过Response的success方法将返回的Java对象封装成Response。

  Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
   ...
   return Response.success(body, rawResponse);
}
复制代码

进入Response的success方法:

  public static <T> Response<T> success(@Nullable T body, okhttp3.Response rawResponse) {
    ...
    return new Response<>(rawResponse, body, null);
  }
复制代码

返回创建好的Response,将body也就是我们的Java对象传过去。

Response的构造函数:

  private Response(okhttp3.Response rawResponse, @Nullable T body,
      @Nullable ResponseBody errorBody) {
    this.rawResponse = rawResponse;
    this.body = body;
    this.errorBody = errorBody;
  }
复制代码

到这里大家应该很熟悉了,我们利用Retrofit进行网络的同步或异步请求,最终会返回一个Response对象并通过response.body来获取结果,这个body就是通过转换器转换好的Java对象。

接下来分析异步请求:

        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                System.out.println(response.body());
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                System.out.println("请求错误");
            }
        });
复制代码

执行异步请求的流程和同步类似,只不过异步请求的结果是通过回调来传递的,异步是通过enqueue方法来执行的,而这个Call的实现类是OkHttpCall,进入OkHttpCall的enqueue方法。

OkHttpCall的enqueue方法(上半部分):

    @Override public void enqueue(final Callback<T> callback) {
        ...
        okhttp3.Call call;
        ...
        synchronized (this) {
            if (executed) throw new IllegalStateException("Already executed.");
            executed = true;

            call = rawCall;
            failure = creationFailure;
            if (call == null && failure == null) {
                try {
                    call = rawCall = createRawCall();
                } catch (Throwable t) {
                    throwIfFatal(t);
                    failure = creationFailure = t;
                }
            }
        }
        ...
    }
复制代码

可以发现enqueue的上半部分与上面介绍同步请求时是一样的,创建OkHttp的Call,并检查相关异常,如果call为null,就通过createRawCall方法创建OkHttp的Call以及请求所需要的Request。

OkHttpCall的enqueue方法(下半部分):

    @Override public void enqueue(final Callback<T> callback) {
        ...
        call.enqueue(new okhttp3.Callback() {
            @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
                Response<T> response;
                try {
                    response = parseResponse(rawResponse);
                } catch (Throwable e) {
                    callFailure(e);
                    return;
                }

                try {
                    callback.onResponse(OkHttpCall.this, response);
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            }
            ...
        });
    }
复制代码

上面这段代码不用我讲,大家也应该知道就是通过OkHttp的Call的enqueue方法进行异步请求,关于OkHttp相关知识可以阅读之前写的OkHttp分析的相关系列教程,在OkHttp的Call的enqueue方法的回调方法onResponse方法中,将返回的Response通过parseResponse方法转换成Java对象并返回Retrofit的Response对象,通过前面传入的Callback对象将Response回调给客户端。

到这里关于Retrofit网络请求框架的封装就讲解完毕了!


838794-506ddad529df4cd4.webp.jpg

关注下面的标签,发现更多相似文章
评论