Android 学习笔记之Volley(八)实现网络图片的数据加载

PS:最后一篇关于Volley框架的博客...

学习内容：

1.使用ImageRequest.java实现网络图片加载

2.使用ImageLoader.java实现网络图片加载

3.使用NetWorkImageView.java实现网络图片加载

  Volley的第三个作用就是实现网络图片的加载，图片加载在Volley中有三种不同的方式，各有各的用法，只是后两个还算是有相关联系的，因为NetWorkImageView是基于ImageLoader的..内部的图片加载还是使用ImageLoader，只是在后续的过程中有一些不同...

1.ImageRequest.java

  使用ImageRequest加载图片数据，ImageRequest没有什么特殊的，也需要建立一个请求队列，向请求队列当中添加这次请求就可以完成图片数据的加载...

package com.android.volley.toolbox;

import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyLog;

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;

public class ImageRequest extends Request<Bitmap> {
    /** Socket timeout in milliseconds for image requests */
    private static final int IMAGE_TIMEOUT_MS = 1000; //超时时间的定义..

    /** Default number of retries for image requests */
    private static final int IMAGE_MAX_RETRIES = 2; //一次最多重试的图片数量...

    /** Default backoff multiplier for image requests */
    private static final float IMAGE_BACKOFF_MULT = 2f; //后退请求的数量..

    private final Response.Listener<Bitmap> mListener; //成功监听..
    private final Config mDecodeConfig;  //属性编码...
    private final int mMaxWidth;    //最大宽度...
    private final int mMaxHeight;   //最大高度...

