Picasso源码解析

一、Picasso使用：

gradle:

compile 'com.squareup.picasso:picasso:2.5.2'

使用：

Picasso.with(this).load("http://...../photo3.jpg").into(myImg);

自定义的使用方法：

Picasso picasso = new Picasso.Builder(this)
        .memoryCache(new LruCache())       // 设置自定义的内存缓存
        .addRequestHandler(requestHandler) // 设置自定义的RequestHandler
        .defaultBitmapConfig(bitmapConfig) // 设置自定义的Bitmap Config
        .downloader(okHttpDownloader)      // 设置自定义的Downloader
        .executor(executorService)         // 设置自定义的线程池
        .requestTransformer(transformer)   // 设置自定义的Transformor
        .listener(listener)                // 添加Listener进行监听
        .build();
picasso.load(File/resId/Uri/String)
        .resize(width, height)
        .centerInside()
        .into(imageView);

二、源码分析

（一）Picasso.with进行一系列初始化

public static Picasso with(Context context) {
    if (singleton == null) {
        synchronized (Picasso.class) {
            if (singleton == null) {
                singleton = new Builder(context).build();
            }
        }
    }
    return singleton;
}

简单的多线程单例模式；同时使用Buidler模式来创建Picasso实例。

1、Picasso.Builder#build:

/** Start building a new {@link Picasso} instance. */
public Builder(Context context) {
    if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
    }
    this.context = context.getApplicationContext();
}

private Downloader downloader;
private ExecutorService service;
private Cache cache;
private Listener listener;
private RequestTransformer transformer;
private List requestHandlers;
private Bitmap.Config defaultBitmapConfig;
/** Create the {@link Picasso} instance. */
public Picasso build() {
    Context context = this.context;

    // 为这一系列变量进行默认初始化
    // Downloader执行实际的下载业务，返回Response
    if (downloader == null) {
        downloader = Utils.createDefaultDownloader(context);
    }
    // 内存缓存，可以看到默认的是LruCache
    if (cache == null) {
        cache = new LruCache(context);
    }
    // 线程池，执行网络请求的地方
    if (service == null) {
        service = new PicassoExecutorService();
    }
    // request发送前进行处理
    if (transformer == null) {
        transformer = RequestTransformer.IDENTITY;
    }
    // 用以统计
    Stats stats = new Stats(cache);
    // 进行Request以及Response的转发
    Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

    // 创建一个Picasso
    return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
            defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
}

可以看到这里为许多重要类进行了默认初始化，后面获取图片使用到的都是这些默认的变量，当然这些变量也都可以进行自定义；
Downloader：默认实现是OkHttpDownloader，Picasso是对OkHttp的封装，它的网络请求以及对本地Cache的请求都是直接通过OkHttp来实现的；Downloader是实现本地磁盘查询，以及发起网络请求的类；
Cache：内存缓存；这里采用的LruCache，也可以自行定义。缓存的是进行网络请求后，大小等裁剪之后的图片资源。
PicassoExecutorService： Picasso之中的线程池，默认核心线程为3个，没有非核心线程；但也会根据手机当前的网络状态进行适时改变，比如WIFI状态的核心线程就为4个，而4G，3G，2G状态下的线程数分别为3,2,1个；
Stats：进行一些数据统计，比如图片下载命中率等。
RequestTransformer:用来预处理Request，必须修改域名等
Dispatcher：用以分发任务，它通过启动了一个DispatcherThread线程，然后创建一个用来处理消息的DispatcherHandler，该Handler的数据处理是在DispatcherThread中进行的。
RequestHandler： 后面将会看到，该对象用来持有一个具体的Request，所有Request最终其实都是由其对应的RequestHandler来进行处理的。

根据后面具体使用情况再做分析：

2、Picasso#load:

public RequestCreator load(String path) {
    if (path == null) {
        return new RequestCreator(this, null, 0);
    }
    if (path.trim().length() == 0) {
        throw new IllegalArgumentException("Path must not be empty.");
    }
    return load(Uri.parse(path));
}

