Android 2 新框架 rxjava ，retrifit

Rxjava

Rxjava主要作用就是用来处理异步，当你的业务需要访问数据库，访问网络，或者任何耗时的操作，都可以借助Rxjava来实现。  但是有人说在Android中已经有很多异步操作的API，比如Handler，AsyncTask等，这些都能满足基本的异步操作，为什么还要使用Rxjava呢？  首先我们开看一个例子做个比较：

假设有这样一个需求：界面上有一个自定义的视图 imageCollectorView ，它的作用是显示多张图片，并能使用 addImage(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在 imageCollectorView中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在 UI 线程执行。

常用的实现方式有多种，比如：  代码块1

//采用android自带的api实现 new Thread() {     @Override     public void run() {         super.run();         for (File file : files) {             File[] files = folder.listFiles();             for (File file : files) {                 if (file.getName().endsWith(".png")) {                     final Bitmap bitmap = getBitmapFromFile(file);                     getActivity().runOnUiThread(new Runnable() {                         @Override                         public void run() {                             imageCollectorView.addImage(bitmap);                         }                     });                 }             }         }     } }.start(); 如果使用Rxjava，则可以这样实现：  代码块2

//采用Rxjava实现 Observable.from(folders)     .flatMap(new Func1<File, Observable<File>>() {         @Override         public Observable<File> call(File file) {             return Observable.from(file.listFiles());         }     })     .filter(new Func1<File, Boolean>() {         @Override         public Boolean call(File file) {             return file.getName().endsWith(".png");         }     })     .map(new Func1<File, Bitmap>() {         @Override         public Bitmap call(File file) {             return getBitmapFromFile(file);         }     })     .subscribeOn(Schedulers.io())     .observeOn(AndroidSchedulers.mainThread())     .subscribe(new Action1<Bitmap>() {         @Override         public void call(Bitmap bitmap) {             imageCollectorView.addImage(bitmap);         }     }); 虽然代码块2的代码量比代码块1的代码量要多，但是很明显代码块2的代码看起来更整洁更优雅，而且如果读者学过Rxjava的人，会明显感觉到代码块2的可读性比代码块1的可读性要强。  由此可见Rxjava的优点即是：采用链式调用，代码简洁优雅有美感，并且可读性增强！

以上，是Rxjava的一部分优点，其实Rxjava的优点更在于它的强大。

下面我们简单了解一下Rxjava的原理： Rxjava实现异步的方法是通过观察者模式实现的。

什么事观察者模式呢？

举个例子，用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。

在Android中最常见的观察者模式是View的onClick事件模型。 

如图可见，当Button持有OnClickListener对象之后，Button被点击之后会自动触发OnClickListener中的OnClick方法。  把上面的Button点击事件抽象一下就变成：  当Observable(可观察的，被观察者)的状态发生变化时，内部会通过一系列事件触发Observer(观察者)中的方法，可以做出相应的操作。  可能这样讲还是比较抽象，举个简单的生活中的例子：

以上模型中，上课铃声是被观察者，即Observable，可观察的，被观察者；学生就是观察者，即Observer（观察者）,学生听到上课铃声响了，就会去上课，这就是学生根据上课铃声所做出的反应。  也就是：  被观察者状态发生变化，观察者可以做出反应。

在Rxjava中观察者模式 RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以根据情况回调来通知 Observer。  Rxjava常用的的回调方法有三种：  - onNext：完成队列中的一个事件  - onComplete：完成队列中所有的事件  - onError：事件发生错误时，并且后续的事件终止。

为什么Rxjava要使用观察者模式呢？  因为观察者模式在模块之间划定了清晰的界限，降低模块耦合性，提高了代码的可维护性和重用性。

Rxjava基本使用方法 创建Observer  Observer是观察者，当被观察者状态发生变化的时候，他会收到相应的事件，使用者可以根据不同的事件进行不同的处理。 Observer<String> observer = new Observer<String>() {             @Override             public void onCompleted() {                 Log.d("Rxjava demo", "onCompleted");             }

            @Override             public void onError(Throwable e) {                 Log.d("Rxjava demo", "onError");             }

            @Override             public void onNext(String s) {                 Log.d("Rxjava demo", "onNext");             }         }; 其实，除了使用Observer以外，Rxjava还有个Subscriber。这个是实现了Observer的抽象类，里面对Observer进行了一些扩展。

 Subscriber<String> subscriber = new Subscriber<String>() {

            @Override             public void onStart() {                 super.onStart();             }

            @Override             public void onNext(String s) {                 Log.d("Rxjava demo", "Item: " + s);             }

            @Override             public void onCompleted() {                 Log.d("Rxjava demo", "Completed!");             }

            @Override             public void onError(Throwable e) {                 Log.d("Rxjava demo", "Error!");             }         }; 可以看出，Subscriber比Observer多了一个回调方法onStart()，它会在事件开始执行之前的时候调用，用于做一些准备工作，类似于AsyncTask中的onPreExecute方法。  但是subscriber中还有几个很重要的方法：  - unsubscribe()：这个方法是取消订阅事件，一般有利于防止内存泄漏。在android开发中我们知道一般有订阅就应该有取消订阅。  - isUnsubscribed()：这个方法是用于判断事件是否被订阅。  - add(Subscription s)：这个方法是把一个Subscription 添加到Subscription列表中，便于统一管理，取消订阅等  2. 创建Observable

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {             @Override             public void call(Subscriber<? super String> subscriber) {                 subscriber.onNext("onNext");                 subscriber.onCompleted();                 subscriber.onNext("onNext");                 subscriber.onError(new Throwable());             }         }); 使用create方法创建Observable（被观察者），然后call方法会被自动调用，在call方法内部定义事件的回调的行为。  其实这段代码中，当执行了onComplete方法之后，就不会在往下执行了，也就是说onError方法不会被调用，因为事件已经完全执行完成，就会停止执行之后的事件。  如果我们反过来写：

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {             @Override             public void call(Subscriber<? super String> subscriber) {                 subscriber.onNext("onNext");                 subscriber.onError(new Throwable());                 subscriber.onCompleted();                 subscriber.onNext("onNext");             }         }); onNext方法执行完成之后会执行onError，但是之后的onComplete方法以及后面的事件都不会在执行了，前面我们说过，onError执行之后表示事件执行失败，后面的事件就会停止执行。  3. Subscribe(订阅)