    /** Decoding lock so that we don't decode more than one image at a time (to avoid OOM's) */
    private static final Object sDecodeLock = new Object(); //一个编码锁..目的是一次只能对一个图片进行编码，加载，避免OOM的发生...
    //指定url来创建一个ImageRequest请求...
    public ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight,
            Config decodeConfig, Response.ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        setRetryPolicy(
                new DefaultRetryPolicy(IMAGE_TIMEOUT_MS, IMAGE_MAX_RETRIES, IMAGE_BACKOFF_MULT));
        mListener = listener;
        mDecodeConfig = decodeConfig;
        mMaxWidth = maxWidth;
        mMaxHeight = maxHeight;
    }
    //获取优先级...图片加载的优先级一般是最低的..
    @Override
    public Priority getPriority() {
        return Priority.LOW;
    }

    //重新设置图片的大小...其实为了缩小图片...
    private static int getResizedDimension(int maxPrimary, int maxSecondary, int actualPrimary,
            int actualSecondary) {
        // If no dominant value at all, just return the actual.
        if (maxPrimary == 0 && maxSecondary == 0) {
            return actualPrimary;
        }

        // If primary is unspecified, scale primary to match secondary's scaling ratio.
        if (maxPrimary == 0) {
            double ratio = (double) maxSecondary / (double) actualSecondary;
            return (int) (actualPrimary * ratio);
        }

        if (maxSecondary == 0) {
            return maxPrimary;
        }

        double ratio = (double) actualSecondary / (double) actualPrimary;
        int resized = maxPrimary;
        if (resized * ratio > maxSecondary) {
            resized = (int) (maxSecondary / ratio);
        }
        return resized;
    }
    //解析响应...
    @Override
    protected Response<Bitmap> parseNetworkResponse(NetworkResponse response) {
        // Serialize all decode on a global lock to reduce concurrent heap usage.
        synchronized (sDecodeLock) {
            try {
                return doParse(response); //调用doParse函数..
            } catch (OutOfMemoryError e) {
                VolleyLog.e("Caught OOM for %d byte image, url=%s", response.data.length, getUrl());
                return Response.error(new ParseError(e));
            }
        }
    }

    /**
     * The real guts of parseNetworkResponse. Broken out for readability.
     */
    //获取图片数据的过程...
    private Response<Bitmap> doParse(NetworkResponse response) {
        byte[] data = response.data;  //图片数据...
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();  //定义一个位图选项对象..
        Bitmap bitmap = null;
        if (mMaxWidth == 0 && mMaxHeight == 0) {//这里表示如果为0，那么表示图片按照图片本身的大小进行展现..不用进行其他操作...
            decodeOptions.inPreferredConfig = mDecodeConfig;
            bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);
        } else {
            // If we have to resize this image, first get the natural bounds.
            decodeOptions.inJustDecodeBounds = true; //表示图片需要缩放..
            BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);//这里并不是完全对图片进行编码，而是获取图片的基本参数..
            int actualWidth = decodeOptions.outWidth; //获取图片的宽度...
            int actualHeight = decodeOptions.outHeight; //获取图片的高度..

            // Then compute the dimensions we would ideally like to decode to.
            int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                    actualWidth, actualHeight); //对宽度进行缩放...
            int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                    actualHeight, actualWidth); //对高度进行缩放...

            // Decode to the nearest power of two scaling factor.
            decodeOptions.inJustDecodeBounds = false; //缩放后，表示图片不需要进行缩放了...
            // TODO(ficus): Do we need this or is it okay since API 8 doesn't support it?
            // decodeOptions.inPreferQualityOverSpeed = PREFER_QUALITY_OVER_SPEED;
            decodeOptions.inSampleSize =
                findBestSampleSize(actualWidth, actualHeight, desiredWidth, desiredHeight);//根据实际大小和所需大小去找到一个最合适的大小...
            Bitmap tempBitmap =
                BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);//对图片编码，转化成比特流的形式...

            // If necessary, scale down to the maximal acceptable size.
            if (tempBitmap != null && (tempBitmap.getWidth() > desiredWidth ||
                    tempBitmap.getHeight() > desiredHeight)) {
                //这里表示如果通过上述缩放后图片的大小仍然比所需大小要大，那么按照所需大小进一步进行缩放...
                bitmap = Bitmap.createScaledBitmap(tempBitmap,
                        desiredWidth, desiredHeight, true);
                tempBitmap.recycle();
            } else {
                bitmap = tempBitmap; //否则直接为当前临时图片...
            }
        }

        if (bitmap == null) {
            return Response.error(new ParseError(response)); //返回错误数据..
        } else {
            return Response.success(bitmap, HttpHeaderParser.parseCacheHeaders(response)); //返回成功数据...
        }
    }
    //对响应分发...
    @Override
    protected void deliverResponse(Bitmap response) {
        mListener.onResponse(response);
    }

    //需找最优大小..
    static int findBestSampleSize(
            int actualWidth, int actualHeight, int desiredWidth, int desiredHeight) {
        double wr = (double) actualWidth / desiredWidth;
        double hr = (double) actualHeight / desiredHeight;
        double ratio = Math.min(wr, hr);
        float n = 1.0f;
        while ((n * 2) <= ratio) {
            n *= 2;
        }

        return (int) n;
    }
} 

  源码看起来其实并不是非常的困难，还是比较好理解的..如果预先对ImageLoader加载图片非常熟悉的话，那么这个理解起来就不是非常的费劲...源码就分析到这，还是看看调用过程..这里的构造函数需要传递六个参数...

  public ImageRequest(url,Listener,maxWidth,maxHeight,Config,errorListener);

  传递的参数分别是url，成功监听，最大宽度和高度，图片使用的颜色属性，以及失败后的监听...这里宽度和高度如果指定成自定义的大小，那么图图片就会按照指定大小进行缩放，如果都指定成0，那么图片按照原本大小进行显示，不进行缩放设置...

package com.example.oop;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley;

import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;

public class MainActivity extends Activity implements OnClickListener {

    String url="http://192.168.199.172:8080/JSP/imageview.jpg";
    ImageView iv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv=(ImageView)findViewById(R.id.iv);
         init();
    }

    public void init(){
        RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
         queue.add(new ImageRequest("http://192.168.199.172:8080/JSP/imageview.jpg",new Listener<Bitmap>(){
        @Override
          public void onResponse(Bitmap response){
            //自定义了一个imageview...图片资源就是下载后的Bitmap
            iv.setImageBitmap(response);
        }
    },0,0,Config.ARGB_8888, new ErrorListener(){
        @Override
         public void onErrorResponse(VolleyError error){
            System.out.println(error.toString());
        }
    }));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub

    }

}

  这样就成功的使用ImageRequest加载了网络上的图片数据...但是使用ImageRequest加载网络图片的缺点是没有缓存机制，只能频繁的发送网络请求，而没有缓存请求，这样会增加服务器的负担...因此在这点上ImageRequest并不是非常的完善...

