Android 面试开源框架篇

本文是Android面试题整理中的一篇,内容包括

LeakCanary
Okhttp
Retrofit
Fresco 使用
EventBus

LeakCanary原 理

在Application中注册一个ActivityLifecycleCallbacks来监听Activity的销毁

通过IdleHandler在主线程空闲时进行检测

检测是通过WeakReference实现的，如果没有被回收会再次调用gc再确认一遍

确认有泄漏后，dump hprof文件，并开启一个进程IntentService通过HAHA进行分析

OkHttp（基于3.9版本）

使用

1. 在gradle中添加依赖

compile 'com.squareup.okhttp3:okhttp:3.9.0'
compile 'com.squareup.okio:okio:1.13.0'

2. 创建OkHttpClient，并对timeout等进行设置

File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024;
OkHttpClient.Builder builder = new OkHttpClient.Builder()
        .connectTimeout(15, TimeUnit.SECONDS)
        .writeTimeout(20, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .cache(new Cache(sdcache.getAbsoluteFile(), cacheSize));
OkHttpClient mOkHttpClient=builder.build();

3. 创建Request

get请求

Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .build();

post请求（post需要传入requsetBody）

RequestBody formBody = new FormEncodingBuilder()
            .add("size", "10")
            .build();
    Request request = new Request.Builder()
            .url("http://api.1-blog.com/biz/bizserver/article/list.do")
            .post(formBody)
            .build();

4. 创建Call并执行（okHttp的返回结果并没有在ui线程）

Call call = mOkHttpClient.newCall(request);

同步执行

Response mResponse=call.execute();
        if (mResponse.isSuccessful()) {     
           return mResponse.body().string();
       } else {
           throw new IOException("Unexpected code " + mResponse);
       }

异步执行

call.enqueue(new Callback() {
        @Override
        public void onFailure(Request request, IOException e) {
        }
        @Override
        public void onResponse(Response response) throws IOException {
            String str = response.body().string();
            Log.i("wangshu", str);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(getApplicationContext(), "请求成功", Toast.LENGTH_SHORT).show();
                }
            });
        }
    });

4. 封装

因为以下原因，所以我们需要封装：

避免重复代码编写
请求的回调改为UI线程
其他需要的逻辑：例如加解密等

OkHttp中的设计模式

Builder模式：OkHttpClient 和Request等都是通过Builder模式创建的
责任链模式：拦截器通过责任链模式进行工作
门面模式：整体采用门面模式，OkHttpClient为门面，向子系统委派任务
享元模式：连接池等采用了享元模式
其他：工厂模式、代理模式等

源码分析

1. Call

Call的实现类为RealCall
在执行execute或者enqueue时，会取出okHttpClient中的Dispatcher执行对应的方法

client.dispatcher().enqueue(new AsyncCall(responseCallback, forWebSocket));

2. Diapatcher

Diapatcher在OkHttpClient build时进行初始化
Dispatcher负责进行任务调度，内部维护一个线程池，处理并发请求
Dispatcher内部有三个队列

/** 将要运行的异步请求队列 */
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
/**正在运行的异步请求队列 */
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
/** 正在运行的同步请求队列 */
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

执行时，线程会调用AsyncCall的excute方法

3. AsyncCall

AsyncCall是RealCall的一个内部类，实现了Runnalbe接口
AsyncCall 通过 getResponseWithInterceptorChain方法取得Response
执行完毕后通过client.dispatcher().finished(this)；将自身从dispatcher队列中取出，并取出下一个加入相应队列

//AsyncCall 的excute方法
@Override protected void execute() {
  boolean signalledCallback = false;
  try {
    Response response = getResponseWithInterceptorChain(forWebSocket);
    if (canceled) {
      signalledCallback = true;
      responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
    } else {
      signalledCallback = true;
      responseCallback.onResponse(RealCall.this, response);
    }
  } catch (IOException e) {
    if (signalledCallback) {
      // Do not signal the callback twice!
      logger.log(Level.INFO, "Callback failure for " + toLoggableString(), e);
    } else {
      responseCallback.onFailure(RealCall.this, e);
    }
  } finally {
    client.dispatcher().finished(this);
  }
}

