面向对象的原则之开闭原则

作者: 刘涤生 | 来源:发表于2016-03-17 22:47 被阅读322次

开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。

勃兰特-梅耶在1988年出版的《面向对象软件构造》一书中提出这一原则---开闭原则。这一想法认为，程序一旦开发完成，程序中一个类的实现只应该因错误而被修改，新的或者改变的特性应该通过新建不同的类实现，新建的类可以通过继承的方式来重用原类的代码。显然梅耶的定义提倡实现继承，已存在的实现类对于修改时封闭的，但是新的类可以通过覆写父类的接口应对变化。

引入其他缓存方式

说了这么多，下面还是以一个简单示例来说明开闭原则：

在对ImageLoader进行了一次重构之后的ImageLoader职责单一、结构清晰，算是个不错的开始。随着用户的增多，有些问题开始暴露出来：缓存系统是最让大家吐槽的地方，通过内存缓存解决了每次从网络加载图片的问题，但是，Android应用的内存很有限，且具有易失性，即当应用重新启动之后，原来已经加载过的图片将会丢失，这样重启之后及需要重新下载图片！而这又会导致加载缓慢、耗费用户流量的问题。针对以上问题考虑引入SD卡缓存，这样下载过的图片就会缓存到本地，即使重启应用也不需要重新下载了，接下来开始实现SD卡缓存。

DiskCache.java类，将图片缓存到SD卡中：

package com.deason.library.ocp;

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

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * SD卡图片缓存
 * Created by liuguoquan on 2016/3/17.
 */
public class DiskCache {

    public static final String CACHE_DIR = "/sdcard/cache/";

    /**
     * 从缓存中获取图片
     * @param url
     * @return
     */
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(CACHE_DIR + url);
    }

    /**
     * 将图片存入SD卡中
     * @param url
     * @param bitmap
     */
    public void put(String url,Bitmap bitmap) {

        FileOutputStream out = null;
        try {
            out = new FileOutputStream(CACHE_DIR + url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MemoryCache类，把图片缓存到内存中

package com.deason.library.ocp;

import android.graphics.Bitmap;
import android.util.LruCache;

/**
 * 处理图片缓存
 * Created by liuguoquan on 2016/3/14.
 */
public class MemoryCache {

    /**
     * 图片缓存
     */
    LruCache<String, Bitmap> mImageCache;
    public MemoryCache() {
        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;
            }
        };
    }

    /**
     * 将图片存入缓存
     * @param key
     * @param bitmap
     */
    public void put(String key,Bitmap bitmap) {
        mImageCache.put(key,bitmap);
    }

    /**
     * 取出缓存图片
     * @param key
     * @return
     */
    public Bitmap get(String key) {
        return mImageCache.get(key);
    }
}

因为需要将图片缓存到SD卡中，所有ImageLoader代码有所更新，具体代码如下：

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

    /**
     * 图片缓存
     */
    MemoryCache mMemoryCache = new MemoryCache();

    /**
     * SD卡缓存
     */
    DiskCache mDiskCache = new DiskCache();

    /**
     * 是否使用SD卡缓存
     */
    private boolean isUseDiskCache = false;

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        //判断使用哪种缓存
        Bitmap bitmap =  isUseDiskCache ? mDiskCache.get(url) :  mMemoryCache.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);
                }
                //将下载的图片存入内存
                mMemoryCache.put(url,bitmap);
                mDiskCache.put(url,bitmap);
            }
        });
    }

    /**
     * 设置是否用SD卡缓存
     * @param isUseDiskCache
     */
    public void useDiskCache(boolean isUseDiskCache) {
        this.isUseDiskCache = isUseDiskCache;
    }

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

从上述的代码中可以看到，仅仅新增了一个DiskCache类和往ImageLoader类中加入了少量代码就添加了SD卡缓存的功能，用户可以通过useDiskCache方法来对使用哪种缓存进行设置，例如

ImageLoader mImageLoader = new ImageLoader();
//使用SD卡缓存
mImageLoader.useDiskCache(true);
//使用内存缓存
mImageLoader.useDisCache(false);