observable.subscribe(observer); 最后我们使用subscribe方法让observer订阅observable。但是这个方法看起来写反了，他不是“观察者”订阅“被观察者”，而是被观察者订阅了观察者，这其实是因为为了保证流式的设计，把subscribe是Observable的方法，把observer作为参数传进。  什么保证流式设计呢？  因为Rxjava可以这样写：

Observable.create(new Observable.OnSubscribe<String>() {             @Override             public void call(Subscriber<? super String> subscriber) {                 subscriber.onNext("onNext");                 subscriber.onCompleted();                 subscriber.onError(new Throwable());             }         }).subscribe(new Observer<String>() {             @Override             public void onCompleted() {                 Log.d("Rxjava demo", "onCompleted");             }

            @Override             public void onError(Throwable e) {                 Log.d("Rxjava demo", "onError");             }

            @Override             public void onNext(String s) {                 Log.d("Rxjava demo", "onNext");             }         }); 这样代码就会看着优雅许多，而且层级清晰，可读性强。  通过以上方法，我们就简单了解了Rxjava的使用方法。但其实，Observable的创建方式有多种:  - 例如just可以传入多个参数，最多可以传入10个参数，并且会自动调用10次onNext  - from(T[])将传入的数组依次发送出去，数组内有多少个元素，就会调用多少次onNext，当所有元素（事件）发送结束之后会调用onComplete，如果在某个元素中发生错误，就会调用onError。  写法如下：

ArrayList<String> array = new ArrayList<>(); Observable.from(array).subscribe(new Subscriber<String>() {             @Override             public void onCompleted() {

            }

            @Override             public void onError(Throwable e) {

            }

            @Override             public void onNext(String s) {

            }         }); 大家可以看到，不用再重写call方法，因为会自动安排事件发送，不需要手动调用onNext等方法了，而这段代码中的onNext方法会依次输出数组中的每一个元素。

