前言:
哈哈, 其实写的还是很水, 各位原谅我 O(∩_∩)O.
介于自己的网络方面知识烂的一塌糊涂, 所以准备写相关网络的文章, 但是考虑全部写在一篇太长了, 所以分开写, 希望大家能仔细看, 最好可以指出我的错误, 让我也能纠正.
1. 讲解相关的整个网络体系结构:
Android 技能树 - 网络小结 (1) 之网络体系结构
2. 讲解相关网络的重要知识点, 比如很多人都听过相关网络方面的名词, 但是仅限于听过而已, 什么 tcp ,udp ,socket ,websocket, http ,https , 然后 webservice 是啥, 跟 websocket 很像, socket 和 websocket 啥关系长的也很像, session,token,cookie 又是啥.
Android 技能树 - 网络小结 (2) 之 TCP/UDP
Android 技能树 - 网络小结 (3) 之 HTTP/HTTPS
Android 技能树 - 网络小结 (4) 之 socket/websocket/webservice
相关网络知识点小结 - cookie/session/token(待写)
3. 相关的第三方框架的源码解析, 毕竟现在面试个大点的公司, okhttp 和 retrofit 源码是必问的.
Android 技能树 - 网络小结 (6) 之 OkHttp 超超超超超超超详细解析
- Retrofit retrofit = new Retrofit.Builder()
- .client(new OkHttpClient())
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
- .addConverterFactory(GsonConverterFactory.create())
- .baseUrl("https://xxxx.com/")
- .build();
- InfoApi.java:
- interface InfoApi{
- @GET("userinfo.do")
- Observable<UserBean> getInfo(@Query("name") String nameStr);
- }
- public <T> T create(final Class<T> service) {
- Utils.validateServiceInterface(service);
- if (this.validateEagerly) {
- this.eagerlyValidateMethods(service);
- }
- //'使用了代理模式'
- return Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service}, new InvocationHandler() {
- private final Platform platform = Platform.get();
- public Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
- if (method.getDeclaringClass() == Object.class) {
- return method.invoke(this, args);
- } else if (this.platform.isDefaultMethod(method)) {
- return this.platform.invokeDefaultMethod(method, service, proxy, args);
- } else {
- //'我们可以看到我们写的接口里面的的 method 传入到了 loadServiceMethod 方法里面, 从而得到了我们定义在 method 上面的相关参数信息.'
- ServiceMethod<Object, Object> serviceMethod = Retrofit.this.loadServiceMethod(method);
- //'我们传入的方法的参数 args 和上面获得的 ServiceMethod, 一起传入 OkHttpCall 构造函数中, 得到 OkHttpCall 对象'
- OkHttpCall<Object> okHttpCall = new OkHttpCall(serviceMethod, args);
- return serviceMethod.adapt(okHttpCall);
- }
- }
- });
- }
- ServiceMethod<?, ?> loadServiceMethod(Method method) {
- //'从缓存中去读'
- ServiceMethod<?, ?> result = (ServiceMethod)this.serviceMethodCache.get(method);
- if (result != null) {
- return result;
- } else {
- Map var3 = this.serviceMethodCache;
- synchronized(this.serviceMethodCache) {
- result = (ServiceMethod)this.serviceMethodCache.get(method);
- if (result == null) {
- //'如果缓存中没有, 则新建'
- result = (new retrofit2.ServiceMethod.Builder(this, method)).build();
- //'新建完后再放入缓存中'
- this.serviceMethodCache.put(method, result);
- }
- return result;
- }
- }
- }
- Builder(Retrofit retrofit, Method method) {
- this.retrofit = retrofit;
- this.method = method;
- //'Java 特有的方法, 可以获取 Java 方法上面的注解标识, 比如:@POST,@GET'
- this.methodAnnotations = method.getAnnotations();
- //'获取方法参数里面定义的参数类型, 比如: String,boolean'
- this.parameterTypes = method.getGenericParameterTypes();
- //'获取方法里面的注解标识, 比如:@Query,@Path'
- this.parameterAnnotationsArray = method.getParameterAnnotations();
- }
- public ServiceMethod build() {
- //'创建了 CallAdapter 对象, 具体干嘛用的, 具体后面会讲解'
- callAdapter = createCallAdapter();
- responseType = callAdapter.responseType();
- if (responseType == Response.class || responseType == okhttp3.Response.class) {
- throw methodError("'"
- + Utils.getRawType(responseType).getName()
- + "is not a valid response body type. Did you mean ResponseBody?");
- }
- //'创建了 ResponseConverter 对象, 具体后面会讲解'
- responseConverter = createResponseConverter();
- //'对于我们写的接口请求方法的方法上面的注解进行相关判断,'
- for (Annotation annotation : methodAnnotations) {
- parseMethodAnnotation(annotation);
- }
- //'因为进行方法上面注解的解析了, 所以 httpMethod 的也就相应的被赋值了,
- if (httpMethod == null) {
- throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
- }
- //'因为上面解析了, 所以比如我们发现是 @GET 请求, 这时候 hasBody 会是 false, 如果你还用了 Multipart 注解, 就会报错了, 他要求是要有 request body 的,@GET 请求是不能使用 Multipart 的'
- if (!hasBody) {
- if (isMultipart) {
- throw methodError(
- "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
- }
- //'同上, 表单提交是一定要求有 request body 的'
- if (isFormEncoded) {
- throw methodError("FormUrlEncoded can only be specified on HTTP methods with
- + request body (e.g., @POST).");
- }
- }
- int parameterCount = parameterAnnotationsArray.length;
- parameterHandlers = new ParameterHandler<?>[parameterCount];
- //'遍历我们获取的方法里面的注解集合, 比如 @Query,@Path 等'
- for (int p = 0; p <parameterCount; p++) {
- Type parameterType = parameterTypes[p];
- if (Utils.hasUnresolvableType(parameterType)) {
- throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
- parameterType);
- }
- Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
- if (parameterAnnotations == null) {
- throw parameterError(p, "No Retrofit annotation found.");
- }
- //'然后对我们写的方法内部参数注解进行判断, 看写的是否正确等
- parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
- }
- if (relativeUrl == null && !gotUrl) {
- throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
- }
- if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
- throw methodError("Non-body HTTP method cannot contain @Body.");
- }
- if (isFormEncoded && !gotField) {
- throw methodError("Form-encoded method must contain at least one @Field.");
- }
- if (isMultipart && !gotPart) {
- throw methodError("Multipart method must contain at least one @Part.");
- }
- return new ServiceMethod<>(this);
- }
- T adapt(Call<R> call) {
- return callAdapter.adapt(call);
- }
- Retrofit retrofit = new Retrofit.Builder()
- .client(new OkHttpClient())
- //'这里传入了 CallAdapterFactory, 而 Factory 类是用来创建具体的 CallAdapter 对象的工厂类'
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
- .addConverterFactory(GsonConverterFactory.create())
- .baseUrl("https://xxxx.com/")
- .build();
- private CallAdapter<T, R> createCallAdapter() {
- //'我们上面的接口请求方法绿色框里面的返回类型还没有拿到的, 终于在这里拿到了'
- Type returnType = method.getGenericReturnType();
- //'如果方法的返回结果包含了泛型表达式, 泛型, 泛型数组, 就抛出异常'
- if (Utils.hasUnresolvableType(returnType)) {
- throw methodError(
- "Method return type must not include a type variable or wildcard: %s", returnType);
- }
- //'如果方法的返回结果是 void, 则抛出异常'
- if (returnType == void.class) {
- throw methodError("Service methods cannot return void.");
- }
- //'我们前面提过的, 获取方法上的注解, 比如 @GET 等'
- Annotation[] annotations = method.getAnnotations();
- try {
- //'拿着我们的接口请求方法的返回对象及方法上的注解信息,'
- //'去通过 Retrofit 类的 callAdapter 类去生成一个 CallAdapter 对象'
- return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
- } catch (RuntimeException e) { // Wide exception range because factories are user code.
- throw methodError(e, "Unable to create call adapter for %s", returnType);
- }
- }
- public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
- callAdapterFactories.add(checkNotNull(factory, "factory == null"));
- return this;
- }
- Retrofit retrofit = new Retrofit.Builder()
- ........
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
- .addCallAdapterFactory(xxxxxxCallAdapterFactory.create())
- .addCallAdapterFactory(yyyyyyCallAdapterFactory.create())
- ........
- ........
- .build();
- //'看名字就知道, 加入平台的默认的 CallAdapterFactory(有 java8 和 Android Platform, 我们这里肯定是 Android)'
- callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
- public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
- //'因为可能有多个 CallAdapterFactory 工厂类, 所以要每个工厂类都去试一下, 有一个成功就直接返回了'
- return nextCallAdapter(null, returnType, annotations);
- }
- public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
- Annotation[] annotations) {
- checkNotNull(returnType, "returnType == null");
- checkNotNull(annotations, "annotations == null");
- int start = callAdapterFactories.indexOf(skipPast) + 1;
- //'循环遍历所有的 CallAdapterFactory, 然后哪个能成功生成 CallAdapter, 就直接返回'
- for (int i = start, count = callAdapterFactories.size(); i <count; i++) {
- CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
- if (adapter != null) {
- return adapter;
- }
- }
- //'如果所有的 CallAdapterFctory 都不能使用, 就拼接字符串, 抛出异常'
- StringBuilder builder = new StringBuilder("Could not locate call adapter for")
- .append(returnType)
- .append(".\n");
- if (skipPast != null) {
- builder.append("Skipped:");
- for (int i = 0; i <start; i++) {
- builder.append("\n *").append(callAdapterFactories.get(i).getClass().getName());
- }
- builder.append('\n');
- }
- builder.append("Tried:");
- for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
- builder.append("\n *").append(callAdapterFactories.get(i).getClass().getName());
- }
- throw new IllegalArgumentException(builder.toString());
- }
- @Override
- public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
- //'如果不是 Call.class, 直接退出生成 CallAdapter 对象'
- if (getRawType(returnType) != Call.class) {
- return null;
- }
- .......
- .......
- }
- @Override
- public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
- Class<?> rawType = getRawType(returnType);
- //'如果我们的返回类型是 Completable, 就直接返回 RxJava2CallAdapter 对象, 里面的 responseType 是 void'
- if (rawType == Completable.class) {
- // Completable is not parameterized (which is what the REST of this method deals with) so it
- // can only be created with a single configuration.
- return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
- false, true);
- }
- //'判断是否是 Flowable 或者 Single 或者 Maybe'
- boolean isFlowable = rawType == Flowable.class;
- boolean isSingle = rawType == Single.class;
- boolean isMaybe = rawType == Maybe.class;
- //'如果既不是上面三种又不是 Observable 类型, 直接返回 null'
- if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
- return null;
- }
- boolean isResult = false;
- boolean isBody = false;
- Type responseType;
- //'如果不是泛型类的, 比如 Observable<XXXX> , 则抛异常'
- if (!(returnType instanceof ParameterizedType)) {
- String name = isFlowable ? "Flowable"
- : isSingle ? "Single"
- : isMaybe ? "Maybe" : "Observable";
- throw new IllegalStateException(name + "return type must be parameterized"
- + "as" + name + "<Foo> or" + name + "<? extends Foo>");
- }
- //'获取泛型中的具体参数, 比如 Observable<xxxBean > 中的 xxxBean 的 type'
- Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
- //'获取 xxxBean 具体的 Class 对象'
- Class<?> rawObservableType = getRawType(observableType);
- //'判断我们上面获取的泛型内容 (xxxBean) 是不是 Response'
- if (rawObservableType == Response.class) {
- if (!(observableType instanceof ParameterizedType)) {
- throw new IllegalStateException("Response must be parameterized"
- + "as Response<Foo> or Response<? extends Foo>");
- }
- responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
- //'判断我们上面获取的泛型内容 (xxxBean) 是不是 Result'
- } else if (rawObservableType == Result.class) {
- if (!(observableType instanceof ParameterizedType)) {
- throw new IllegalStateException("Result must be parameterized"
- + "as Result<Foo> or Result<? extends Foo>");
- }
- responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
- isResult = true;
- } else {
- //'我们平常开发泛型里面填的肯定是自己的 Bean 对象
- // 所以最后走的是这里的代码'
- responseType = observableType;
- //'同时 isBody 设置为 true'
- isBody = true;
- }
- //'生成具体的 Rxjava2CallAdapter 对象'
- return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
- isSingle, isMaybe, false);
- }
- @Override public Object adapt(Call<R> call) {
- /**
- '很多人会说这个 isAsync, 是否异步是哪里设置的,
- 其实就是再我们传入 Factory 对象时候建立的.
- Retrofit retrofit = new Retrofit.Builder()
- .client(new OkHttpClient())
- 我们看见创建 Factory 对象, 可以是 createAsync()或者 create()方法二种来创建, 从而决定是同步还是异步操作
- .addCallAdapterFactory(RxJava2CallAdapterFactory.createAsync())
- 或者是
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create()
- .build();'
- */
- //'我们可以看到上面根据是否异步, 建立不同的 Observable 对象, 我们用复杂点的来讲解吧,
- Observable<Response<R>> responseObservable = isAsync
- ? new CallEnqueueObservable<>(call)
- : new CallExecuteObservable<>(call);
- //'因为我们 Observable<xxxBean > 里面包含的是自己 Bean, 所以建立的时候 isBody = true;'
- Observable<?> observable;
- if (isResult) {
- observable = new ResultObservable<>(responseObservable);
- } else if (isBody) {
- //'所以我们的 Observable 为 BodyObservable'
- observable = new BodyObservable<>(responseObservable);
- } else {
- observable = responseObservable;
- }
- if (scheduler != null) {
- observable = observable.subscribeOn(scheduler);
- }
- if (isFlowable) {
- return observable.toFlowable(BackpressureStrategy.LATEST);
- }
- if (isSingle) {
- return observable.singleOrError();
- }
- if (isMaybe) {
- return observable.singleElement();
- }
- if (isCompletable) {
- return observable.ignoreElements();
- }
- //'所以最终返回了 BodyObservable<CallEnqueueObservable>'
- return observable;
- }
- final class BodyObservable<T> extends Observable<T> {
- private final Observable<Response<T>> upstream;
- BodyObservable(Observable<Response<T>> upstream) {
- this.upstream = upstream;
- }
- @Override protected void subscribeActual(Observer<? super T> observer) {
- //'当有 Observer 注册我们的 Observable 的时候,
- upstream.subscribe(new BodyObserver<T>(observer));
- }
- }
- final class CallEnqueueObservable<T> extends Observable<Response<T>> {
- private final Call<T> originalCall;
- CallEnqueueObservable(Call<T> originalCall) {
- this.originalCall = originalCall;
- }
- @Override protected void subscribeActual(Observer<? super Response<T>> observer) {
- // Since Call is a one-shot type, clone it for each new observer.
- Call<T> call = originalCall.clone();
- //'我们可以看到简历了一个 CallCallback 对象, 传入了用户写的我们前面创建的 OkHttpCall 对象和用户写的 observer 对象'
- CallCallback<T> callback = new CallCallback<>(call, observer);
- observer.onSubscribe(callback);
- //'然后调用了 call 的 enqueue 方法,
- call.enqueue(callback);
- }
- private static final class CallCallback<T> implements Disposable, Callback<T> {
- .......
- .......
- .......
- }
- }
- @Override public void enqueue(final Callback<T> callback) {
- checkNotNull(callback, "callback == null");
- okhttp3.Call call;
- Throwable failure;
- synchronized (this) {
- if (executed) throw new IllegalStateException("Already executed.");
- executed = true;
- call = rawCall;
- failure = creationFailure;
- if (call == null && failure == null) {
- try {
- //'创建 Okhttp3 的 Call 对象(毕竟最后发起网络请求是 Okhttp, 也要使用它的 Call 对象)'
- call = rawCall = createRawCall();
- } catch (Throwable t) {
- throwIfFatal(t);
- failure = creationFailure = t;
- }
- }
- }
- if (failure != null) {
- callback.onFailure(this, failure);
- return;
- }
- if (canceled) {
- call.cancel();
- }
- //'常规 Okhttp 的操作, call.enqueue 方法发起异步请求, 估计大家都看得懂, 我就不多介绍了, 我们直接看拿到返回的数据处理'
- call.enqueue(new okhttp3.Callback() {
- @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
- Response<T> response;
- try {
- //'我们这里成功的拿到了 Okhttp3.Response 对象,
- response = parseResponse(rawResponse);
- } catch (Throwable e) {
- callFailure(e);
- return;
- }
- try {
- callback.onResponse(OkHttpCall.this, response);
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
- @Override public void onFailure(okhttp3.Call call, IOException e) {
- callFailure(e);
- }
- private void callFailure(Throwable e) {
- try {
- callback.onFailure(OkHttpCall.this, e);
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
- });
- }
- Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
- //'把 Okhttp3.Response 中的 body 部分取出来'
- ResponseBody rawBody = rawResponse.body();
- rawResponse = rawResponse.newBuilder()
- .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
- .build();
- int code = rawResponse.code();
- //'我们就当成功请求回来的, 所以 code 是 200'
- if (code <200 || code>= 300) {
- try {
- // Buffer the entire body to avoid future I/O.
- ResponseBody bufferedBody = Utils.buffer(rawBody);
- return Response.error(bufferedBody, rawResponse);
- } finally {
- rawBody.close();
- }
- }
- if (code == 204 || code == 205) {
- rawBody.close();
- return Response.success(null, rawResponse);
- }
- ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
- try {
- //'核心代码:
- T body = serviceMethod.toResponse(catchingBody);
- return Response.success(body, rawResponse);
- } catch (RuntimeException e) {
- // If the underlying source threw an exception, propagate that rather than indicating it was
- // a runtime exception.
- catchingBody.throwIfCaught();
- throw e;
- }
- }
- R toResponse(ResponseBody body) throws IOException {
- //'可以看到我们通过 responseConverter 转换器来对 body 部分进行了转换'
- return responseConverter.convert(body);
- }
- Retrofit retrofit = new Retrofit.Builder()
- .client(new OkHttpClient())
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
- //'看见了 ConverterFactory 没有, 就是这里传入了我们的转换器对象'
- .addConverterFactory(GsonConverterFactory.create())
- .baseUrl("https://xxxx.com/")
- .build();
- public final class GsonConverterFactory extends Converter.Factory {
- //'可以看到默认内部使用的是 GSON 来进行转换'
- public static GsonConverterFactory create() {
- return create(new Gson());
- }
- public static GsonConverterFactory create(Gson gson) {
- return new GsonConverterFactory(gson);
- }
- private final Gson gson;
- private GsonConverterFactory(Gson gson) {
- if (gson == null) throw new NullPointerException("gson == null");
- this.gson = gson;
- }
- //'这个方法从名字就可以看出来, 是用用来给 ResponseBody 转换成我们要的对象'
- @Override
- public Converter<ResponseBody, ?> responseBodyConverter(final Type type, Annotation[] annotations, Retrofit retrofit) {
- Type newType = new ParameterizedType() {
- @Override
- public Type[] getActualTypeArguments() {
- return new Type[] { type };
- }
- @Override
- public Type getOwnerType() {
- return null;
- }
- @Override
- public Type getRawType() {
- return HttpResult.class;
- }
- };
- TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(newType));
- //'可以看到, 用在 Response 的转换器是叫 GsonResponseBodyConverter 对象'
- return new GsonResponseBodyConverter<>(adapter);
- }
- //'这个名字也可以看出来是把我们传入的对象转换成 RequestBody, 从而发起请求'
- @Override
- public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations,
- Annotation[] methodAnnotations, Retrofit retrofit) {
- TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
- //'可以看到, 用在 Request 的转换器是叫 GsonRequestBodyConverter 对象'
- return new GsonRequestBodyConverter<>(gson, adapter);
- }
- }
- final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
- private final Gson gson;
- private final TypeAdapter<T> adapter;
- GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
- this.gson = gson;
- this.adapter = adapter;
- }
- @Override public T convert(ResponseBody value) throws IOException {
- //'根据传入的 ResponseBody 得到 JsonReader'
- JsonReader jsonReader = gson.newJsonReader(value.charStream());
- try {
- //'很简单, 就是 GSON 进行相关的 JSON 解析'
- T result = adapter.read(jsonReader);
- if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
- throw new JsonIOException("JSON document was not fully consumed.");
- }
- return result;
- } finally {
- value.close();
- }
- }
- }
- final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, Object> {
- private final TypeAdapter<T> adapter;
- GsonResponseBodyConverter(TypeAdapter<T> adapter) {
- this.adapter = adapter;
- }
- @Override
- public Object convert(ResponseBody value) throws IOException {
- try {
- //'因为我统一的外层对象都是使用的 HttpResult, 我的代码是这么写的 Observable<HttpResult<xxxBean>>'
- HttpResult apiModel = (HttpResult) adapter.fromJson(value.charStream());
- //'直接在这里就对统一处理操作'
- if (apiModel.getCode().equals(CompanyHttpCode.TOKEN_NOT_EXIST)) {
- throw new TokenNotExistException();
- } else if (apiModel.getCode().equals(CompanyHttpCode.TOKEN_INVALID)) {
- throw new TokenInvalidException();
- } else if (!apiModel.getCode().equals(CompanyHttpCode.SUCCESS_CODE)) {
- // 特定 API 的错误, 在相应的 Subscriber 的 onError 的方法中进行处理
- throw new ApiException();
- } else if (apiModel.getCode().equals(CompanyHttpCode.SUCCESS_CODE) || apiModel.getCode().equals(CompanyHttpCode.SUCCESS_CODE_STR)) {
- return apiModel;
- }
- } finally {
- value.close();
- }
- return null;
- }
- }
- try {
- //'我们前面讲过, 通过这个方法转换的 parseResponse(rawResponse);
- } catch (Throwable e) {
- callFailure(e);
- return;
- }
- try {
- //'在转换成功后, 我们就把具体的 response 重新通过回调函传回去给 CallEnqueueObservable'
- callback.onResponse(OkHttpCall.this, response);
- } catch (Throwable t) {
- t.printStackTrace();
- }
- @Override public void onResponse(Call<T> call, Response<T> response) {
- if (disposed) return;
- try {
- //'我们可以看到, Observable 调用了 observerde 的 onNext 方法把 Retrofit.Reponse 对象发送了出去'
- observer.onNext(response);
- ......
- ......
- ......
- }
- private static class BodyObserver<R> implements Observer<Response<R>> {
- @Override public void onNext(Response<R> response) {
- if (response.isSuccessful()) {
- //'最终到我们的 Observer 的时候, 就是 Response 里面包含了的我们写的 xxxBean 对象了.'
- observer.onNext(response.body());
- } else {
- .....
- .....
- }
- }
- ......
- ......
- }
- interface InfoApi{
- @GET("userinfo.do")
- Observable<UserBean> getInfo(@Query("name") String nameStr);
- }
- Retrofit retrofit = new Retrofit.Builder()
- .client(new OkHttpClient())
- .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
- .addConverterFactory(GsonConverterFactory.create())
- .baseUrl("https://xxxx.com/")
- .build();
- retrofit.create(InfoApi.class)
- .getInfo("青蛙要 fly")
- .subscribe(new ResourceObserver<UserBean>() {
- @Override
- public void onNext(UserBean userBean) {
- }
- @Override
- public void onError(Throwable e) {
- }
- @Override
- public void onComplete() {
- }
- });
来源: https://juejin.im/post/5bfe74245188256693607ad2