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

前言

我们在开发中经常会遇到需求修改的情况，因为老板的思想永远是跳跃的，所以开发的时候也要尽量多多考虑程序的扩展性，我们尽量把一些改变控制到我们可预见的范围内，这在后续的开发中会减少很多不必要的麻烦，那就要求我们在设计功能代码的时候遵守开闭原则，这个原则在勃兰特.梅耶的《面向对象软件构造》一书中首次提出，他认为：程序一旦开发完成，程序中一个类的实现只应该因为错误而被修改，新的需求或功能改变应该通过新建不同的类来实现，新建的类应该通过继承的方式重写原来的代码，也就是说我们已存在的实现类对于修改是封闭的，新的实现类可以通过覆盖父类的接口应对变化。

定义

开闭原则：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。

在开发软件的过程中，因为变化、升级和维护等原因需要对软件原有的代码进行修改，可能会将错误引入原本已经测试过的旧代码中，破坏原有的系统，因此，当软件需求变化时，我们应尽量运用扩展的方式来实现变化，而不是修改原来的代码。

应用

举个栗子

比如这样一个需求，写一个图片加载类，实现图片加载，并且要将图片缓存起来。这个需求通过内存缓存解决了每次从网络加载图片的问题(具体实现请看上篇面向对象六大原则之单一职责原则)，但是android应用的内存是有限的，且有易失性，即当应用重新启动后内存缓中的将会丢失，这样又需要重新下载，那我们考虑引入sd卡缓存，代码入下：

/**
 * 图片加载类
 */
public class ImageLoader{
    //内存缓存
    ImageCache mImageCache = new ImageCache();
    //SD 卡缓存
    DiskCache mDiskCache = new DiskCache();
    //是否使用SD卡缓存
    boolean isUseDiskCache = false;

    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());

    public void setUseDiskCache(boolean useDiskCache) {
        isUseDiskCache = useDiskCache;
    }

    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap = isUseDiskCache? mDiskCache.get(url) : mImageCache.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);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }
    private 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;
    }

}

/**
 * 图片缓存类
 */
public class ImageCache {
    //图片LRU缓存
    LruCache<String,Bitmap> mImageCache;
    public ImageCache() {
        initImageCache();
    }

    private void initImageCache() {
        //计算可使用的最大内存
        final int maxMemory = (int)(Runtime.getRuntime().maxMemory() / 1024);
        //取四分之一的可用内存作为缓存
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String,Bitmap>(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);
    }
}
/**
 * SD卡缓存类
 */

public class DiskCache {
    private static String cacheDir = "sdcard/cache/";
    //从缓存中获取图片
    public Bitmap get (String url) {
        return BitmapFactory.decodeFile(cacheDir+url);
    }
    //将图片缓存到内存中
    public void put(String url,Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(cacheDir + url);
            bmp.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

如上述代码可以看出，仅仅新增了一个DiskCache类和往ImageLoader中加入了少量的代码就添加了SD卡缓存功能

ImageLoader imageLoader = new ImageLoader();
imageLoader.setUseDiskCache(true);

通过setUseDiskCache来设置

那如果想两种缓存策略同时用呢?

代码入下：

/**
 * 图片加载类
 */

public class ImageLoader4 {

    //内存缓存
    ImageCache mImageCache = new ImageCache();
    //SD 卡缓存
    DiskCache mDiskCache = new DiskCache();
    //双缓存
    DoubleCache mDoubleCache = new DoubleCache();

    //是否使用SD卡缓存
    boolean isUseDiskCache = false;
    //是否使用双缓存
    boolean isUseDoubleCache = false;

    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());

    public void setUseDiskCache(boolean useDiskCache) {
        isUseDiskCache = useDiskCache;
    }

    public void setUseDoubleCache(boolean useDoubleCache) {
        isUseDoubleCache = useDoubleCache;
    }

    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap = null;
        if (isUseDoubleCache) {
            bitmap = mDoubleCache.get(url);
        } else if (isUseDiskCache) {
            bitmap = mDiskCache.get(url);
        } else {
            bitmap = mImageCache.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);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }
    private 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;
    }
}
/**
 * 双缓存类，处理缓存切换的逻辑
 */