2.ImageLoader.java

  ImageLoader算是对ImageRequest的一个强化，这个类内部提供了缓存机制，这样我们可以更好的去处理请求，由于存在缓存，那么相同的请求可以通过从缓存中直接获取相关的数据，从而能够减少一些不必要的请求，这样会减少网络请求，减少服务器的负担...

package com.android.volley.toolbox;

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.os.Handler;
import android.os.Looper;
import android.widget.ImageView;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageRequest;

import java.util.HashMap;
import java.util.LinkedList;

public class ImageLoader {
    /** RequestQueue for dispatching ImageRequests onto. */
    private final RequestQueue mRequestQueue; //请求队列..

    /** Amount of time to wait after first response arrives before delivering all responses. */
    private int mBatchResponseDelayMs = 100;  //响应到达的延时...

    /** The cache implementation to be used as an L1 cache before calling into volley. */
    private final ImageCache mCache; //图片缓存对象...

    private final HashMap<String, BatchedImageRequest> mInFlightRequests =
            new HashMap<String, BatchedImageRequest>(); //表示正在处理的请求集合...

    /** HashMap of the currently pending responses (waiting to be delivered). */
    private final HashMap<String, BatchedImageRequest> mBatchedResponses =
            new HashMap<String, BatchedImageRequest>(); //批处理响应的集合..

    /** Handler to the main thread. */
    private final Handler mHandler = new Handler(Looper.getMainLooper());

    /** Runnable for in-flight response delivery. */
    private Runnable mRunnable; //用于分发响应...
    //缓存对象构造...
    public interface ImageCache {
        public Bitmap getBitmap(String url);
        public void putBitmap(String url, Bitmap bitmap);
    }

    //通过一个请求队列和缓存机制来构造一个ImageLoader对象...
    public ImageLoader(RequestQueue queue, ImageCache imageCache) {
        mRequestQueue = queue;
        mCache = imageCache;
    }

    //获取图片监听...
    public static ImageListener getImageListener(final ImageView view,
            final int defaultImageResId, final int errorImageResId) {
        return new ImageListener() { //失败的监听...
            @Override
            public void onErrorResponse(VolleyError error) {
                if (errorImageResId != 0) {
                    view.setImageResource(errorImageResId); //如果加载失败，使用默认图片来显示...
                }
            }

            @Override
            public void onResponse(ImageContainer response, boolean isImmediate) {
                if (response.getBitmap() != null) {
                    view.setImageBitmap(response.getBitmap());//如果响应数据不为空，那么显示网络图片...
                } else if (defaultImageResId != 0) {
                    view.setImageResource(defaultImageResId);//失败显示默认图片...
                }
            }
        };
    }

    //失败监听的一个接口...
    public interface ImageListener extends ErrorListener {

        public void onResponse(ImageContainer response, boolean isImmediate);
    }

