用正反实例说说单一职责原则

2017-10-10 本文已影响0人付凯强

0. 序言

这篇博客从实践栗子出发，通俗易懂的讲解单一职责原则适用的场景，以及单一职责原则所应该把握的"适度".希望阅读完本文可以更好的对代码的可读性、可维护性、复杂度、变革风险有进一步的认识。
博客目录如下：
- 单一职责原则的定义
- 单一职责原则的优缺点
- 用正反栗子讲解如何在接口、类和方法中保持单一职责原则。
- 用正反栗子讲解如何保持单一职责原则的“适度”

1. 定义

就一个类而言，应该仅有一个引起它变化的原因。

2. 优点

类的复杂性降低：实现什么职责都有清晰明确的定义。
可读性提高：复杂性降低，那当然可读性提高了。
可维护性提高：可读性提高，那当然更容易维护。
变革引起的风险降低：变更是必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性和维护性都有非常大的帮助。

3. 缺点

单一职责原则提出了一个编写程序的标准，用“职责”或“变化原因”来衡量接口或者类设计的是否优良，但是“职责”和“变化原因”都是不可度量的，因项目而异，因环境而异，因而有时候饱受争议。

4. 栗子

单一职责原则适用于接口、类和方法。

接口：

反面教材：

public interface IUserInfo {

    void setUserID(String userID);
    String getUserID();
    void setPassword(String password);
    String getPassword();
    void setUserName(String userName);
    String getUserName();
    
    boolean changePassword(String oldPassword);
    boolean deleteUser();
    void mapUser();
    boolean addOrg(int orgID);
    boolean addRole(int roleID);
    
}

问题所在：用户的属性和用户的行为没有分开。

正面栗子：

//BO(Business Object) 业务对象
public interface IUserBO {
    void setUserID(String userID);
    String getUserID();
    void setPassword(String password);
    String getPassword();
    void setUserName(String userName);
    String getUserName();
}

//Biz(Business Logic) 业务逻辑
public interface IUserBiz {
    boolean changePassword(String oldPassword);
    boolean deleteUser();
    void mapUser();
    boolean addOrg(int orgID);
    boolean addRole(int roleID);
}

修正：两个接口有各自不同的实现类，职责单一，分工明确。

类：

反面教材：

public class ImageLoader {
    //图片缓存
    LruCache<String, Bitmap> mImageCache;
    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public ImageLoader() {
        initImageCache();
    }

    private void initImageCache() {
        //计算可使用的最大内存
        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 bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
            }
        };
    }

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

    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 (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

问题：创建线程池、创建LruCache、下载图片、设置图片都放在了一个类，耦合性太强，触一发动全身。

正面栗子：

/**
 * Created by FuKaiqiang on 2017-10-10.
 * 图片缓存类
 */

public class ImageCache {
    //图片Lru缓存
    LruCache<String, Bitmap> mImageCache;

    public ImageCache() {
        initImageCache();
    }

    private void initImageCache() {
        //计算可使用的最大内存
        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 bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
            }
        };
    }

    public void put(String url, Bitmap bitmap) {
        mImageCache.put(url, bitmap);
    }

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

/**
 * Created by FuKaiqiang on 2017-10-10.
 * 图片加载类
 */

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

    //加载图片
    private void displayImage(final String url, final ImageView imageView) {
        Bitmap 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 (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

修正：
① ImageLoader负责图片加载，ImageCache负责图片缓存，ImageLoader代码量变少，职责清晰。
② 当缓存相关的逻辑变动时，不需要修改ImageLoader类，当图片加载相关的逻辑变动时，不需要修改缓存处理逻辑。

方法

反面教材：

public interface IUserManager {
    void changeUser(String newUserName, String newHomeAddress, String telNumber);
}

问题：方法职责不清晰，不单一。

正面栗子：

public interface IUserManager {
    void changeUserName(String newsUserName);

    void changeHomeAddress(String newHomeAddress);

    void changeOfficeTel(String telNumber);
}

修正：职责单一，分工明确，你我他都好。

5. 进阶

我们首先看一个接口和它的实现类：

public interface IPhone {
    //拨通电话
    public void dial(String phoneNumber);

    //通话
    public void chat(Object o);

    //通话完毕，挂电话
    public void hangup();
}

问题：它包含两个职责：一个是协议管理，一个是数据传输。

public class Phone implements IPhone {
    @Override
    public void dial(String phoneNumber) {
        
    }

    @Override
    public void chat(Object o) {

    }

    @Override
    public void hangup() {

    }
}

我们对之进行改进：

public interface IConnectionManager {
    //拨通电话
    public void dial(String phoneNumber);
    //通话完毕，挂电话
    public void hangup();
}

public interface IDataTransfer {
    //通话
    public void chat(Object o);
}

public class ConnectionManager implements IConnectionManager {
    @Override
    public void dial(String phoneNumber) {
        
    }

    @Override
    public void hangup() {

    }
}

public class DataTransfer implements IDataTransfer {
    @Override
    public void chat(Object o) {
        
    }
}

改进：
① 两个接口两个实现类----导致了Phone类要把两个实现类组合在一起才可以使用。
② 然而组成是一种强耦合关系，有共同的生命周期，这样的耦合关系还不如使用接口实现的方式，而且还正价了类的复杂性，多了两个类。

最终改进如下：

public interface IConnectionManager {
    //拨通电话
    public void dial(String phoneNumber);
    //通话完毕，挂电话
    public void hangup();
}

public interface IDataTransfer {
    //通话
    public void chat(Object o);
}

public class Phone implements IConnectionManager, IDataTransfer {
    @Override
    public void dial(String phoneNumber) {

    }

    @Override
    public void chat(Object o) {

    }

    @Override
    public void hangup() {

    }
}

进一步改进：

这样的设计才是完美的，一个类实现了两个接口，把两个职责融合在一个类中。
你肯定会问这个Phone有两个原因引起变化了呀，是的，但是别忘记了我们是面向接口编程，我们对外公布的是接口而不是实现类。
如果真要实现类的单一职责，我们就必须使用上面的组合模式了，这会引起类间耦合过重、类的数量增加等问题，人为增加了设计的复杂性。

6. 后续

如果大家喜欢这篇文章，麻烦点赞。
如果想看更多设计模式方面的技术，欢迎关注！