Rxjava的变化 以上内容都是基于Rxjava比较旧的API介绍的，目前Rxjava 1 已经更新到了1.3  使用最新的Rxjava 1需要引入以下依赖：

compile 'io.reactivex:rxjava:1.3.0' compile 'io.reactivex:rxandroid:1.2.1' 1 2 在这个版本中的Observable的创建有所变化,方法 static Observable create(OnSubscribe f)已经过时了，因为这个方法不安全。  新的版本中已经引入了比较安全的方法：  - static

 Observable.create(new SyncOnSubscribe<String, String>() {             @Override             protected String generateState() {                 Log.d("Rxjava demo", "generateState");                 return "generateState";             }

            @Override             protected String next(String state, Observer<? super String> observer) {                 observer.onNext(state);                 observer.onCompleted();                 observer.onError(new Throwable("onError"));                 return state;             }         }).subscribe(new Action1<String>() {             @Override             public void call(String s) {                 Log.d("Rxjava demo", s);             }         }, new Action1<Throwable>() {             @Override             public void call(Throwable throwable) {                 Log.d("Rxjava demo", throwable.getMessage());             }         }, new Action0() {             @Override             public void call() {                 Log.d("Rxjava demo", "onComplete");             }         }); 但是可以看出来多了两种回调方法：  - generateState()，这个方法会在subscribe的时候调用，产生一个state值，这个值会在第一次迭代的时候传递到next(S state, Observer observer) 方法中，后续迭代下将收到由先前的调用返回下一个状态。也就是会收到next(S state, Observer observer)的返回值

next(S state, Observer observer)中会收到上游传来的数据，并通过observer.onNext方法传递到下游。但是该方法的实现必须遵循以下规则：(1)observer.onNext(t)不能超过1次调用。(2)不能同时调用observer.onNext(t)。  next(S state, Observer observer)会返回下一次迭代的状态值（state）给generateState()，然后generateState()再把值传递给next(S state, Observer observer)，如果你没有调用onComplete或者onError，这个循环会一直下去 好了，Rxjava简单的介绍就到这里了，下次我们会介绍Rxjava最强大的地方，也就是Rxjava操作符。

Retrofit原理解析

retrofit入门 定义网络请求的API接口： interface GithubApiService {         @GET("users/{name}/repos")         Call<ResponseBody> searchRepoInfo(@Path("name") String name);     } 使用了注解表明请求方式，和参数类型，这是retrofit的特性，也正是简化了我们的网络请求过程的地方！

初始化一个retrofit的实例： Retrofit retrofit = new Retrofit.Builder()                 .baseUrl("https://api.github.com/")                 .build(); retrofit的实例化很简单，采用链式调用的设计，把需要的参数传进去即可，复杂的参数我们这里就不举例了。

补充：链式调用优势

普通：

 　　1：维护性强

 　　2：对方法的返回类型无要求 

 　　3：对程序员的业务要求适中

链式：

 　　1：编程性强

 　　2：可读性强

 　　3：代码简洁

 　　4：对程序员的业务能力要求高

 　　5：不太利于代码调试  

生成接口实现类： GithubApiService githubService = retrofit.create(service) Call<ResponseBody> call = githubService.searchRepoInfo("changmu175"); 我们调用retrofit的create方法就可以把我们定义的接口转化成实现类，我们可以直接调用我们定义的方法进行网络请求，但是我们只定义了一个接口方法，也没有方法体，请求方式和参数类型都是注解，create是如何帮我们整理参数，实现方法体的呢？一会我们通过源码解析再去了解。