4. getResponseWithInterceptorChain

getResponseWithInterceptorChain是用责任链的方式，执行拦截器，对请求和请求结果进行处理

getResponseWithInterceptorChain 中创建拦截器，并创建第一个RealInterceptorChain，执行其proceed方法

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

RealInterceptorChain的proceed方法中，会取出拦截器，并创建下一个Chain，将其作为参数传给拦截器的intercept方法

  // If there's another interceptor in the chain, call that.
  if (index < client.interceptors().size()) {
    Interceptor.Chain chain = new ApplicationInterceptorChain(index + 1, request, forWebSocket);
    //从拦截器列表取出拦截器
    Interceptor interceptor = client.interceptors().get(index);
    Response interceptedResponse = interceptor.intercept(chain);

    if (interceptedResponse == null) {
      throw new NullPointerException("application interceptor " + interceptor
          + " returned null");
    }

    return interceptedResponse;
  }

  // No more interceptors. Do HTTP.
  return getResponse(request, forWebSocket);
}

拦截器

1. 自定义拦截器

自定义拦截器分为两类，interceptor和networkInterceptor（区别：networkInterceptor处理网络相关任务，如果response直接从缓存返回了，那么有可能不会执行networkInterceptor）
自定义方式：实现Interceptor，重写intercept方法，并注册拦截器

2. 系统拦截器

RetryAndFollowUpInterceptor：进行失败重试和重定向
BridgeInterceptor：添加头部信息
CacheInterceptor：处理缓存
ConnectInterceptor：获取可用的connection实例
CallServerInterceptor：发起请求

连接池复用

在ConnectInterceptor中，我们获取到了connection的实例，该实例是从ConnectionPool中取得

1. Connection

Connection 是客户端和服务器建立的数据通路，一个Connection上可能存在几个链接
Connection的实现类是RealConnection，是socket物理连接的包装
Connection内部维持着一个List<Reference>引用

2. StreamAllocation

StreamAllocation是Connection维护的连接，以下是类内注解

 <ul>
 *     <li><strong>Connections:</strong> physical socket connections to remote servers. These are
 *         potentially slow to establish so it is necessary to be able to cancel a connection
 *         currently being connected.
 *     <li><strong>Streams:</strong> logical HTTP request/response pairs that are layered on
 *         connections. Each connection has its own allocation limit, which defines how many
 *         concurrent streams that connection can carry. HTTP/1.x connections can carry 1 stream
 *         at a time, HTTP/2 typically carry multiple.
 *     <li><strong>Calls:</strong> a logical sequence of streams, typically an initial request and
 *         its follow up requests. We prefer to keep all streams of a single call on the same
 *         connection for better behavior and locality.
 * </ul>

3. ConnectionPool

ConnectionPool通过Address等来查找有没有可以复用的Connection，同时维护一个线程池，对Connection做回收工作

Retrofit

Retrofit帮助我们对OkHttp进行了封装，使网络请求更加方便

使用

1. 添加依赖

dependencies {
    compile 'com.squareup.retrofit2:retrofit:2.0.2'
  }

2. 创建Retrofit实例

Retrofit retrofit = new Retrofit.Builder() 
 .baseUrl("http://fanyi.youdao.com/") // 设置网络请求的Url地址
 .addConverterFactory(GsonConverterFactory.create()) // 设置数据解析器 
 .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) // 支持RxJava平台 .build();

3. 创建网络接口

@GET("user")
Call<User> getUser(@Header("Authorization") String authorization)

4. 创建Call

 GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);
//对 发送请求 进行封装
Call<Reception> call = request.getCall();

5. 执行Call的请求方法

//发送网络请求(异步) call.enqueue(new Callback<Translation>() { 
//请求成功时回调
 @Override 