    //如果请求允许缓存，那么保存缓存数据...
    public boolean isCached(String requestUrl, int maxWidth, int maxHeight) {
        throwIfNotOnMainThread();

        String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);
        return mCache.getBitmap(cacheKey) != null;
    }

    //调用下面的函数...
    public ImageContainer get(String requestUrl, final ImageListener listener) {
        return get(requestUrl, listener, 0, 0);
    }

    //获取图片的过程...
    public ImageContainer get(String requestUrl, ImageListener imageListener,
            int maxWidth, int maxHeight) {
        // only fulfill requests that were initiated from the main thread.
        throwIfNotOnMainThread();
        //如果缓存中存在，那么从缓存当中取出数据...
        final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);

        Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
        if (cachedBitmap != null) { //缓存存在...
            // Return the cached bitmap.
            ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);//将缓存数据的图片，以及url进行封装，返回...
            imageListener.onResponse(container, true);
            return container;
        }

        ImageContainer imageContainer =
                new ImageContainer(null, requestUrl, cacheKey, imageListener); //缓存不存在，新建立一个ImageContainer对象...

        // Update the caller to let them know that they should use the default bitmap.
        //回调函数，使用默认图片...
        imageListener.onResponse(imageContainer, true);

        // Check to see if a request is already in-flight.
        BatchedImageRequest request = mInFlightRequests.get(cacheKey);  //查看当前执行队列中是否有与之相同的请求..
        if (request != null) {
            // If it is, add this request to the list of listeners.
            request.addContainer(imageContainer); //如果有，那么加入到批处理请求队列当中，由这个请求队列去处理这些相同的请求..
            return imageContainer;
        }

        //如果没有，那么新建立一个请求...
        Request<?> newRequest =
            new ImageRequest(requestUrl, new Listener<Bitmap>() {
                @Override
                public void onResponse(Bitmap response) {
                    onGetImageSuccess(cacheKey, response);
                }
            }, maxWidth, maxHeight,
            Config.RGB_565, new ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    onGetImageError(cacheKey, error);
                }
            });
        //添加新请求到请求队列当中
        mRequestQueue.add(newRequest);
        //向当前请求队列中加入这次请求的键和值...
        mInFlightRequests.put(cacheKey,
                new BatchedImageRequest(newRequest, imageContainer));
        return imageContainer;
    }

    //设置批处理响应的延时...
    public void setBatchedResponseDelay(int newBatchedResponseDelayMs) {
        mBatchResponseDelayMs = newBatchedResponseDelayMs;
    }

    //成功获取图片...
    private void onGetImageSuccess(String cacheKey, Bitmap response) {
        // cache the image that was fetched.
        mCache.putBitmap(cacheKey, response); //向缓存中放入数据...

        // remove the request from the list of in-flight requests.
        BatchedImageRequest request = mInFlightRequests.remove(cacheKey); //请求成功，那么表示所有与之相同的请求都获取到了相关数据，那么就将请求移出队列...

        if (request != null) {
            // Update the response bitmap.
            request.mResponseBitmap = response;

            // Send the batched response
            batchResponse(cacheKey, request);//发送相同请求的响应...
        }
    }

    //获取图片失败的时候和成功时执行的操作基本是相同的...
    private void onGetImageError(String cacheKey, VolleyError error) {
        // Notify the requesters that something failed via a null result.
        // Remove this request from the list of in-flight requests.
        BatchedImageRequest request = mInFlightRequests.remove(cacheKey);

        // Set the error for this request
        request.setError(error);

        if (request != null) {
            // Send the batched response
            batchResponse(cacheKey, request);
        }
    }

    //ImageContainer类..
    public class ImageContainer {

        private Bitmap mBitmap; //图片对象..

        private final ImageListener mListener; //成功监听..

        /** The cache key that was associated with the request */
        private final String mCacheKey; //缓存键值

        /** The request URL that was specified */
        private final String mRequestUrl; //url地址...

        //将图片，url，缓存键值，以及监听的一个封装...
        public ImageContainer(Bitmap bitmap, String requestUrl,
                String cacheKey, ImageListener listener) {
            mBitmap = bitmap;
            mRequestUrl = requestUrl;
            mCacheKey = cacheKey;
            mListener = listener;
        }

        //是否中断了请求...
        public void cancelRequest() {
            if (mListener == null) {
                return;
            }

            BatchedImageRequest request = mInFlightRequests.get(mCacheKey);
            if (request != null) {
                boolean canceled = request.removeContainerAndCancelIfNecessary(this);  //请求如果中断，那么判断是否有必要中断请求...
                if (canceled) {
                    mInFlightRequests.remove(mCacheKey); //如果有必要，直接中断处理...
                }
            } else {
                // check to see if it is already batched for delivery.
                request = mBatchedResponses.get(mCacheKey); //判断请求的响应是否已经被分发...
                if (request != null) {
                    request.removeContainerAndCancelIfNecessary(this);//判断是否有必要移除所有与之相同的请求并中断..
                    if (request.mContainers.size() == 0) { //如果同一种请求已经空了，那么就从批处理请求中移除这个键值..
                        mBatchedResponses.remove(mCacheKey);
                    }
                }
            }
        }
        //获取图片数据...
        public Bitmap getBitmap() {
            return mBitmap;
        }

        //获取url...
        public String getRequestUrl() {
            return mRequestUrl;
        }
    }

    private class BatchedImageRequest {
        /** The request being tracked */
        private final Request<?> mRequest; //请求对象..

        /** The result of the request being tracked by this item */
        private Bitmap mResponseBitmap; //位图对象...

        /** Error if one occurred for this response */
        private VolleyError mError; //错误对象...

        private final LinkedList<ImageContainer> mContainers = new LinkedList<ImageContainer>(); //用于保存相同的键值对应的请求...

        //构造函数...
        public BatchedImageRequest(Request<?> request, ImageContainer container) {
            mRequest = request;
            mContainers.add(container);
        }

        /**
         * Set the error for this response
         */
        public void setError(VolleyError error) {
            mError = error;
        }

        /**
         * Get the error for this response
         */
        public VolleyError getError() {
            return mError;
        }

        //将每一个不同的请求加入队列中
        public void addContainer(ImageContainer container) {
            mContainers.add(container);
        }

        //是否有必要中断请求...
        public boolean removeContainerAndCancelIfNecessary(ImageContainer container) {
            mContainers.remove(container);
            if (mContainers.size() == 0) {
                mRequest.cancel();
                return true;
            }
            return false;
        }
    }

    //批处理响应...
    private void batchResponse(String cacheKey, BatchedImageRequest request) {
        mBatchedResponses.put(cacheKey, request);//放入响应...
        //开启一个线程分发响应的过程...
        if (mRunnable == null) {
            mRunnable = new Runnable() {
                @Override
                public void run() {
                    for (BatchedImageRequest bir : mBatchedResponses.values()) {
                        for (ImageContainer container : bir.mContainers) {
                            // If one of the callers in the batched request canceled the request
                            // after the response was received but before it was delivered,
                            // skip them.
                            if (container.mListener == null) {
                                continue;
                            }
                            if (bir.getError() == null) {
                                container.mBitmap = bir.mResponseBitmap;
                                container.mListener.onResponse(container, false);
                            } else {
                                container.mListener.onErrorResponse(bir.getError());
                            }
                        }
                    }
                    mBatchedResponses.clear();
                    mRunnable = null;
                }

            };
            // Post the runnable.
            mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
        }
    }

    private void throwIfNotOnMainThread() {
        if (Looper.myLooper() != Looper.getMainLooper()) {
            throw new IllegalStateException("ImageLoader must be invoked from the main thread.");
        }
    }
    //获取缓存中的键值..
    private static String getCacheKey(String url, int maxWidth, int maxHeight) {
        return new StringBuilder(url.length() + 12).append("#W").append(maxWidth)
                .append("#H").append(maxHeight).append(url).toString();
    }
}

  这个源码相对就比较多，但是其中的过程并不是非常的难理解...还是看一下实际中是如何使用的...