发起网络请求 //同步请求方式  call.request();  //异步请求方式  call.enqueue(new Callback<ResponseBody>() {             @Override             public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {                 //请求成功回调             }

            @Override             public void onFailure(Call<ResponseBody> call, Throwable t) {                 //请求与失败回调             }         }); 至此，retrofit的一次网络请求示例已经结束，基于对okhttp的封装，让网络请求已经简化了很多。当然retrofit最适合的还是REST API类型的接口，方便简洁。

下面我们就看看retrofit的核心工作是如何完成的！

retrofit初始化 retrofit的初始化采用了链式调用的设计

Retrofit retrofit = new Retrofit.Builder()                        .baseUrl("https://api.github.com/")                        .build(); 很明显这个方法是在传一些需要的参数，我们简单的跟踪一下：

首先看看Builder()的源码： public Builder() {       this(Platform.get());     } 这句代码很简单就是调用了自己的另一个构造函数：

Builder(Platform platform) {       this.platform = platform;     } 这个构造函数也很简单，就是一个赋值，我们把之前的Platform.get()点开，看看里面做在什么：

private static final Platform PLATFORM = findPlatform();

static Platform get() {     return PLATFORM;   } 我们发现这里使用使用了一个饿汉式单例，使用Platform.get()返回一个实例，这样写的好处是简单，线程安全，效率高，不会生成多个实例！

我们再看看findPlatform() 里做了什么：

 private static Platform findPlatform() {     try {       Class.forName("android.os.Build");       if (Build.VERSION.SDK_INT != 0) {         return new Android();       }     } catch (ClassNotFoundException ignored) {     }

    ....省略部分代码...  } 所以是判断了一下系统，然后根据系统实例化一个对象。这里面应该做了一些和Android平台相关的事情，属于细节，我们追究，感兴趣的可以只看看。

再看看baseUrl(url)的源码 public Builder baseUrl(String baseUrl) {       checkNotNull(baseUrl, "baseUrl == null");       HttpUrl httpUrl = HttpUrl.parse(baseUrl);       ....       return baseUrl(httpUrl);     }

public Builder baseUrl(HttpUrl baseUrl) {       checkNotNull(baseUrl, "baseUrl == null");       ....       this.baseUrl = baseUrl;       return this;     } 这两段代码也很简单，校验URL，生成httpUrl对象，然后赋值给baseUrl

看看build() 方法在做什么 参数基本设置完了，最后就要看看build() 这个方法在做什么：

 public Retrofit build() {       if (baseUrl == null) {         throw new IllegalStateException("Base URL required.");       }

      okhttp3.Call.Factory callFactory = this.callFactory;       if (callFactory == null) {         callFactory = new OkHttpClient();       }       ....

      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),           unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);     }   } } 代码中有大量的参数校验，有些复杂的参数我们没有传，所以我就把那些代码删除了。简单看一下也能知道，这段代码就是做一些参数校验，baseUrl不能为空否则会抛异常，至于其他的参数如果为null则会创建默认的对象。其中callFactory就是okhttp的工厂实例，用于网络请求的。  最后我们看到，这个方法最终返回的是一个Retrofit的对象，初始化完成。

生成接口实现类 刚才我们就讲过retrofit.create这个方法很重要，它帮我们生成了接口实现类，并完成了方法体的创建，省去了我们很多工作量。那我们来看看它是如何帮我们实现接口的。

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 {             // If the method is a method from Object then defer to normal invocation.             if (method.getDeclaringClass() == Object.class) {               return method.invoke(this, args);             }             if (platform.isDefaultMethod(method)) {               return platform.invokeDefaultMethod(method, service, proxy, args);             }             ServiceMethod<Object, Object> serviceMethod =                 (ServiceMethod<Object, Object>) loadServiceMethod(method);             OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);             return serviceMethod.adapt(okHttpCall);           }         });   } 这段代码实际上是使用了动态代理的设计模式，而且这个方法封装的非常好，我们只需要调用 方法就可以获得我们需要的实现类，遵循了迪米特法则（最少知道原则）。

了解动态代理的人都知道我们要重写Object invoke(Object proxy, Method method, @Nullable Object[] args) 方法，这个方法会传入我们需要的实现的方法，和参数，并返回我们需要的返回值。  retrofit在重写这个方法的时候做了三件事：

1、先判断了这个方法的类是不是一个Object.class)，就直接返回方法原有的返回值。 2、判断这个方法是不是DefaultMethod，大家都知道这个方法是Java 8出来的新属性，表示接口的方法体。 3、构建一个ServiceMethod<Object, Object>对象和OkHttpCall<Object>对象，并调用  serviceMethod.adapt(okHttpCall)方法将二者绑定。 我们看看这个方法的源码：

