面向对象的六大原则之 —— 开闭原则

学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下

什么是开闭原则

一个类、模块、函数等应该对于扩展是开放的，但是对于修改是封闭的，简单说就是当你的系统要升级维护需要对原有的代码进行修改时，可能会将错误引入到了原来的旧代码中，因此，在软件升级维护时，应该尽可能的通过扩展的方式而不是修改原有的代码，虽然在实际开发中，修改原本的代码跟扩展代码都是同时存在的，但是为了程序的可扩展性，在制作初期，应该遵循开闭原则。

以上一篇《面向对象的六大原则之 —— 单一原则》的例子为例继续讲解

在ImageCache类中，使用了内存缓存，可是内存缓存很有限，而且还容易丢失，比如应用关闭后，原来缓存在内存的图片会丢失，再打开需要重新加载，所以我们考虑加入SD卡缓存。

加入DiskCache类，缓存图片到SD卡中

import android.graphics.Bitmap;import android.graphics.BitmapFactory;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/** * Created by Administrator on 2016/3/1. */public class DiskCache {    public static final String cacheDir="sdcard/cache/";    /**     * 获取sd卡的图片缓存     * @param url 图片url     * @return 返回bitmap     */    public Bitmap get(String url){        Bitmap bitmap=null;        bitmap= BitmapFactory.decodeFile(cacheDir+url);        return bitmap;    }    /**     * 缓存到sd卡     * @param url 图片的url     * @param bitmap bitmap对象     */    private void put(String url ,Bitmap bitmap){        FileOutputStream output = null;        try {            output = new FileOutputStream(cacheDir+url);            bitmap.compress(Bitmap.CompressFormat.PNG,100,output);        } catch (FileNotFoundException e) {            e.printStackTrace();        }finally {            //无论是否有异常，都要关闭流            try {                if(output!=null){                    output.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }}

因为加入了sd卡的缓存方式，所以要修改ImageLoader类

import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.widget.ImageView;import java.io.IOException;import java.net.HttpURLConnection;import java.net.MalformedURLException;import java.net.URL;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * Created by Administrator on 2016/3/1. */public class ImageLoader {    public ImageLoader() {    }    //内存缓存类    ImageCache imageCache=new ImageCache();    //sd卡缓存类    DiskCache diskCache=new DiskCache();    //是否使用sd卡缓存    boolean isUseDiskCache=false;    //线程池，线城数量为cpu的数量    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());    /**     * 显示图片     * @param url 图片的url     * @param imageView 要显示的view     */    public void displayImage(final String url, final ImageView imageView) {        Bitmap bitmap=isUseDiskCache()?diskCache.get(url):imageCache.get(url);        if(bitmap!=null){            imageView.setImageBitmap(bitmap);            return;        }        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);                }                imageCache.put(url, bitmap);diskCache.put(url,bitmap);            }        });    }    /**     * 下載圖片     * @param imageUrl 网络图片地址     * @return 返回bitmap对象     */    public Bitmap downloadImage(String imageUrl) {        Bitmap bitmap = null;        try {            URL url = new URL(imageUrl);            HttpURLConnection conn = (HttpURLConnection) url.openConnection();            bitmap = BitmapFactory.decodeStream(conn.getInputStream());            conn.disconnect();        } catch (MalformedURLException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }        return bitmap;    }    public boolean isUseDiskCache() {        return isUseDiskCache;    }    public void setIsUseDiskCache(boolean isUseDiskCache) {        this.isUseDiskCache = isUseDiskCache;    }}

ImageLoader类中加入了少量代码就添加了sd卡缓存的功能，用户还能通过setIsUseDiskCache设置使用哪种缓存，但是以上还有个问题，使用内存缓存的时候，就没有sd卡缓存，用户要两种策略都用，首先缓存优先使用内存缓存， 如果内存没有就查找sd卡缓存，sd卡没有就从网络获取，，这才是最好的缓存策略，依照这种想法，修改代码，加入DoubleCache类，实现双缓存

import android.graphics.Bitmap;/** * Created by Administrator on 2016/3/1. */public class DoubleCache {    //内存缓存    ImageCache mImageCache=new ImageCache();    //sd卡缓存    DiskCache mDiskCache=new DiskCache();    /**     * 获取缓存图片     * @param url 图片url     * @return 返回bitmap对象     */    public Bitmap get(String url){        Bitmap bitmap=null;        bitmap=mImageCache.get(url);        if(bitmap==null){            bitmap=mDiskCache.get(url);        }        return bitmap;    }    /**     * 缓存图片     * @param url 图片url     * @param bitmap      */    public void put(String url,Bitmap bitmap){        mImageCache.put(url,bitmap);        mDiskCache.put(url,bitmap);    }}

ImageLoader类修改如下

import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.widget.ImageView;import java.io.IOException;import java.net.HttpURLConnection;import java.net.MalformedURLException;import java.net.URL;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * Created by Administrator on 2016/3/1. */public class ImageLoader {    public ImageLoader() {    }    //内存缓存类    ImageCache imageCache=new ImageCache();    //sd卡缓存类    DiskCache diskCache=new DiskCache();    //双缓存    DoubleCache doubleCache=new DoubleCache();    //是否使用sd卡缓存    boolean isUseDiskCache=false;    //是否使用双缓存    boolean isUseDoubleCache=false;    //线程池，线城数量为cpu的数量    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());    /**     * 显示图片     * @param url 图片的url     * @param imageView 要显示的view     */    public void displayImage(final String url, final ImageView imageView) {        Bitmap bitmap=null;        if(isUseDoubleCache()){            bitmap=doubleCache.get(url);        }else if(isUseDiskCache()){            bitmap=diskCache.get(url);        }else{            bitmap=imageCache.get(url);        }        if(bitmap!=null){            imageView.setImageBitmap(bitmap);            return;        }        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);                }                //缓存到内存跟sd卡中                doubleCache.put(url, bitmap);            }        });    }    /**     * 下載圖片     * @param imageUrl 网络图片地址     * @return 返回bitmap对象     */    public Bitmap downloadImage(String imageUrl) {        Bitmap bitmap = null;        try {            URL url = new URL(imageUrl);            HttpURLConnection conn = (HttpURLConnection) url.openConnection();            bitmap = BitmapFactory.decodeStream(conn.getInputStream());            conn.disconnect();        } catch (MalformedURLException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }        return bitmap;    }    public boolean isUseDiskCache() {        return isUseDiskCache;    }    public void setIsUseDiskCache(boolean isUseDiskCache) {        this.isUseDiskCache = isUseDiskCache;    }    public boolean isUseDoubleCache() {        return isUseDoubleCache;    }    public void setIsUseDoubleCache(boolean isUseDoubleCache) {        this.isUseDoubleCache = isUseDoubleCache;    }}

经过修改之后，我们的图片加载器已经实现了双缓存的功能了，可是细心的你可能发现了，每次加入新的缓存方法都要修改原来的代码，而且还会让ImageLoader变的越来越复杂，一堆的if{}else{}判断，条件多了就容易造成错误，而且如果现在用户想要自己扩展一个缓存方式，都要动ImageLoader类里面的东西，本文最上面已经说了，开闭原则的目的就是为了让扩展是开发的，修改是封闭的，当软件需要变化时，我们应该尽可能的通过扩展的方式来实现变化，而不要通过修改已有的代码来实现，按照这个思维，我们来想想应该如何修改，首先，我们的ImageLoader的职责就是加载图片跟设置缓存的，而缓存的实现不由它管，我们的目的是让缓存的方式能让用户自己扩展，所以我们定义ImageCache接口，接口中有两个方法，一个是put(String url,Bitmap bitmap)用来添加到缓存，一个是get(String url);用来获取缓存，具体实现不管，而是由实现了这个接口的实现类来具体实现。

ImageCache类如下：

import android.graphics.Bitmap;/** * Created by Administrator on 2016/3/1. */public interface ImageCache {    /**     * 添加缓存     * @param url    缓存的图片url作为缓存的key     * @param bitmap 缓存的bitmap     */    public void put(String url, Bitmap bitmap);    /**     * 获取缓存的图片     * @param url     * @return     */    public Bitmap get(String url);}

我们可以将接口当成是一个标准，比如电脑的usb接口，想要通过usb连接到电脑，就必须要按照usb这个插口的标准走，不然你想插也插不进去，我们的图片加载器也是一样，想要自己扩展一个缓存方式，就要按我的标准来。

所以，上面的内存缓存、sd卡缓存、双缓存三个类，我们全部修改实现ImageCache类

内存缓存类（MemoryCache）

import android.graphics.Bitmap;import android.util.LruCache;/** * Created by Administrator on 2016/3/1. */public class MemoryCache implements ImageCache{    public MemoryCache() {        //初始化图片缓存        initImageCache();    }    //图片缓存类    LruCache<String, Bitmap> memoryCache;    /**     * 初始化缓存     */    private void initImageCache() {        //计算可使用的最大内存        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);        //只用最大内存的四分之一作为缓存大小        int cacheSize = maxMemory / 4;        memoryCache = new LruCache<String, Bitmap>(cacheSize) {            @Override            protected int sizeOf(String key, Bitmap value) {                return value.getRowBytes() * value.getHeight() / 1024;            }        };    }    /**     * 添加缓存     *     * @param url    缓存的图片url作为缓存的key     * @param bitmap 缓存的bitmap     */    public void put(String url, Bitmap bitmap) {        memoryCache.put(url, bitmap);    }    /**     * 获取缓存的图片     *     * @param url     * @return     */    public Bitmap get(String url) {        Bitmap bitmap = null;        bitmap = memoryCache.get(url);        return bitmap;    }}

SD卡缓存类（DiskCache）

import android.graphics.Bitmap;import android.graphics.BitmapFactory;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/** * Created by Administrator on 2016/3/1. */public class DiskCache implements ImageCache{    public static final String cacheDir="sdcard/cache/";    /**     * 获取sd卡的图片缓存     * @param url 图片url     * @return 返回bitmap     */    public Bitmap get(String url){        Bitmap bitmap=null;        bitmap= BitmapFactory.decodeFile(cacheDir+url);        return bitmap;    }    /**     * 缓存到sd卡     * @param url 图片的url     * @param bitmap bitmap对象     */    public void put(String url ,Bitmap bitmap){        FileOutputStream output = null;        try {            output = new FileOutputStream(cacheDir+url);            bitmap.compress(Bitmap.CompressFormat.PNG,100,output);        } catch (FileNotFoundException e) {            e.printStackTrace();        }finally {            //无论是否有异常，都要关闭流            try {                if(output!=null){                    output.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }}

双缓存类（DoubleCache）

import android.graphics.Bitmap;/** * Created by Administrator on 2016/3/1. */public class DoubleCache implements ImageCache{    //内存缓存    MemoryCache mMemoryCache =new MemoryCache();    //sd卡缓存    DiskCache mDiskCache=new DiskCache();    /**     * 获取缓存图片     * @param url 图片url     * @return 返回bitmap对象     */    public Bitmap get(String url){        Bitmap bitmap=null;        bitmap= mMemoryCache.get(url);        if(bitmap==null){            bitmap=mDiskCache.get(url);        }        return bitmap;    }    /**     * 缓存图片     * @param url 图片url     * @param bitmap     */    public void put(String url,Bitmap bitmap){        mMemoryCache.put(url,bitmap);        mDiskCache.put(url,bitmap);    }}

最后我们的ImageLoader类修改如下：

import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.widget.ImageView;import java.io.IOException;import java.net.HttpURLConnection;import java.net.MalformedURLException;import java.net.URL;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * Created by Administrator on 2016/3/1. */public class ImageLoader {    public ImageLoader() {    }    //默认使用内存缓存    ImageCache imageCache=new MemoryCache();    //线程池，线城数量为cpu的数量    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());    /**     * 设置要使用哪种缓存     * @param imageCache 缓存类     */    public void setImageCache(ImageCache imageCache) {        this.imageCache = imageCache;    }    /**     * 显示图片     * @param url 图片的url     * @param imageView 要显示的view     */    public void displayImage(final String url, final ImageView imageView) {        Bitmap bitmap=imageCache.get(url);        if(bitmap!=null){            imageView.setImageBitmap(bitmap);            return;        }        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);                }                //添加到缓存                imageCache.put(url, bitmap);            }        });    }    /**     * 下載圖片     * @param imageUrl 网络图片地址     * @return 返回bitmap对象     */    public Bitmap downloadImage(String imageUrl) {        Bitmap bitmap = null;        try {            URL url = new URL(imageUrl);            HttpURLConnection conn = (HttpURLConnection) url.openConnection();            bitmap = BitmapFactory.decodeStream(conn.getInputStream());            conn.disconnect();        } catch (MalformedURLException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }        return bitmap;    }}

在ImageLoader中，我们去掉了其他的缓存类，只加入了ImageCache接口，而且还开放了一个设置缓存的方法，也就是通常说的依赖注入，经过以上修改之后，用户的使用方式如下：

<span style="white-space:pre"></span>ImageLoader imageLoader=new ImageLoader();        /**         * 内存缓存方式         */        imageLoader.setImageCache(new MemoryCache());        /**         * SD卡缓存方式         */        imageLoader.setImageCache(new DiskCache());        /**         * 双缓存方式         */        imageLoader.setImageCache(new DoubleCache());        /**         * 自定义缓存方式         */        imageLoader.setImageCache(new ImageCache() {            @Override            public void put(String url, Bitmap bitmap) {                //用户自定义的缓存方式            }            @Override            public Bitmap get(String url) {                //从缓存中获取图片                return null;            }        });

通过以上的修改，发现现在的ImageLoader的可扩展性、灵活性变的很高，三种缓存方式各自的具体实现都不一样，但是他们都实现了ImageCache接口，即有了这个标准，而用户想要自定义缓存实现的时候，只需要实现ImageCache接口，将其setImageCache进去即可。

以上就是开闭原则，对于修改是封闭的，对于扩展是开发的，遵循开闭原则的重要手段应该是通过抽象，由于实际开发中，可能会不尽人意，但是我们在设计的时候，应该尽量通过扩展的方式，这里说尽量是因为，可能原本的代码就是有问题的，必须要修改。

上一篇：《面向对象的六大原则之 —— 单一原则》

下一篇：《面向对象的六大原则之 —— 里氏替换原则》