图片请求处理简单框架

• 图片请求处理框架图示
  
• 代码实现
  1.Request的封装

import android.content.Context;
import android.widget.ImageView;
import java.lang.ref.SoftReference;

public class BitmapRequest {

    private Context mContext;
    // 图片请求地址
    private String url;
    private SoftReference<ImageView> mImageView;
    // 占位图片
    private int resId;
    // 回调对象
    private RequestListener mRequestListener;
    // 图片标识
    private String urlMd5;

    public BitmapRequest(Context context) {
        this.mContext = context;
    }

    public BitmapRequest load(String url) {
        this.url = url;
//        this.urlMd5 =
        return this;
    }

    public BitmapRequest loading(int resId) {
        this.resId = resId;
        return this;
    }

    public BitmapRequest setListener(RequestListener listener) {
        this.mRequestListener = listener;
        return this;
    }

    public void into(ImageView imageView) {
        imageView.setTag(urlMd5);
        this.mImageView = new SoftReference<>(imageView);
        // 将图片请求添加到队列中去
        RequestManager.getInstance().addBitmapRequest(this);
    }

    public String getUrl() {
        return url;
    }

    public ImageView getImageView() {
        return mImageView.get();
    }

    public int getResId() {
        return resId;
    }

    public RequestListener getRequestListener() {
        return mRequestListener;
    }

    public String getUrlMd5() {
        return urlMd5;
    }
}

2.请求分发器（BitmapDispatcher）对应上图中服务（RequestDispatcher）

import android.graphics.Bitmap;
import android.os.Handler;
import android.os.Looper;
import android.widget.ImageView;
import java.util.concurrent.LinkedBlockingQueue;

public class BitmapDispatcher extends Thread {

    private Handler mMainHandler = new Handler(Looper.getMainLooper());
    // 创建一个阻塞队列
    private LinkedBlockingQueue<BitmapRequest> requestQueue;

    public BitmapDispatcher(LinkedBlockingQueue requestQueue) {
        this.requestQueue = requestQueue;
    }

    @Override
    public void run() {
        super.run();
        while (!this.isInterrupted()) {
            try {
                // 获取请求
                BitmapRequest br = requestQueue.take();
                // 设置占位图
                showLoadingImage(br);
                // 加载图片
                Bitmap bitmap = findBitmap(br);
                // 将图片显示到ImageView中
                showImageView(br, bitmap);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void showLoadingImage(BitmapRequest br) {
        if (br.getResId() > 0 && br.getImageView() != null) {
            final int resId = br.getResId();
            final ImageView imageView = br.getImageView();
            mMainHandler.post(new Runnable() {
                @Override
                public void run() {
                    imageView.setImageResource(resId);
                }
            });
        }
    }

    private Bitmap findBitmap(BitmapRequest br) {
        Bitmap bitmap = downloadBitmap(br.getUrl());
        return bitmap;
    }

    private void showImageView(final BitmapRequest br, final Bitmap bitmap) {

        if (bitmap != null && br.getImageView() != null && br.getUrlMd5().equals(br.getImageView().getTag())) {
            final ImageView imageView = br.getImageView();
            mMainHandler.post(new Runnable() {
                @Override
                public void run() {
                    imageView.setImageBitmap(bitmap);
                    if (br.getRequestListener() != null) {
                        RequestListener requestListener = br.getRequestListener();
                        requestListener.onSuccess(bitmap);
                    }
                }
            });
        }

    }

    /**
     * 从网上下载图片
     * @param url
     * @return
     */
    private Bitmap downloadBitmap(String url) {
        return null;
    }
}

3.RequestManager 对应上图中的服务大厅

import java.util.concurrent.LinkedBlockingQueue;

public class RequestManager {

    private static RequestManager requestManager = new RequestManager();
    private LinkedBlockingQueue<BitmapRequest> requestQueue = new LinkedBlockingQueue<>();

    // 创建线程数组
    private BitmapDispatcher[] mBitmapDispatchers;

    private RequestManager() {
        start();
    }

    public void start() {
        stop();
        startAllDispatcher();
    }

    // 提醒窗口开始服务
    public void startAllDispatcher() {
        // 获取手机支持的单个应用最大的线程数
        int threadCount = Runtime.getRuntime().availableProcessors();
        mBitmapDispatchers = new BitmapDispatcher[threadCount];
        for (int i = 0; i < threadCount; i++) {
            BitmapDispatcher bitmapDispatcher = new BitmapDispatcher(requestQueue);
            bitmapDispatcher.start();

            // 将每个dispatcher放到数组中，方便统一管理
            mBitmapDispatchers[i] = bitmapDispatcher;
        }
    }

    // 停止所有线程
    public void stop() {
        if (mBitmapDispatchers != null && mBitmapDispatchers.length > 0) {
            for (BitmapDispatcher bitmapDispatcher : mBitmapDispatchers) {
                if (!bitmapDispatcher.isInterrupted()) {
                    bitmapDispatcher.interrupt();
                }
            }
        }
    }

    public static RequestManager getInstance() {
        return requestManager;
    }

    // 将图片请求添加到请求队列
    public void addBitmapRequest(BitmapRequest bitmapRequest) {
        if (bitmapRequest == null) {
            return;
        }
        if (!requestQueue.contains(bitmapRequest)) {
            requestQueue.add(bitmapRequest);
        }
    }
}

注：代码并不是很完善，重在理解思想！！！