一.我们先来看看哪些重要的实现类: Picasso: 图片加载、转换、缓存的管理类。单列模式 ,通过with方法获取实例,也是加载图片的入口。 RequestCreator: Request构建类,Builder 模式,采用链式设置该Request的属性(如占位图、缓存策略、裁剪规则、显示大小、优先级等等)。最后调用build()方法生成一个请求(Request)。 DeferredRequestCreator:RequestCreator的包装类,当创建请求的时候还不能获取ImageView的宽和高的时候,则创建一个DeferredRequestCreator,DeferredRequestCreator里对 target 设置监听,直到可以获取到宽和高的时候重新执行请求创建。 Action: 请求包装类,存储了该请求和RequestCreator设置的这些属性,最终提交给线程执行下载。 Dispatcher:分发器,分发执行各种请求、分发结果等等。 PicassoExecutorService:Picasso使用的线程池,默认池大小为3。 LruCache:一个使用最近最少使用策略的内存缓存。 BitmapHunter:这是Picasso的一个核心的类,开启线程执行下载,获取结果后解码成Bitmap,然后做一些转换操作如图片旋转、裁剪等,如果请求设置了转换器Transformation,也会在BitmapHunter里执行这些转换操作。 NetworkRequestHandler:网络请求处理器,如果图片需要从网络下载,则用这个处理器处理。 FileRequestHandler:文件请求处理器,如果请求的是一张存在文件中的图片,则用这个处理器处理。 AssetRequestHandler: Asset 资源图片处理器,如果是加载asset目录下的图片,则用这个处理器处理。 ResourceRequestHandler:Resource资源图片处理器,如果是加载res下的图片,则用这个处理器处理。 ContentStreamRequestHandler: ContentProvider 处理器,如果是ContentProvider提供的图片,则用这个处理器处理 MediaStoreRequestHandler: MediaStore 请求处理器,如果图片是存在MediaStore上的则用这个处理器处理。 ContactsPhotoRequestHandler:ContactsPhoto 请求处理器,如果加载com.android.contacts/ 下的tu图片用这个处理器处理 Response: 返回的结果信息,Stream流或者Bitmap。 Request: 请求实体类,存储了应用在图片上的信息。 Target:图片加载的监听器接口,有3个回调方法,onPrepareLoad 在请求提交前回调,onBitmapLoaded 请求成功回调,并返回Bitmap,onBitmapFailed请求失败回调。 PicassoDrawable:继承BitmapDrawable,实现了过渡动画和图片来源的标识(就是图片来源的指示器,要调用 setIndicatorsEnabled(true)方法才生效),请求成功后都会包装成BitmapDrawable显示到ImageView 上。 OkHttpDownloader:用OkHttp实现的图片下载器,默认就是用的这个下载器。 UrlConnectionDownloader:使用HttpURLConnection 实现的下载器。 MemoryPolicy: 内存缓存策略,一个枚举类型。 NetworkPolicy: 磁盘缓存策略,一个枚举类型。 Stats: 这个类相当于日志记录,会记录如:内存缓存的命中次数,丢失次数,下载次数,转换次数等等,我们可以通过StatsSnapshot类将日志打印出来,看一下整个项目的图片加载情况。 StatsSnapshot :状态快照,和上面的Stats对应,打印Stats纪录的信息。 二.基本使用 Picasso.with(this).load(URL) .placeholder(R.drawable.icon_bg) .error(R.drawable.icon_iamge) .into(image); 三.源码分析 1.首先要获取一个Picasso对象,采用的单例模式 //单例模式获取Picasso 对象 public static Picasso with(Context context) { if (singleton == null) { synchronized (Picasso.class) { if (singleton == null) { singleton = new Builder(context).build(); } } } return singleton; } // 真正new 的地方在build()方法里 public Picasso build() { Context context = this.context; if (downloader == null) { //配置默认的下载器,首先通过反射获取OkhttpClient,如果获取到了,就使用OkHttpDwownloader作为默认下载器 //如果获取不到就使用UrlConnectionDownloader作为默认下载器 downloader = Utils.createDefaultDownloader(context); } if (cache == null) { // 配置内存缓存,大小为手机内存的15% cache = new LruCache(context); } if (service == null) { // 配置Picaso 线程池,核心池大小为3 service = new PicassoExecutorService(); } if (transformer == null) { // 配置请求转换器,默认的请求转换器没有做任何事,直接返回原请求 transformer = RequestTransformer.IDENTITY; } Stats stats = new Stats(cache); //分发器 Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats); return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats, defaultBitmapConfig, indicatorsEnabled, loggingEnabled); } 2.通过load方法生成一个RequestCreator,用链式api 来构建一个图片下载请求,RequestCreator提供了很多的API 来构建请求,如展位图、大小、转换器、裁剪等等,这些API其实是为对应的属性赋值,最终会在into方法中构建请求。 //load有几个重载方法,参数为string和File 的重载最重都会包装成一个Uri 调用这个方法 public RequestCreator load(Uri uri) { return new RequestCreator(this, uri, 0); } // 如果是加载资源id 的图片会调用这个方法 public RequestCreator load(int resourceId) { if (resourceId == 0) { throw new IllegalArgumentException("Resource ID must not be zero."); } return new RequestCreator(this, null, resourceId); } // 配置占位图,在加载图片的时候显示 public RequestCreator placeholder(int placeholderResId) { if (!setPlaceholder) { throw new IllegalStateException("Already explicitly declared as no placeholder."); } if (placeholderResId == 0) { throw new IllegalArgumentException("Placeholder image resource invalid."); } if (placeholderDrawable != null) { throw new IllegalStateException("Placeholder image already set."); } this.placeholderResId = placeholderResId; return this; } // 配置真正显示的大小 public RequestCreator resize(int targetWidth, int targetHeight) { data.resize(targetWidth, targetHeight); return this; } 3.into 添加显示的View,并且提交下载请求 into方法里面干了3件事情: 1.判断是否设置了fit 属性,如果设置了,再看是否能够获取ImageView 的宽高,如果获取不到,生成一个DeferredRequestCreator(延迟的请求管理器),然后直接return,在DeferredRequestCreator中当监听到可以获取ImageView 的宽高的时候,再执行into方法。 2.判断是否从内存缓存获取图片,如果没有设置NO_CACHE,则从内存获取,命中直接回调CallBack 并且显示图片。 3.如果缓存未命中,则生成一个Action,并提交Action。 public void into(ImageView target, Callback callback) { long started = System.nanoTime(); // 检查是否在主线程 checkMain(); if (target == null) { throw new IllegalArgumentException("Target must not be null."); } //如果没有url或者resourceId 则取消请求 if (!data.hasImage()) { picasso.cancelRequest(target); if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } return; } //判断是否设置了fit属性 if (deferred) { if (data.hasSize()) { throw new IllegalStateException("Fit cannot be used with resize."); } int width = target.getWidth(); int height = target.getHeight(); if (width == 0 || height == 0) { if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } //如果获取不到宽高,生成一个DeferredRequestCreator(延迟的请求管理器),然后直接return, //在DeferredRequestCreator中当监听到可以获取ImageView 的宽高的时候,再执行into方法。 picasso.defer(target, new DeferredRequestCreator(this, target, callback)); return; } data.resize(width, height); } Request request = createRequest(started); String requestKey = createKey(request); //是否从内存缓存中获取 if (shouldReadFromMemoryCache(memoryPolicy)) { Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey); if (bitmap != null) { //缓存命中,取消请求,并显示图片 picasso.cancelRequest(target); setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled); if (picasso.loggingEnabled) { log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY); } if (callback != null) { callback.onSuccess(); } return; } } if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } //内存缓存未命中或者设置了不从内存缓存获取,则生成一个Action ,提交执行。 Action action = new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId, errorDrawable, requestKey, tag, callback, noFade); picasso.enqueueAndSubmit(action);// 提交请求 } 4.提交、分发、执行请求 会经过下面这一系列的操作,最重将Action 交给BitmapHunter 执行。 enqueueAndSubmit -> submit -> dispatchSubmit -> performSubmit: //将action 保存到了一个Map 中,目标View作为key void enqueueAndSubmit(Action action) { Object target = action.getTarget(); if (target != null && targetToAction.get(target) != action) { // This will also check we are on the main thread. cancelExistingRequest(target); targetToAction.put(target, action); } submit(action); } // 交给分发器分发提交请求 void submit(Action action) { dispatcher.dispatchSubmit(action); } //执行请求提交 //1, 先查看保存暂停tag表里面没有包含Action的tag,如果包含,则将Action 存到暂停Action表里 //2,从BitmapHunter表里查找有没有对应action的hunter,如果有直接attach //3, 为这个请求生成一个BitmapHunter,提交给线程池执行 void performSubmit(Action action, boolean dismissFailed) { // 先查看保存暂停tag表里面没有包含Action的tag,如果包含,则将Action 存到暂停Action表里 if (pausedTags.contains(action.getTag())) { pausedActions.put(action.getTarget(), action); if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_PAUSED, action.request.logId(), "because tag '" + action.getTag() + "' is paused"); } return; } BitmapHunter hunter = hunterMap.get(action.getKey()); if (hunter != null) { hunter.attach(action); return; } // 如果线程池北shutDown,直接return if (service.isShutdown()) { if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), "because shut down"); } return; } // 为请求生成一个BitmapHunter hunter = forRequest(action.getPicasso(), this, cache, stats, action); hunter.future = service.submit(hunter);//提交执行 hunterMap.put(action.getKey(), hunter); if (dismissFailed) { failedActions.remove(action.getTarget()); } if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId()); } } 5.指定对应的处理器(RequestHandler) 在上面执行的请求的performSubmit 方法里,调用了forRequest 方法为对应的Action 生成一个BitmapHunter,里面有一个重要的步骤,指定请求处理器(在上面一节介绍Picasso有7种请求处理器,看一下对应的代码: // 1,首先调用了getRequestHandlers List<RequestHandler> getRequestHandlers() { return requestHandlers; } // 2 requestHandlers 列表是在Picasso 构造函数里出实话的 Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener, RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats, Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) { .... //前面代码省略 // 添加了7个内置的请求处理器 // 如果你自己通过Builder添了额外的处理器,也会添加在这个列表里面 int builtInHandlers = 7; // Adjust this as internal handlers are added or removed. int extraCount = (extraRequestHandlers != null ? extraRequestHandlers.size() : 0); List<RequestHandler> allRequestHandlers = new ArrayList<RequestHandler>(builtInHandlers + extraCount); // ResourceRequestHandler needs to be the first in the list to avoid // forcing other RequestHandlers to perform null checks on request.uri // to cover the (request.resourceId != 0) case. allRequestHandlers.add(new ResourceRequestHandler(context)); if (extraRequestHandlers != null) { allRequestHandlers.addAll(extraRequestHandlers); } allRequestHandlers.add(new ContactsPhotoRequestHandler(context)); allRequestHandlers.add(new MediaStoreRequestHandler(context)); allRequestHandlers.add(new ContentStreamRequestHandler(context)); allRequestHandlers.add(new AssetRequestHandler(context)); allRequestHandlers.add(new FileRequestHandler(context)); allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats)); requestHandlers = Collections.unmodifiableList(allRequestHandlers); //后面代码省略 ... } 6.介绍过BitmapHunter,BitmapHunter继承Runnable,其实就是开启一个线程执行最终的下载。看一下源码: @Override public void run() { try { updateThreadName(data); if (picasso.loggingEnabled) { log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this)); } // 调用hunt() 方法获取最终结果 result = hunt(); if (result == null) { dispatcher.dispatchFailed(this);//如果为null,分发失败的消息 } else { dispatcher.dispatchComplete(this);//如果不为null,分发成功的消息 } } catch (Downloader.ResponseException e) { if (!e.localCacheOnly || e.responseCode != 504) { exception = e; } dispatcher.dispatchFailed(this); } catch (NetworkRequestHandler.ContentLengthException e) { exception = e; dispatcher.dispatchRetry(this); } catch (IOException e) { exception = e; dispatcher.dispatchRetry(this); } catch (OutOfMemoryError e) { StringWriter writer = new StringWriter(); stats.createSnapshot().dump(new PrintWriter(writer)); exception = new RuntimeException(writer.toString(), e); dispatcher.dispatchFailed(this); } catch (Exception e) { exception = e; dispatcher.dispatchFailed(this); } finally { Thread.currentThread().setName(Utils.THREAD_IDLE_NAME); } } 当将一个bitmapHunter submit 给一个线程池执行的时候,就会执行run() 方法,run里面调用的是hunt方法来获取结果 7.Downloader 下载器下载图片 上面的hunt方法获取结果的时候,最终调用的是配置的处理器的load方法,如下: RequestHandler.Result result = requestHandler.load(data, networkPolicy); NetworkRequestHandler最终是调用的downloader 的load方法下载图片。内置了2个Downloader,OkhttpDownloader和UrlConnectionDownloader 。我们以UrlConnectionDownloader为例,来看一下load方法: @Override public Response load(Uri uri, int networkPolicy) throws IOException { // 如果SDK 版本大于等于14,安装磁盘缓存,用的是HttpResponseCache(缓存http或者https的response到文件系统) if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) { installCacheIfNeeded(context); } HttpURLConnection connection = openConnection(uri); //设置使用缓存 connection.setUseCaches(true); if (networkPolicy != 0) { String headerValue; // 下面一段代码是设置缓存策略 if (NetworkPolicy.isOfflineOnly(networkPolicy)) { headerValue = FORCE_CACHE; } else { StringBuilder builder = CACHE_HEADER_BUILDER.get(); builder.setLength(0); if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) { builder.append("no-cache"); } if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) { if (builder.length() > 0) { builder.append(','); } builder.append("no-store"); } headerValue = builder.toString(); } connection.setRequestProperty("Cache-Control", headerValue); } int responseCode = connection.getResponseCode(); if (responseCode >= 300) { connection.disconnect(); throw new ResponseException(responseCode + " " + connection.getResponseMessage(), networkPolicy, responseCode); } long contentLength = connection.getHeaderFieldInt("Content-Length", -1); boolean fromCache = parseResponseSourceHeader(connection.getHeaderField(RESPONSE_SOURCE)); // 最后获取InputStream流包装成Response返回 return new Response(connection.getInputStream(), fromCache, contentLength); } 8.显示在控件上 在BitmapHunter获取结果后,分发器分发结果,通过Hander处理后,执行performComplete方法: void performComplete(BitmapHunter hunter) { // 这里将结果缓存到内存 if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) { cache.set(hunter.getKey(), hunter.getResult()); } hunterMap.remove(hunter.getKey());// 请求完毕,将hunter从表中移除 batch(hunter); if (hunter.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion"); } } // 2,然后将BitmapHunter添加到一个批处理列表,通过Hander发送一个批处理消息 private void batch(BitmapHunter hunter) { if (hunter.isCancelled()) { return; } batch.add(hunter); if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) { handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY); } } // 3,最后执行performBatchComplete 方法,通过主线程的Handler送处理完成的消息 void performBatchComplete() { List<BitmapHunter> copy = new ArrayList<BitmapHunter>(batch); batch.clear(); mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy)); logBatch(copy); } // 4,最后在Picasso 中handleMessage,显示图片 static final Handler HANDLER = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(Message msg) { switch (msg.what) { case HUNTER_BATCH_COMPLETE: { @SuppressWarnings("unchecked") List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj; //noinspection ForLoopReplaceableByForEach for (int i = 0, n = batch.size(); i < n; i++) { BitmapHunter hunter = batch.get(i); hunter.picasso.complete(hunter); } break; } //后面代码省略 ... }; // 5,最后回调到ImageViewAction 的complete方法显示图片 @Override public void complete(Bitmap result, Picasso.LoadedFrom from) { if (result == null) { throw new AssertionError( String.format("Attempted to complete action with no result!\n%s", this)); } ImageView target = this.target.get(); if (target == null) { return; } Context context = picasso.context; boolean indicatorsEnabled = picasso.indicatorsEnabled; //将结果包装成一个PicassoDrawable 并显示 PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled); if (callback != null) { callback.onSuccess(); 回调callback } } 以上8步就是图片加载整个过程
Picasso图片加载源码分析
最新推荐文章于 2021-12-23 22:09:20 发布