public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
}

这里创建一个RequestCreator

private final Picasso picasso;
private final Request.Builder data;

RequestCreator(Picasso picasso, Uri uri, int resourceId) {
    if (picasso.shutdown) {
        throw new IllegalStateException(
                "Picasso instance already shut down. Cannot submit new requests.");
    }
    this.picasso = picasso;
    this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
}

data对应创建一个Request的Builder，这个Request中封装了了相应的请求信息，传入了请求加载图片的URI，已经resourceId，以及默认显示图片的配置信息。
进而一般调用into将图片加载到相应的控件中。

3、RequestCreator#into：

// RequestCreator.java
public void into(ImageView target) {
    into(target, null);
}

public void into(ImageView target, Callback callback) {
    long started = System.nanoTime();
    // 盘算是否是在主线程，如果不是则会抛出异常
    checkMain();

    if (target == null) {
        throw new IllegalArgumentException("Target must not be null.");
    }

    // 判断reqeust是否合法，即存在URI或者对应的resId，否则会取消该请求
    if (!data.hasImage()) {
        picasso.cancelRequest(target);
        if (setPlaceholder) {
            setPlaceholder(target, getPlaceholderDrawable());
        }
        return;
    }

    // 判断是否需要延期执行
    if (deferred) {
        // 判断是否已经设置了宽高大小
        if (data.hasSize()) {
            throw new IllegalStateException("Fit cannot be used with resize.");
        }
        // 获取目标控件的宽高参数
        int width = target.getWidth();
        int height = target.getHeight();
        // 表示当前控件并未加载到界面上（宽或高为0）
        if (width == 0 || height == 0) {
            if (setPlaceholder) {
                setPlaceholder(target, getPlaceholderDrawable());
            }
            // 生成DeferredRequestCreator，加入相应队列进行处理
            picasso.defer(target, new DeferredRequestCreator(this, target, callback));
            return;
        }
        // 设置Request.Builder中的宽高参数大小
        data.resize(width, height);
    }

    // 创建Request
    Request request = createRequest(started);
    // 获取request对应的key
    String requestKey = createKey(request);

    // 根据策略判断是够需要跳过读取MemoryCache
    if (shouldReadFromMemoryCache(memoryPolicy)) { // 尝试从MemoryCache中获取Bitmap
        // 根据Requeskey来获取相应的Bitmap
        Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
        if (bitmap != null) {
            // 如果从MemoryCache中获取到相应的bitmap，则取消request
            picasso.cancelRequest(target);
            // 设置图片
            setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
            if (picasso.loggingEnabled) {
                log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
            }
            // 调用回调callback的onSuccess函数
            if (callback != null) {
                callback.onSuccess();
            }
            return;
        }
    }

    // 如果从MemoryCache获取图片失败，或者根据缓存策略直接跳过读取MemoryCache，则设置默认图片
    if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
    }

    // 创建ImageViewAction，Action里面包含了一次请求所需要的所有信息
    Action action =
            new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
                    errorDrawable, requestKey, tag, callback, noFade);

    // 将action入队列
    picasso.enqueueAndSubmit(action);
}

整个图片加载流程和一般的三级缓存加载流程相似，下图已经介绍地很清晰：

上面主要是尝试从MemoryCache中获取对应Bitmap，如果获取失败，再创建Action，通过将Action入队列，然后从本地Cache以及网络上去获取该图片。
接着上面enqueueAndSubmit继续分析

4、Picasso#enqueueAndSubmit：

// Picasso.java
final Map targetToAction;

void enqueueAndSubmit(Action action) {
    // 根据Action获取对应的Target
    Object target = action.getTarget();
    if (target != null && targetToAction.get(target) != action) {
        // This will also check we are on the main thread.
        // 取消该target对应的以前的请求
        cancelExistingRequest(target);
        // 添加当前请求
        targetToAction.put(target, action);
    }
    // 提交action
    submit(action);
}

