优化代码第一步---------单一职责（学习笔记）

【一】定义：

         就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。

 

【二】例子：ImageLoader

需求：实现图片的加载并缓存起来

public class ImageLoader {
    //图片缓存
    LruCache mImageCache;
    //线程池，线程池数量为cpu的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().
            availableProcessors());
    public ImageLoader(){
        initImageCache();
    }
    private void initImageCache(){
        //计算可用的最大内存
        final int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);
        //取四分之一内存作为缓存
        final int cacheSize = maxMemory/4;
        mImageCache = new LruCache(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes()*value.getHeight()/1024;
            }
        };
    }

   
    public void displayImage(final String url, final ImageView imageView){
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if(bitmap == null){
                    return ;
                }
                if(imageView.getTag().equals(url)){
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection)url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

上面的代码虽然满足了需求，但是耦合度太严重了！没有设计可言。更不要说扩展性，灵活性了。所有功能都写在一个类里，随着功能的增加,ImageLoader类会越来越大，代码也越来越复杂，图片加载系统就越来越弱。

这就涉及到单一职责了，应该把各个功能独立出来。

图：

 

代码如下：

/**
*缓存类
**/
public class ImageCache {
    //图片缓存
    LruCache mImageCache;
    public ImageCache(){

    }
    private void initImageCache(){
        //计算可用的最大内存
        final int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);
        //取四分之一内存作为缓存
        final int cacheSize = maxMemory/4;
        mImageCache = new LruCache(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes()*value.getHeight()/1024;
            }
        };
    }
    public void put(String url,Bitmap bitmap){
        mImageCache.put(url,bitmap);
    }

    public Bitmap get(String url){
        return mImageCache.get(url);
    }
}



/**
*ImageLoader
**/

public class ImageLoader {
    //图片缓存
    ImageCache mImageCache = new ImageCache();
    //线程池
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().
            availableProcessors());

    public void displayImage(final String url, final ImageView imageView){
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if(bitmap == null){
                    return ;
                }
                if(imageView.getTag().equals(url)){
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }

    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection)url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

这样ImageLoader一拆为二，ImageLoader只负责图片加载的逻辑，而ImageCache只负责处理图片缓存的逻辑,

这样ImageLoader的代码量变少了，职责野清晰了。

从上述的例子中我们能够体会到，单一职责所表达出的用意就是“单一"，如何划分一个类，一个函数的职责，每个人都有自己的看法，这就需要根据个人经验，具体的业务逻辑而定了。