通过useDiskCache方法来让用户设置不同的缓存这个思路是对的，但是会有些明显的问题，就是使用内存缓存时用户不能使用SD卡缓存。类似地，使用SD卡缓存时用户就不能使用内存缓存。

实际上，用户需要这两种缓存的综合，首先缓存优先使用内存缓存，如果内存缓存没有图片再使用SD卡缓存，如果SD卡中也没有图片最后才从网络上获取，这才是最好的缓存策略。

接下来，我们继续重构，新建一个双缓冲类DoubleCache，具体代码如下：

package com.deason.library.ocp;


import android.graphics.Bitmap;

/**
 * 双缓冲。获取图片时先从内存中获取，如果内存中没有缓存该图片，再从SD卡中获取
 * Created by liuguoquan on 2016/3/17.
 */
public class DoubleCache {

    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();

    /**
     * 先从内存获取图片，没有再从SD卡获取
     * @param url
     * @return
     */
    public Bitmap get(String url) {

        Bitmap bitmap = mMemoryCache.get(url);

        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }

        return bitmap;
    }

    /**
     * 将图片缓存到内存和SD卡中
     * @param url
     * @param bitmap
     */
    public void put(String url, Bitmap bitmap) {
        mMemoryCache.put(url, bitmap);
        mDiskCache.put(url, bitmap);
    }
}

我们再来看看最新的ImageLoader类，代码更新也不多：

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

    /**
     * 图片缓存
     */
    MemoryCache mMemoryCache = new MemoryCache();

    /**
     * SD卡缓存
     */
    DiskCache mDiskCache = new DiskCache();
    //双缓存
    DoubleCache mDoubleCache = new DoubleCache();

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

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    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 = mMemoryCache.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);
                }
                //将下载的图片存入内存
                mMemoryCache.put(url,bitmap);
                mDiskCache.put(url,bitmap);
            }
        });
    }

    /**
     * 设置是否用SD卡缓存
     * @param isUseDiskCache
     */
    public void useDiskCache(boolean isUseDiskCache) {

        this.isUseDiskCache = isUseDiskCache;
    }

    /**
     * 设置是否使用双缓存
     * @param isUseDoubleCache
     */
    public void useDoubleCache(boolean isUseDoubleCache) {

        this.isUseDoubleCache = isUseDoubleCache;
    }

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

此时程序越来越灵活了，通过增加短短几行代码就能够完成如此重要的功能。

人们总会把美好的事情讲在前面，最后给你来个“但是”，我们先来分析一下上面的程序：每次在程序中加入新的缓存实现都需要修改ImageLoader类，然后通过一个布尔类型的变量来让用户选择使用哪种缓存，因此，就使得ImageLoader中存在各种if-else判断语句，通过这些判断语句来确定使用哪种缓存。随着大量逻辑的引用，代码变得越来越复杂脆弱，如果一不小心写错某个if条件，势必会花费大量的时间去调试程序，整个ImageLoader类也会显得臃肿。最重要的是，用户不能自己实现缓存注入到ImageLoader类中，可扩展性较差，而可扩展性是框架的最重要的特性之一。

注入方式设置缓存方式

“软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改则是封闭的，这就是开放-关闭原则。也就是说，我们应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现”。现在，我们来实现终极解决方案，遵循开闭原则。

首先，我们先画出UML图，如下

开闭原则.png

然后，实现UML图上的类和接口，先重构ImageLoader类：

/**
 * Created by liuguoquan on 2016/3/17.
 */
public interface ImageCache {

    /**
     * 获取图片
     * @param url
     * @return
     */
    public Bitmap get(String url);

    /**
     * 缓存图片
     * @param url
     * @param bitmap
     */
    public void put(String url, Bitmap bitmap);
}