package com.example.oop;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley;

import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;

public class MainActivity extends Activity implements OnClickListener {

    String url="http://192.168.199.172:8080/JSP/imageview.jpg";
    ImageView iv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView=(ImageView) findViewById(R.id.iv);
        init();
    }

    public void init(){
        RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
        ImageLoader imageLoader=new ImageLoader(queue, new ImageCache() {

            LruCache<String,Bitmap>cache=new LruCache<String, Bitmap>(((int) Runtime.getRuntime().maxMemory())/8){

                @Override
                protected int sizeOf(String key,Bitmap bitmap){
                    return bitmap.getRowBytes()*bitmap.getHeight();
                }
            };

            @Override
            public void putBitmap(String url, Bitmap bitmap) {
                // TODO Auto-generated method stub
                cache.put(url, bitmap);
            }

            @Override
            public Bitmap getBitmap(String url) {
                // TODO Auto-generated method stub
                return cache.get(url);
            }
        });
        //为ImageLoader设置监听...成功则iv显示成功图片，没加载完显示默认图片，加载失败显示失败图片..
        ImageListener imagelistener=imageLoader.getImageListener(iv,default_image,error_image);
        imageloader.get(url,imagelistener);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub

    }

}

imageloader.get(url,imagelistener);获取图片的最终过程...这里get函数首先判断图片是否有缓存，通过url的形式来判断是否存在缓存，缓存内部存在，那么直接从缓存中取出，如果缓存中不存在，那么首先看本次的请求是否在批处理图像请求队列中，如果队列中存在这类请求，那么就直接再次添加相同的请求，就没有必要重新建立一个新的请求了...如果这个请求在批处理队列中并不存在，那么就创建一个新的请求来完成...然后放入RequestQueue中和批处理请求队列中...这样就完成了使用ImageLoader来加载图片数据...

  这里使用了LruCache()最近最久未使用算法设立的缓存机制，如果缓存的容量发生了不足，那么直接清除最近最久未被使用的图片缓存...同时每一个Key对应的请求仅仅被放入请求队列一次，对于相同key值的请求，直接从缓存中取出即可，如果缓存内部没有数据，那么通过判断当前是否有这类的请求...如果有，直接进行赋值，如果没有定义一个新的请求...

