《Android原始碼設計模式解析與實戰》讀書筆記(一)
一、單一職責原則
單一職責原則的英文名稱是Single Responsibility Principle，縮寫是SRP。SRP的定義是：就一個類而言，應該僅有一個引起它變化的原因。
簡單來說，一個類中應該是一組相關性很高的函式、資料的封裝。單一職責的劃分界限並不總是那麼清晰，很多時候都是需要靠個人經驗來界定。
1.1、示例程式碼
下面是一個圖片載入器的專案程式碼。
/**
* 圖片載入類
*/
public class ImageLoader {
//圖片快取
LruCache<String, Bitmap> mImageCache;
//執行緒池，執行緒數量為CPU的數量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
public ImageLoader() {
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;
}
};
}
public 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 (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
複製程式碼將各個功能獨立出來，滿足單一職責原則的程式碼如下。
/**
* 圖片載入類
*/
public class ImageLoader {
//圖片快取
ImageCache mImageCache = new ImageCache();
//執行緒池，執行緒數量為CPU的數量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//載入圖片
public 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 (Exception e) {
e.printStackTrace();
}
return bitmap;
}
}
複製程式碼public class ImageCache {
//圖片LRU快取
LruCache<String,Bitmap> mImageCache;
public ImageCache() {
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;
}
};
}
public void put(String url,Bitmap bitmap){
mImageCache.put(url, bitmap);
}
public Bitmap get(String url){
return mImageCache.get(url);
}
}
複製程式碼將原來的程式碼一拆為二，ImageLoader只負責圖片載入的邏輯，而ImageCache只負責處理圖片快取的邏輯，使得職責更清晰。
二、開閉原則
開閉原則的英文全稱是Open Close Principle，縮寫是OCP，它是Java世界裡最基礎的設計原則，它指導我們如何建立一個穩定的、靈活的系統。
開閉原則的定義是：軟體中的物件（類、模組、函式等）應該對於擴充套件是開放的，但是對於修改是封閉的。
2.1、示例程式碼
上面重構之後的ImageLoader職責單一、結構清晰。通過記憶體快取解決了每次從網路載入圖片的問題，但是Android應用的記憶體有限，且具有易失性，就是當應用重新啟動之後，原來已經載入過的圖片將會丟失，這樣重啟之後就需要重新下載。
public class DiskCache {
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卡快取的功能，使用者可以通過useDiskCache方法來對使用哪種快取進行設定。
快取優先使用記憶體快取，如果記憶體快取沒有圖片再使用SD卡快取，如果SD卡中也沒有圖片最後才從網路上獲取，這才是最好的快取策略。
public interface ImageCache {
public void put(String url,Bitmap bitmap);
public Bitmap get(String url);
}
複製程式碼public class MemoryCache implements ImageCache {
//圖片LRU快取
LruCache<String, Bitmap> mMemeryCache;
public MemoryCache() {
//初始化LRU快取
}
@Override
public void put(String url, Bitmap bitmap) {
mMemeryCache.put(url, bitmap);
}
@Override
public Bitmap get(String url) {
return mMemeryCache.get(url);
}
}
複製程式碼//SD卡快取DiskCache類
public class DiskCache implements ImageCache{
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 {
ImageCache mMemoryCache=new MemoryCache();
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);
}
}
複製程式碼/**
* 圖片載入類
*/
public class ImageLoader {
//記憶體快取
private ImageCache mImageCache = new MemoryCache();
//執行緒池，執行緒數量為CPU的數量
private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
//注入快取實現
public void setImageCache(ImageCache imageCache) {
mImageCache = imageCache;
}
//載入圖片
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);
}
});
}
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;
}
}
複製程式碼三、里氏替換原則
里氏替換原則英文全稱是Liskov Substitution Principle，縮寫是LSP。LSP的第一種定義是：如果對每一個型別為S的物件O1，都有型別為T的物件O2，使得以T定義的所有程式P在所有物件O1都代換成O2時，程式P的行為沒有發生變化，那麼型別S是型別T的子型別。
里氏替換原則第二種定義：所有引用基類的地方必須能透明地使用其子類的物件。
3.1、核心原理
里氏替換原則的核心原理是抽象，抽象又依賴於繼承這個特性，在OOP中，繼承的優缺點都相當明顯。
- 優點：
- 程式碼重用，減少建立類的成本，每個子類都擁有父類的方法和屬性；
- 子類與父類基本相似，但又與父類有所區別；
- 提高程式碼的可擴充套件性。
- 缺點：
- 繼承是侵入性的，只要繼承就必須擁有父類的所有屬性和方法；
- 可能造成子類程式碼冗餘、靈活性降低，因為子類必須擁有父類的屬性和方法。
開閉原則和里氏替換原則通常是生死相依、不離不棄的，通過里氏替換原則來達到對擴充套件開放，對修改關閉的效果。這兩個原則都強調了一個OOP的重要特性——抽象。
四、依賴倒置原則
依賴倒置原則英文全稱是Dependence Inversion Principle，縮寫是DIP。依賴倒置原則指代了一種特定的解耦形式，使得高層次的模組不依賴於低層次的模組的實現細節的目的，依賴模組被顛倒了。
依賴倒置原則有以下幾個關鍵點：
- 高層模組不應該依賴低層模組，兩者都應該依賴其抽象；
- 抽象不應該依賴細節；
- 細節應該依賴抽象。
在Java中，抽象是指介面或抽象類，兩者都不能直接被例項化；細節就是實現類，實現介面或繼承抽象類而產生的類就是細節，可以直接被例項化。
高層模組就是呼叫端，低層模組就是具體實現類。
依賴倒置原則在Java語言中的表現：模組間的依賴通過抽象發生，實現類之間不發生直接的依賴關係，其依賴關係是通過介面或抽象類產生的。
五、介面隔離原則
介面隔離原則英文全稱是Interface Segregation Principles，縮寫是ISP。ISP的定義是：客戶端不應該依賴它不需要的介面。另一種定義是：類間的依賴關係應該建立在最小的介面上。
介面隔離原則的目的是系統解開耦合，從而容易重構、更改和重新部署。
Robert C Martin在21世紀早期將單一職責、開閉原則、里氏替換、介面隔離以及依賴倒置5個原則定義為SOLID原則，作為物件導向程式設計的5個基本原則。
六、迪米特原則
迪米特原則英文全稱為Law of Demeter，縮寫是LOD，也稱為最少知識原則（Least Knowledge Principle）。其定義是：一個物件應該對其他物件有最少的瞭解。
6.1、示例程式碼
以租房為例來說一下迪米特原則的應用。
/**
* 房間
*/
public class Room {
public float area;
public float price;
public Room(float area, float price) {
this.area = area;
this.price = price;
}
@Override
public String toString() {
return "Room{" +
"area=" + area +
", price=" + price +
'}';
}
}
複製程式碼/**
* 中介
*/
public class Mediator {
List<Room> mRooms = new ArrayList<Room>();
public Mediator() {
for (int i = 0; i < 5; i++) {
mRooms.add(new Room(14 + i, (14 + i) * 150));
}
}
public List<Room> getRooms() {
return mRooms;
}
}
複製程式碼/**
* 租戶
*/
public class Tenant {
public float roomArea;
public float roomPrice;
public static final float diffPrice = 100.0001f;
public static final float diffArea = 0.00001f;
public void rentRoom(Mediator mediator) {
List<Room> rooms = mediator.getRooms();
for (Room room :
rooms) {
if (isSuitable(room)) {
System.out.println("租到房間了" + room);
break;
}
}
}
private boolean isSuitable(Room room) {
return Math.abs(room.price - roomPrice) < diffPrice
&& Math.abs(room.area - roomArea) < diffArea;
}
}
複製程式碼從上面的程式碼中可以看到，Tenant不僅依賴了Mediator類，還需要頻繁地與Room類打交道。優化程式碼如下：
/**
* 中介
*/
public class Mediator {
List<Room> mRooms = new ArrayList<Room>();
public Mediator() {
for (int i = 0; i < 5; i++) {
mRooms.add(new Room(14 + i, (14 + i) * 150));
}
}
public List<Room> getRooms() {
return mRooms;
}
public Room rentOut(float area,float price){
for (Room room : mRooms) {
if (isSuitable(area,price,room)) {
return room;
}
}
return null;
}
private boolean isSuitable(float area,float price,Room room) {
return Math.abs(room.price - price) < Tenant.diffPrice
&& Math.abs(room.area - area) < Tenant.diffArea;
}
}
複製程式碼/**
* 租戶
*/
public class Tenant {
public float roomArea;
public float roomPrice;
public static final float diffPrice = 100.0001f;
public static final float diffArea = 0.00001f;
public void rentRoom(Mediator mediator) {
System.out.println("租到房了" + mediator.rentOut(roomArea, roomPrice));
}
}
複製程式碼學海無涯苦作舟
