前言

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

定义

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

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

应用

举个栗子

比如这样一个需求，写一个图片加载类，实现图片加载，并且要将图片缓存起来。这个需求通过内存缓存解决了每次从网络加载图片的问题(具体实现请看上篇面向对象六大原则之单一职责原则)，但是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 mImageCache;
    public ImageCache() {
        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 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 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(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原有的代码。这就是所谓的软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。

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

前言

定义

应用

举个栗子

你可能感兴趣的:(面向对象六大原则之开闭原则)