3.NetWorkImageLoader.java

  第三种加载图片的方式...它基于ImageLoader，加载图片也是通过ImageLoader来实现的，只是在一些地方有一定的差异...

package com.android.volley.toolbox;

import android.content.Context;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.ViewGroup.LayoutParams;
import android.widget.ImageView;

import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageLoader.ImageContainer;
import com.android.volley.toolbox.ImageLoader.ImageListener;

public class NetworkImageView extends ImageView {
    /** The URL of the network image to load */
    private String mUrl; //图片的url

    /**
     * Resource ID of the image to be used as a placeholder until the network image is loaded.
     */
    private int mDefaultImageId; //默认图片的ID..

    /**
     * Resource ID of the image to be used if the network response fails.
     */
    private int mErrorImageId; //错误显示的图片...

    /** Local copy of the ImageLoader. */
    private ImageLoader mImageLoader;  //图片加载对象...

    /** Current ImageContainer. (either in-flight or finished) */
    private ImageContainer mImageContainer; //ImageContainer对象..

    public NetworkImageView(Context context) {
        this(context, null);
    }

    public NetworkImageView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public NetworkImageView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    //设置图片的url...
    public void setImageUrl(String url, ImageLoader imageLoader) {
        mUrl = url;
        mImageLoader = imageLoader;
        // The URL has potentially changed. See if we need to load it.
        loadImageIfNecessary(false);
    }

    //设置默认图片...
    public void setDefaultImageResId(int defaultImage) {
        mDefaultImageId = defaultImage;
    }

    //设置错误图片...
    public void setErrorImageResId(int errorImage) {
        mErrorImageId = errorImage;
    }