public class DoubleCache {
    ImageCache mMemoryCache = new ImageCache();
    DiskCache mDiskCache = new DiskCache();

    //先从内存中获取图片，如果没有，再从SD中获取
    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }
    //将图片缓存到内存和SD卡中
    public void put(String url,Bitmap bmp) {
        mMemoryCache.put(url,bmp);
        mDiskCache.put(url,bmp);
    }
}

上述代码增加几行代码修改几个地方就可以完成需求了，但这样修改每次都修改原有的代码，很可能会引入新的bug，而且会让原来的代码越来越复杂，可扩展性很差。

根据开闭原则软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。因此，当软件需求变化时，我们应尽量运用扩展的方式来实现变化，而不是修改原来的代码。

那么我们是否可以把内存缓存和sd卡缓存抽取出一个接口，在ImageLoader中通过接口来接收处理缓存，以后有其它新的缓存需求可以通过实现接口来扩展，UML类图入下

按照类图代码如下：

/**
 * 图片加载类
 */
public class ImageLoader{

    //默认内存缓存
    ImageCache mImageCache = new MemoryCache();

    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors());
    //注入实现缓存
    public void setmImageCache(ImageCache mImageCache) {
        this.mImageCache = mImageCache;
    }

    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap = null;
        bitmap = mImageCache.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);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }
    private 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;
    }
}

/**
 * 缓存类的接口
 */
public interface ImageCache {
    Bitmap get(String url);
    void put(String url,Bitmap bmp);
}

/**
 * 内存缓存
 */
public class MemoryCache implements ImageCache{
    private LruCache<String,Bitmap> mMemoryCache;

    public MemoryCache() {
        initImageCache();
    }

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

/**
 * SD卡缓存
 */
public class DiskCache implements ImageCache {
    private static String cacheDir = "sdcard/cache/";
    @Override
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(cacheDir+url);
    }

    @Override
    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(cacheDir + url);
            bmp.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * 双缓存类
 */
public class DoubleCache implements ImageCache{
    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();
    //先从内存中获取图片，如果没有，再从SD中获取
    @Override
    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }
    //将图片缓存到内存和SD卡中
    @Override
    public void put(String url, Bitmap bmp) {
        mMemoryCache.put(url,bmp);
        mDiskCache.put(url,bmp);
    }
}

ImageLoader中增加了setmImageCache方法，可以通过此方法设置缓存的实现，就是依赖注入。
如下代码可以调用：

ImageLoader imageLoader  = new ImageLoader();
//使用双缓存
imageLoader.setmImageCache(new DoubleCache());
//使用内存缓存
imageLoader.setmImageCache(new MemoryCache());
//使用sd缓存
imageLoader.setmImageCache(new DiskCache());
//自定义缓存的实现
imageLoader.setmImageCache(new ImageCache(){
    @Override
    public Bitmap get(String url) {
        //...
        return bitmap;
    }

    @Override
    public void put(String url, Bitmap bmp) {
        //..
    }

});

经过这次重构，ImageLoader类中没有那么多内存缓存和sd卡缓存的切换逻辑和控制流程，只有加载图片的显示功能，缓存调度功能完全交给ImaeCache接口的实现类处理，这是一个典型的遵守开闭原则的案例。这样可以使ImageLoader类更简单，也更灵活。MemoryCache，DiskCache，DoubleCache类的具体实现都各不相同，如果有新的需求可以通过ImageCache接口来实现，不用修改ImageLoader原有的代码。这就是所谓的软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。

最后编辑于：2017.12.08 05:01:44

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 159,015评论 4赞 362
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 67,262评论 1赞 292
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 108,727评论 0赞 243
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 43,986评论 0赞 205
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,363评论 3赞 287
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,610评论 1赞 219
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,871评论 2赞 312
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,582评论 0赞 198
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,297评论 1赞 242
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,551评论 2赞 246
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,053评论 1赞 260
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,385评论 2赞 253
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,035评论 3赞 236
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,079评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,841评论 0赞 195
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,648评论 2赞 274
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,550评论 2赞 270

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

前言

定义

应用

举个栗子

推荐阅读更多精彩内容