public void onResponse(Call<Translation> call, Response<Translation> response) { 
   //请求处理,输出结果
    response.body().show(); 
 } 
 //请求失败时候的回调 
 @Override 
 public void onFailure(Call<Translation> call, Throwable throwable) { 
     System.out.println("连接失败"); 
 } 
 });
 
 // 发送网络请求（同步） Response<Reception> response = call.execute();

源码解析

1. Retrofit

Retrofit 通过builder模式创建，我们可以对其进行各种设置：

baseUrl：请求地址的头部，必填
callFactory：网络请求工厂（不进行设置的话默认会生成一个OkHttpClient）
adapterFactories：网络请求适配器工厂的集合，这里有适配器因为Retrofit不仅支持Android，还支持Ios等其他平台（不进行设置的话会根据平台自动生成）
converterFactories：数据转换器工厂的集合（将网络返回的数据转换成我们需要的类）
callbackExecutor：回调方法执行器（Android平台默认通过Handler发送到主线程执行）

2. Call

我们的每个method对应一个Call， Call的创建分为两步：

retorfit.create(myInfterfaceClass.class)创建我们网络请求接口类的实例
调用对应方法拿到对应网络请求的Call

关键在第一步，第一步是通过动态代理实现的

public <T> T create(final Class<T> service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
    eagerlyValidateMethods(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, 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 serviceMethod = loadServiceMethod(method);//1
          OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
          return serviceMethod.callAdapter.adapt(okHttpCall);
        }
      });
}

通过loadServiceMethod方法生成mehtod对应的ServiceMethod
将ServiceMethod和方法参数传进OkHttpCall生成OkHttpCall
调用callAdapter方法对OkHttpCall进行处理并返回

1. ServiceMethod

loadServiceMethod方法会首先在缓存里查找是否有该method对应的ServiceMethod，没有的话调用build方法创建一个

ServiceMethod loadServiceMethod(Method method) {
 ServiceMethod result; 
 // 设置线程同步锁 
 synchronized (serviceMethodCache) { 
 result = serviceMethodCache.get(method);
  // ServiceMethod类对象采用了单例模式进行创建 
  // 即创建ServiceMethod对象前，先看serviceMethodCache有没有缓存之前创建过的网络请求实例 
  // 若没缓存，则通过建造者模式创建 
  serviceMethod 对象 if (result == null) { 
  // 下面会详细介绍ServiceMethod生成实例的过程 
  result = new ServiceMethod.Builder(this, method).build(); 
  serviceMethodCache.put(method, result); 
   } 
  }
   
  return result;
}

ServiceMethod的创建过程即是对method的解析过程，解析过程包括：对注解的解析，寻找合适的CallAdapter和Convert等

2. OkHttpCall

OkHttpCall实现了Call接口，当执行excute或enqueue请求命令时，内部通过传入的CallFactory（OkHttpClient）执行网络请求

3. callAdapter

如果我们没有对CallAdapter进行设置，它的值将是Android平台的默认设置，其adapt方法如下