    //这个函数在OnLauout调用时才被调用...用于加载图片...
    private void loadImageIfNecessary(final boolean isInLayoutPass) {
        //获取长度和宽度...
        int width = getWidth();
        int height = getHeight();

        boolean isFullyWrapContent = getLayoutParams() != null
                && getLayoutParams().height == LayoutParams.WRAP_CONTENT
                && getLayoutParams().width == LayoutParams.WRAP_CONTENT;
        //如果view控件的大小界限是不确定的，并且还不是wrap_content属性，那么放弃加载...
        if (width == 0 && height == 0 && !isFullyWrapContent) {
            return;
        }

        // if the URL to be loaded in this view is empty, cancel any old requests and clear the
        // currently loaded image.
        //如果这个url被加载后，view是空的，那么就撤销掉与之相同的所有请求...
        if (TextUtils.isEmpty(mUrl)) {
            if (mImageContainer != null) {
                mImageContainer.cancelRequest();
                mImageContainer = null;
            }
            setImageBitmap(null);
            return;
        }

        // if there was an old request in this view, check if it needs to be canceled.
        //如果请求是相同的url，那么直接return，数据的获取由缓存处理...
        if (mImageContainer != null && mImageContainer.getRequestUrl() != null) {
            if (mImageContainer.getRequestUrl().equals(mUrl)) {
                // if the request is from the same URL, return.
                return;
            } else {
                // if there is a pre-existing request, cancel it if it's fetching a different URL.
                mImageContainer.cancelRequest();
                setImageBitmap(null);
            }
        }

        // The pre-existing content of this view didn't match the current URL. Load the new image
        // from the network.
        //如果不满足上述情况，那么就建立一个新的ImageContainer来保存...
        ImageContainer newContainer = mImageLoader.get(mUrl,
                new ImageListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        if (mErrorImageId != 0) {
                            setImageResource(mErrorImageId);
                        }
                    }

                    @Override
                    public void onResponse(final ImageContainer response, boolean isImmediate) {
                        // If this was an immediate response that was delivered inside of a layout
                        // pass do not set the image immediately as it will trigger a requestLayout
                        // inside of a layout. Instead, defer setting the image by posting back to
                        // the main thread.
                        if (isImmediate && isInLayoutPass) {
                            post(new Runnable() {
                                @Override
                                public void run() {
                                    onResponse(response, false);
                                }
                            });
                            return;
                        }

                        if (response.getBitmap() != null) {
                            setImageBitmap(response.getBitmap());
                        } else if (mDefaultImageId != 0) {
                            setImageResource(mDefaultImageId);
                        }
                    }
                });

        // update the ImageContainer to be the new bitmap container.
        mImageContainer = newContainer;
    }
    //布局函数调用...
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        loadImageIfNecessary(true); //这里才会去调用图片加载函数...
    }

    @Override
    protected void onDetachedFromWindow() {
        if (mImageContainer != null) {
            // If the view was bound to an image request, cancel it and clear
            // out the image from the view.
            mImageContainer.cancelRequest();
            setImageBitmap(null);
            // also clear out the container so we can reload the image if necessary.
            mImageContainer = null;
        }
        super.onDetachedFromWindow();
    }

    @Override
    protected void drawableStateChanged() {
        super.drawableStateChanged();
        invalidate();
    }
}

  这是源码的实现过程，有些细节上的问题就不进行分析了...我们还是来看一下实例...

package com.example.oop;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;
import com.android.volley.toolbox.NetworkImageView;
import com.android.volley.toolbox.Volley;

import android.os.Bundle;
import android.app.Activity;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;

public class MainActivity extends Activity implements OnClickListener {

    String url="http://192.168.199.172:8080/JSP/imageview.jpg";
    NetworkImageView imageView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView=(NetworkImageView) findViewById(R.id.network);
        init();
    }

    public void init(){
        RequestQueue queue=Volley.newRequestQueue(MainActivity.this);
        ImageLoader imageLoader=new ImageLoader(queue, new ImageCache() {

            LruCache<String,Bitmap>cache=new LruCache<String, Bitmap>(((int) Runtime.getRuntime().maxMemory())/8){

                @Override
                protected int sizeOf(String key,Bitmap bitmap){
                    return bitmap.getRowBytes()*bitmap.getHeight();
                }
            };

            @Override
            public void putBitmap(String url, Bitmap bitmap) {
                // TODO Auto-generated method stub
                cache.put(url, bitmap);
            }

            @Override
            public Bitmap getBitmap(String url) {
                // TODO Auto-generated method stub
                return cache.get(url);
            }
        });
        imageView.setDefaultImageResId(R.drawable.default_image); //这里需要手动设置默认图片和错误显示图片...
        imageView.setErrorImageResId(R.drawable.no_image);
                //加载获取图片的过程...
        imageView.setImageUrl(url, imageLoader);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub

    }

}

 需要说的是，布局文件中我们需要这样进行书写去定义一个NetWorkImageView对象...通过获取ID，来进行数据信息的加载...

<com.android.volley.toolbox.NetworkImageView
        android:id="@+id/network"
        android:layout_height="100dip"
        android:layout_width="100dip">
    </com.android.volley.toolbox.NetworkImageView>