T adapt(Call<R> call) {     return callAdapter.adapt(call);   } 这个callAdapter我们在初始化retrofit的时候没有使用：  addCallAdapterFactory(CallAdapterFactory)传值，所以这里是默认的DefaultCallAdapterFactory  那我们再看看DefaultCallAdapterFactory里的adapt(call)方法：

@Override public Call<Object> adapt(Call<Object> call) {         return call;       } 直接返回参数，也就是OkHttpCall<Object>的对象。所以如果没有自定义callAdapter的时候，我们定义接口的时候返回值类型应该是个Call类型的。  那么，至此这个create方法已经帮我们实现了我们定义的接口，并返回我们需要的值。

请求参数整理 我们定义的接口已经被实现，但是我们还是不知道我们注解的请求方式，参数类型等是如何发起网络请求的呢？  这时我们可能应该关注一下ServiceMethod<Object, Object>对象的构建了：

  ServiceMethod<Object, Object> serviceMethod =                 (ServiceMethod<Object, Object>) loadServiceMethod(method); 主要的逻辑都在这个loadServiceMethod(method)里面，我们看看方法体：

ServiceMethod<?, ?> loadServiceMethod(Method method) {     ServiceMethod<?, ?> result = serviceMethodCache.get(method);     if (result != null) return result;

    synchronized (serviceMethodCache) {       result = serviceMethodCache.get(method);       if (result == null) {         result = new ServiceMethod.Builder<>(this, method).build();         serviceMethodCache.put(method, result);       }     }     return result;   } 逻辑很简单，就是先从一个 serviceMethodCache中取ServiceMethod<?, ?>对象，如果没有，则构建ServiceMethod<?, ?>对象，然后放进去serviceMethodCache中，这个serviceMethodCache是一个HashMap:

private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>(); 1 所以构建ServiceMethod<?, ?>对象的主要逻辑还不在这个方法里，应该在new ServiceMethod.Builder<>(this, method).build();里面。这也是个链式调用，一般都是参数赋值，我们先看看Builder<>(this, method)方法：

Builder(Retrofit retrofit, Method method) {       this.retrofit = retrofit;       this.method = method;       this.methodAnnotations = method.getAnnotations();       this.parameterTypes = method.getGenericParameterTypes();       this.parameterAnnotationsArray = method.getParameterAnnotations();     } 果然，这里获取了几个重要的参数：

retrofit实例 method，接口方法 接口方法的注解methodAnnotations，在retrofit里一般为请求方式 参数类型parameterTypes 参数注解数组parameterAnnotationsArray，一个参数可能有多个注解 我们再看看build()的方法：

 public ServiceMethod build() {       callAdapter = createCallAdapter();       responseType = callAdapter.responseType();       responseConverter = createResponseConverter();

      for (Annotation annotation : methodAnnotations) {         parseMethodAnnotation(annotation);       }

      if (httpMethod == null) {         throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");       }

      int parameterCount = parameterAnnotationsArray.length;       parameterHandlers = new ParameterHandler<?>[parameterCount];       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);       }

      return new ServiceMethod<>(this);     } 这个方法挺长的，删了些无关紧要的代码还是很长。首先一开始先获取几个重要对象：callAdapter、responseType和responseConverter，这三个对象都跟最后的结果有关，我们先不管。

看到一个for循环，遍历方法的注解，然后解析：

for (Annotation annotation : methodAnnotations) {         parseMethodAnnotation(annotation);       } private void parseMethodAnnotation(Annotation annotation) {       if (annotation instanceof DELETE) {         parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);       } else if (annotation instanceof GET) {         parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);       } 

        .... 这个方法的方法体我删掉了后面的一部分，因为逻辑都是一样，根据不同的方法注解作不同的解析，得到网络请求的方式httpMethod。但是主要的方法体还是if里面的方法：

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {

      ....

      // Get the relative URL path and existing query string, if present.       int question = value.indexOf('?');       if (question != -1 && question < value.length() - 1) {         // Ensure the query string does not have any named parameters.         String queryParams = value.substring(question + 1);         Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);         if (queryParamMatcher.find()) {           throw methodError("URL query string \"%s\" must not have replace block. "               + "For dynamic query parameters use @Query.", queryParams);         }       }

      this.relativeUrl = value;       this.relativeUrlParamNames = parsePathParameters(value);     } 逻辑不复杂，就是校验这个value的值 是否合法，规则就是不能有“？”如果有则需要使用@Query注解。最后this.relativeUrl = value;。这个relativeUrl就相当于省略域名的URL，一般走到这里我们能得到的是：users/{name}/repos这样的。里面的“{name}”是一会我们需要赋值的变量。