经过重构后，少了if-else语句，没有了各种各样的缓存实现对象、布尔变量，代码确实清晰、简单了很多。需要注意的是，这次重构的ImageCache把它提取成一个图片缓存的接口，用来抽象图片缓存的功能，我们来看看该接口的声明：

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

    /**
     * 图片缓存
     */
    ImageCache mImageCache = new MemoryCache();

    /**
     * 注入缓存实现
     * @param cache
     */
    public void setIamgeCache(ImageCache cache) {
        mImageCache = cache;
    }

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap =  mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return ;
        }

        //没有缓存则提交线程池下载
        submitLoadRequest(url, imageView);

    }

    private void submitLoadRequest(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);
            }
        });
    }

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

ImageCache接口简单定义了获取、缓存图片两个方法，缓存的可以是图片的url,值是图片的本身。内存缓存、SD卡缓存、爽缓存都实现该接口，我们看看几个缓存的实现：

MemoryCache.java

public class MemoryCache implements ImageCache {

    /**
     * 图片缓存
     */
    LruCache<String, Bitmap> mMemoryCache;
    public MemoryCache() {
        initImageCache();
    }

    /**
     * 初始化LRU缓存
     */
    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;
            }
        };
    }
    @Override
    public Bitmap get(String url) {
        return mMemoryCache.get(url);
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        mMemoryCache.put(url, bitmap);
    }
}

DiskCache.java

/**
 * Created by liuguoquan on 2016/3/17.
 */
public class DiskCache implements  ImageCache {

    public static final String CACHE_DIR = "/sdcard/cache/";
    @Override
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(CACHE_DIR + url);
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        FileOutputStream out = null;

        try {
            out = new FileOutputStream(CACHE_DIR + url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,out);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Double.java

/**
 * Created by liuguoquan on 2016/3/17.
 */
public class DoubleCache implements ImageCache {

    ImageCache mMemoryCache = new MemoryCache();
    ImageCache mDiskCache = new DiskCache();

    @Override
    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);

        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }

        return bitmap;
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        mMemoryCache.put(url, bitmap);
        mDiskCache.put(url, bitmap);
    }
}

上述重构后的ImageLoader类中增加了一个setImageCache(ImageCache cache)方法，用户可以通过该函数设置缓存实现，也就是通常所说的依赖注入。

下面看看用户如何通过使用ImageLoader来设置缓存实现的：

ImageLoader mImageLoader = new ImageLoader();

//使用内存缓存
mImageLoader.setIamgeCache(new MemoryCache());

//使用SD卡缓存
mImageLoader.setIamgeCache(new DiskCache());

//使用双缓存
mImageLoader.setIamgeCache(new DoubleCache());

//使用自定义的图片缓存实现
mImageLoader.setIamgeCache(new ImageCache() {
    @Override
    public Bitmap get(String url) {
        return null;
    }

    @Override
    public void put(String url, Bitmap bitmap) {

    }
});

在上述代码中，通过setImageCache(ImageCache cache)方法注入不同的缓存实现，这样不仅能够使ImageLoader更简单、健壮，也使得ImageLoader可课扩展性、灵活性更高。

MemeryCache、DiskCache、DoubleCache缓存图片的具体实现完全不一样，但是，它们有一个特点是，都实现了ImageCache接口。当用户需要自定义缓存实现时，只需要新建一个实现ImageCache接口的类，然后构造该类的对象，并且通过setImageCache(ImageCache cache)注入到ImageLoader中就可以了，这样ImageLoader就实现了千变万化的缓存策略，且扩展这些缓存策略并不会导致ImageLoader类的修改。经过这次重构，ImageLoader在设计模式上基本已经合格了。

开闭原则指导我们，当软件需要变化时，应该尽量通过扩展的方式来实现变化，而不是通过修改已有的代码来实现。这里的“应该尽量”4个字说明OCP原则并不是说绝对不可以修改原始类的。当确定原来的代码已经“腐化”时，应该尽早的重构，以便让代码恢复带正常的状态，而不是通过继承等方式添加新的代码。因此，在开发过程中需要自己结合具体情况进行考量，是通过修改旧代码还是通过继承使得软件系统更稳当、更灵活，在保证去除“腐化代码”的同时，也保证原有模块的正确性。

优点

增加稳定性
可扩展性提高

面向对象的原则之开闭原则

引入其他缓存方式

注入方式设置缓存方式

优点

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读