targetToAction是一个Map，它存储的是Target对应的Action，以Target为相应key值。
当新添加一个action时，首先尝试取消该Action对应的Target之前的Action请求，然后将新Action添加到Map中；
然后提交action请求；

先来看下取消一个Request的函数cancelExistingReqeust，常用的cancelReqeust也是直接调用该函数实现的：

// Picasso.java
final Map targetToAction;

private void cancelExistingRequest(Object target) {
    // 判断是否在主线程中进行
    checkMain();
    // 从Map中移除该target对应action
    Action action = targetToAction.remove(target);
    // 如果该Target之前存在对应的action
    if (action != null) {
        // 则调用该action的cancel函数进行取消
        action.cancel();
        // 并且调用Dispatcher进行分发cancel请求
        dispatcher.dispatchCancel(action);
    }
    // 对于ImageView类型的Target
    if (target instanceof ImageView) {
        ImageView targetImageView = (ImageView) target;
        // 前面分析提到可能有需要延迟操作的请求，它是通过添加到DeferredRequestCreator来实现的，这里的需要将其cancel掉
        DeferredRequestCreator deferredRequestCreator =
                targetToDeferredRequestCreator.remove(targetImageView);
        if (deferredRequestCreator != null) {
            deferredRequestCreator.cancel();
        }
    }
}

简单的cancel逻辑：
这里依然也需要先判断事件处理是否是在主线程中进行的；
然后尝试从targetToAction中删除该Target中对应的Action，如果该Action确实存在，则调用cancel函数取消该Action，并且调用Dispatcher来分发该cancel请求；
对应ImageView类型的target，前面分析中提到当需要defer即延迟的请求时，是通过创建DeferredReqeustCreator，并添加到一个Map中来实现的，这里同理应将其删除并cancel掉；
再来看看其cancel函数：

1）Action#cancel:

// ImageViewAction.java
class ImageViewAction extends Action {
    Callback callback;
    @Override void cancel() {
        super.cancel();
        if (callback != null) {
            callback = null;
        }
    }
}

// Action.java
abstract class Action {
    boolean cancelled;
    void cancel() {
        cancelled = true;
    }
}

和Volley这些差不多，通过设置一个cancel标志来实现。

2） Dispatcher#dispatchCacnel

// Dispatcher.java
void dispatchCancel(Action action) {
    handler.sendMessage(handler.obtainMessage(REQUEST_CANCEL, action));
}

分发逻辑较为简单，使用Handler来实现的；
这里来具体来看下Dispatcher的定义，来确定handler的定义；Dispathcer是在创建Picasso时默认创建了一个Dispathcer实例，如下所示：

// Picasso.java
Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            ...
        }
    }
}

而Dispatcher中的Handler并不是这个Handler，而是又做了一个封装：

this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);

// Dispatcher.java
private static class DispatcherHandler extends Handler {
    private final Dispatcher dispatcher;

    public DispatcherHandler(Looper looper, Dispatcher dispatcher) {
        super(looper);
        this.dispatcher = dispatcher;
    }

    @Override public void handleMessage(final Message msg) {
        switch (msg.what) {
            case REQUEST_SUBMIT: {
                Action action = (Action) msg.obj;
                dispatcher.performSubmit(action);
                break;
            }
            case REQUEST_CANCEL: {
                Action action = (Action) msg.obj;
                dispatcher.performCancel(action);
                break;
            }
            .......
            default:
                Picasso.HANDLER.post(new Runnable() {
                    @Override public void run() {
                        throw new AssertionError("Unknown handler message received: " + msg.what);
                    }
                });
        }
    }
}

Dispathcer的作用是通过handler将相应的操作逻辑转换到自己Looper对应线程中去实现，然后调用performCancel去具体处理该Action；
下面接着来看Dispatcher#performCancel：

// Dispatcher.java
final Map hunterMap;
final Set