我们继续看刚才的build()方法：  解析完方法的注解之后，需要解析参数的注解数组，这里实例化了一个一维数组：

parameterHandlers = new ParameterHandler<?>[parameterCount]; 1 然后遍历取出参数的类型：

Type parameterType = parameterTypes[p]; 1 取出参数注解：

Annotation[] parameterAnnotations = parameterAnnotationsArray[p]; 1 然后把参数类型、参数注解都放在一起进行解析，解析的结果放到刚才实例化的数组parameterHandlers里面：

parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations); 1 那我们再看看这个方法里做了什么：

private ParameterHandler<?> parseParameter(int p, Type parameterType, Annotation[] annotations) {       ParameterHandler<?> result = null;       for (Annotation annotation : annotations) {         ParameterHandler<?> annotationAction = parseParameterAnnotation(             p, parameterType, annotations, annotation);       }

    } 这个方法的主要代码也很简单，解析参数注解，得到一个ParameterHandler<?> annotationAction对象。  那我继续看方法里面的代码。当我们点进parseParameterAnnotation( p, parameterType, annotations, annotation);的源码里面去之后发现这个方法的代码接近500行！但是大部分逻辑类似，都是通过if else判断参数的注解，我们取一段我们刚才的例子相关的代码出来：

 if (annotation instanceof Path) {         if (gotQuery) {           throw parameterError(p, "A @Path parameter must not come after a @Query.");         }         if (gotUrl) {           throw parameterError(p, "@Path parameters may not be used with @Url.");         }         if (relativeUrl == null) {           throw parameterError(p, "@Path can only be used with relative url on @%s", httpMethod);         }         gotPath = true;

        Path path = (Path) annotation;         String name = path.value();         validatePathName(p, name);

        Converter<?, String> converter = retrofit.stringConverter(type, annotations);         return new ParameterHandler.Path<>(name, converter, path.encoded());

      } 前面做了一些校验，后面取出注解的名字：name，然后用正则表达校验这个name是否合法。然后构建一个Converter<?, String>对象：

 Converter<?, String> converter = retrofit.stringConverter(type, annotations); 1 点击去看看：

 public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotations) {       ....     for (int i = 0, count = converterFactories.size(); i < count; i++) {       Converter<?, String> converter =           converterFactories.get(i).stringConverter(type, annotations, this);       if (converter != null) {         //noinspection unchecked         return (Converter<T, String>) converter;       }     }     return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;   } 看到核心代码是converter的stringConverter(type, annotations, this)方法：  因为我们刚才的示例中被没有通过：addConverterFactory(ConverterFactory)添加一个ConverterFactory，所以这里会返回一个空：

 public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,         Retrofit retrofit) {       return null;     } 所以最后会执行最后一句代码：  return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;  我们点进去看看这个INSTANCE：

static final ToStringConverter INSTANCE = new ToStringConverter(); 1 是BuiltInConverters内的内部类ToStringConverter的单例。所以这里我们得到的就  是BuiltInConverters.ToStringConverter的实例。

最后用这个对象构建一个Path（因为示例中的参数类型是path，所以我们看这个代码）：

new ParameterHandler.Path<>(name, converter, path.encoded()); 1 我们看看这个Path类的构造函数：

Path(String name, Converter<T, String> valueConverter, boolean encoded) {       this.name = checkNotNull(name, "name == null");       this.valueConverter = valueConverter;       this.encoded = encoded;     } 只是赋值，并且我们看到这个类继承自：ParameterHandler<T>，所以我们回到刚才的build()方法，发现把参数类型，参数注解放在一起解析之后存储到了这个ParameterHandler<T>数组中，中间主要做了多种合法性校验，并根据注解的类型，生成不同的  ParameterHandler<T>子类，如注解是Url则生成ParameterHandler.RelativeUrl()对象，如果注解是Path，则生成：  ParameterHandler.Path<>(name, converter, path.encoded())对象等等。  我们查看了ParameterHandler<T>类，发现它有一个抽象方法：

abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException; 1 这个方法每个子类都必须复写，那我们看看Path里面怎么复写的：

   @Override      void apply(RequestBuilder builder, @Nullable T value) throws IOException {          builder.addPathParam(name, valueConverter.convert(value), encoded);     } 就是把value被添加到RequestBuilder中，我们看一下这个addPathParam方法：

void addPathParam(String name, String value, boolean encoded) {

    relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded));   } 这个方法把我们传进来的值value按照编码格式转换，然后替换relativeUrl中的{name}，构成一个有效的省略域名的URL。至此，URL的拼接已经完成！