public <R> Call<R> adapt(Call<R> call) { 
    return new ExecutorCallbackCall<>(callbackExecutor, call); 
} 


ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {

 this.delegate = delegate; 
 // 把上面创建并配置好参数的OkhttpCall对象交给静态代理delegate 
 // 静态代理和动态代理都属于代理模式 
 // 静态代理作用：代理执行被代理者的方法，且可在要执行的方法前后加入自己的动作，进行对系统功能的拓展 
 
 this.callbackExecutor = callbackExecutor; 
 // 传入上面定义的回调方法执行器 
 // 用于进行线程切换 }

ExecutorCallbackCall对OkHttpCall进行了装饰，会调用CallBackExcutor对OkHttpCall执行的返回结果进行处理，使其位于主线程

自定义Convert和CallAdapter

Fresco

Fresco是一个图片加载库，可以帮助我们加载图片显示，控制多线程，以及管理缓存和内存等

Fresco使用

引入依赖

dependencies {
  // 其他依赖
  compile 'com.facebook.fresco:fresco:0.12.0'
   // 在 API < 14 上的机器支持 WebP 时，需要添加
  compile 'com.facebook.fresco:animated-base-support:0.12.0'

  // 支持 GIF 动图，需要添加
  compile 'com.facebook.fresco:animated-gif:0.12.0'

  // 支持 WebP （静态图+动图），需要添加
  compile 'com.facebook.fresco:animated-webp:0.12.0'
  compile 'com.facebook.fresco:webpsupport:0.12.0'

  // 仅支持 WebP 静态图，需要添加
  compile 'com.facebook.fresco:webpsupport:0.12.0'
}

初始化

Fresco.initialize(Context context);

使用SimpleView

<com.facebook.drawee.view.SimpleDraweeView
    android:id="@+id/my_image_view"
    android:layout_width="130dp"
    android:layout_height="130dp"
    fresco:placeholderImage="@drawable/my_drawable"
  />

加载图片

Uri uri = Uri.parse("https://raw.githubusercontent.com/facebook/fresco/gh-pages/static/logo.png");
SimpleDraweeView draweeView = (SimpleDraweeView) findViewById(R.id.my_image_view);
draweeView.setImageURI(uri);

以上是Fresco的基本加载流程，此外，我们可以定制加载和显示的各个环节

Fresco由两部分组成，Drawees负责图片的呈现，ImagePipeline负责图片的下载解码和内存管理

Drawees

Drawees 负责图片的呈现。它由三个元素组成，有点像MVC模式。

DraweeView

继承于 View, 负责图片的显示。
一般情况下，使用 SimpleDraweeView 即可。你可以在 XML 或者在 Java 代码中使用它，通过 setImageUri 给它设置一个 URI 来使用，这里有简单的入门教学：开始使用
你可以使用 XML属性来达到各式各样的效果。

DraweeHierarchy

DraweeHierarchy 用于组织和维护最终绘制和呈现的 Drawable 对象，相当于MVC中的M。
你可以通过它来在Java代码中自定义图片的展示

DraweeController

DraweeController 负责和 image loader 交互（ Fresco 中默认为 image pipeline, 当然你也可以指定别的），可以创建一个这个类的实例，来实现对所要显示的图片做更多的控制。
如果你还需要对Uri加载到的图片做一些额外的处理，那么你会需要这个类的。

DraweeControllerBuilder

DraweeControllers 由 DraweeControllerBuilder 采用 Builder 模式创建，创建之后，不可修改。具体参见: 使用ControllerBuilder。

Listeners

使用 ControllerListener 的一个场景就是设置一个 Listener监听图片的下载。

ImagePipeline

Fresco 的 Image Pipeline 负责图片的获取和管理。图片可以来自远程服务器，本地文件，或者Content Provider，本地资源。压缩后的文件缓存在本地存储中，Bitmap数据缓存在内存中。
在5.0系统以下，Image Pipeline 使用 pinned purgeables 将Bitmap数据避开Java堆内存，存在ashmem中。这要求图片不使用时，要显式地释放内存
SimpleDraweeView自动处理了这个释放过程，所以没有特殊情况，尽量使用SimpleDraweeView，在特殊的场合，如果有需要，也可以直接控制Image Pipeline。
ImagePipeline加载图片流程

检查内存缓存，如有，返回

后台线程开始后续工作
检查是否在未解码内存缓存中。如有，解码，变换，返回，然后缓存到内存缓存中。
检查是否在磁盘缓存中，如果有，变换，返回。缓存到未解码缓存和内存缓存中。
从网络或者本地加载。加载完成后，解码，变换，返回。存到各个缓存中。

ImagePipeline的线程池

Image pipeline 默认有3个线程池:

3个线程用于网络下载

2个线程用于磁盘操作: 本地文件的读取，磁盘缓存操作。
2个线程用于CPU相关的操作: 解码，转换，以及后处理等后台操作。

ImagePipeline的缓存

ImagePipeLine有三级缓存

解码后的Bitmap缓存

未解码图片的内存缓存

磁盘缓存

对比

功能

Fresco 相对于Glide/Picaso等拥有更多的功能，如图片的渐进式加载/动图/圆角等，

性能

Fresco采用三级缓存：