單一職責原則

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. 如果真要實現類的單一職責，我們就必須使用上面的組合模式了，這會引起類間耦合過重、類的數量增加等問題，人爲增加了設計的複雜性。