总结：Retrofit使用动态代理模式实现我们定义的网络请求接口，在重写invoke方法的时候构建了一个ServiceMethod对象，在构建这个对象的过程中进行了方法的注解解析得到网络请求方式httpMethod，以及参数的注解分析，拼接成一个省略域名的URL

Retrofit网络请求 我们刚才解析了apply方法，我们看看apply方法是谁调用的呢？跟踪一下就发先只有toCall(args);方法：

 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;

    int argumentCount = args != null ? args.length : 0;     if (argumentCount != handlers.length) {       throw new IllegalArgumentException("Argument count (" + argumentCount           + ") doesn't match expected count (" + handlers.length + ")");     }

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

    return callFactory.newCall(requestBuilder.build());   } 这个方法一开始就构建了RequestBuilder，传进去的参数包含：  httpMethod，baseUrl，relativeUrl，headers，contentType，hasBody，isFormEncoded，isMultipart！

然后获取了parameterHandlers，我们上边分析的时候，知道这个数组是存参数注解的解析结果的，并对其进行遍历调用了如下方法：

for (int p = 0; p < argumentCount; p++) {       handlers[p].apply(requestBuilder, args[p]);     } 1 2 3 把参数值传进RequestBuilder中。  最后调用callFactory.newCall(requestBuilder.build())生成一个okhttp3.Call。  我们看一下这个build方法：

