单一职责原则

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

正解:
1. ImageLoader负责图片加载,ImageCache负责图片缓存,ImageLoader代码量变少,职责清晰。
2. 当缓存相关的逻辑变动时,不需要修改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) {

    }
}

问题:
1. 两个接口两个实现类----导致了Phone类要把两个实现类组合在一起才可以使用。
2. 然而组成是一种强耦合关系,有共同的生命周期,这样的耦合关系还不如使用接口实现的方式,而且还正价了类的复杂性,多了两个类。
  • 最终改进如下:
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() {

    }
}

正解:
1. 这样的设计才是完美的,一个类实现了两个接口,把两个职责融合在一个类中。
2. 你肯定会问这个Phone有两个原因引起变化了呀,是的,但是别忘记了我们是面向接口编程,我们对外公布的是接口而不是实现类。
3. 如果真要实现类的单一职责,我们就必须使用上面的组合模式了,这会引起类间耦合过重、类的数量增加等问题,人为增加了设计的复杂性。
    原文作者:ab_dg_dp
    原文地址: https://blog.csdn.net/fkq_2016/article/details/78191774
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