Request build() {     HttpUrl url;     HttpUrl.Builder urlBuilder = this.urlBuilder;     if (urlBuilder != null) {       url = urlBuilder.build();     } else {       // No query parameters triggered builder creation, just combine the relative URL and base URL.       //noinspection ConstantConditions Non-null if urlBuilder is null.       url = baseUrl.resolve(relativeUrl);       if (url == null) {         throw new IllegalArgumentException(             "Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);       }     }

    RequestBody body = this.body;     if (body == null) {       // Try to pull from one of the builders.       if (formBuilder != null) {         body = formBuilder.build();       } else if (multipartBuilder != null) {         body = multipartBuilder.build();       } else if (hasBody) {         // Body is absent, make an empty body.         body = RequestBody.create(null, new byte[0]);       }     }

    MediaType contentType = this.contentType;     if (contentType != null) {       if (body != null) {         body = new ContentTypeOverridingRequestBody(body, contentType);       } else {         requestBuilder.addHeader("Content-Type", contentType.toString());       }     }

    return requestBuilder         .url(url)         .method(method, body)         .build();   }

可以看到okhttp的请求体在这里构建，当所有的参数满足的时候，则调用了

Request.Builder requestBuilder         .url(url)         .method(method, body)         .build(); 1 2 3 4 这是发起okhttp的网络请求 。  那这个toCall(args);谁调用的呢？继续往回跟！

 private okhttp3.Call createRawCall() throws IOException {     okhttp3.Call call = serviceMethod.toCall(args);     return call;   } 那谁调用了createRawCall()呢？继续看谁调用了！于是发现调用方有三个地方，并且都是OkHttpCall里面！我们一个一个看吧：

Request request()方法： enqueue(final Callback callback)方法 Response execute()的方法

很明显上面三个方法都是retrofit的发起网络请求的方式，分别是同步请求和异步请求。我们的示例中在最后一步就是调用了request方法和enqueue方法发起网络请求。至此我们已经疏通了retrofit是如何进行网络请求的了。

总结：当我们调用Retrofit的网络请求方式的时候，就会调用okhttp的网络请求方式，参数使用的是实现接口的方法的时候拿到的信息构建的RequestBuilder对象，然后在build方法中构建okhttp的Request，最终发起网络请求

总结 Retrofit主要是在create方法中采用动态代理模式实现接口方法，这个过程构建了一个ServiceMethod对象，根据方法注解获取请求方式，参数类型和参数注解拼接请求的链接，当一切都准备好之后会把数据添加到Retrofit的RequestBuilder中。然后当我们主动发起网络请求的时候会调用okhttp发起网络请求，okhttp的配置包括请求方式，URL等在Retrofit的RequestBuilder的build()方法中实现，并发起真正的网络请求。

Retrofit封装了okhttp框架，让我们的网络请求更加简洁，同时也能有更高的扩展性。当然我们只是窥探了Retrofit源码的一部分，他还有更复杂更强大的地方等待我们去探索包括返回值转换工厂，拦截器等，这些都属于比较难的地方，我们需要循序渐进的去学习，当我们一点一点的看透框架的本质之后，我们使用起来才会熟能生巧。大神的代码，对于Android想要进阶的同学来说很有好处，不仅教会我们如何设计代码更多的是解决思想。

RxJava 给我们的项目引入响应式编程方式，让异步方式变得更简洁，而且它的简洁与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。它流式编程的思想，丰富的操作符，线程的任意切换等优点广受大家的喜爱。

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

Retrofit Retrofit是一个RESTful的Http网络请求框架的封装。注意这里并没有说它是网络请求框架，主要原因在于网络请求的工作并不是Retrofit来完成的。

Retrofit 2.0开始内置OkHttp，前者专注于接口的封装，后者专注于网络请求的高效，二者分工协作。

而且Retrofit提供不同的Converter实现（也可以自定义），同时提供RxJava支持(返回Observable对象)，配合Gson和RxJava，你可以用很少的代码就实现请求、返回数据解析和操作等功能。

OkHttp OkHttp是Retrofit底层使用的Http请求库，都是Square公司的开源产品。OkHttp是一个快速、高效的Http客户端实现，它帮我们完成了很多很多事情：

• 支持SPDY, 可以合并多个到同一个主机的请求
• 使用连接池技术减少请求的延迟(如果SPDY是可用的话)
• 使用GZIP压缩减少传输的数据量
• 缓存响应避免重复的网络请求
• ......

OkHttp还提供了拦截器(Interceptors)，方便我们来监控，改写和重试HTTP访问。通过拦截器，我们很容易就能实现对Http的请求和响应记录到日志。

整合

如果我们直接这样组合就认为是一个应用框架的话，那我认为你还没有真正认识框架，或者没有遇到稍大一点复杂一点的项目，所以你毫不费力就有了自己“高大上”的框架。

但是在你整合这些库时，你更应该学习一下他们是怎么能无缝地对接上的，这一点也是我认为可以问面试者的一个重要的点。

如Retrofit的解耦方式：

1、通过注解来配置请求参数；

2、通过工厂来生成CallAdapter，Converter。

• 你可以使用不同的请求适配器(CallAdapter)，比如RxJava；
• 你可以使用不同的反序列化工具(Converter)，比如Gson、protobuff等。

Retrofit retrofit = new Retrofit.Builder()
  .baseUrl("http://api.github.com/api/")
  .addConverterFactory(GsonConverterFactory.create())
  .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
  .build();

Retrofit是如何做到的呢？其间的实现代码值得好好看看，好在代码量并不是很大，看前先学习一个Java动态代理方面的知识，也可缓解一些“痛苦”。

所以总结果一下，关于标配我会这样问：RxJava+Retrofit+OkHttp的内部是如何整合在一起的，还有就是它们如何和数据与业务逻辑层进行整合？