您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

徹底搞懂 iOS 代理設計模式:用法、原理與記憶體細節

編輯:iOS 開發基礎

本文為投稿文章,作者:劉小壯

幾乎每一個 iOS 工程都離不開代理(Delegate)。它既是物件之間傳遞訊息的通道,也是回傳參數、同步狀態的常用手段。這篇文章會從「怎麼用」一路談到「為什麼能這樣用」,涵蓋使用技巧、底層原理,以及代理在記憶體管理上的各種細節。內容偏長,但都是實打實的乾貨。本人能力有限,若文中有說錯或漏掉的地方,歡迎直接指出,先在此致謝。

iOS 裡有哪些消息傳遞方式

先快速盤點一下 iOS 中常見的幾種溝通方式,後面才好做對比。

  • 通知(Notification):由通知中心負責接收與廣播,屬於典型的一對多消息傳遞。

  • 代理(Delegate):通用的設計模式,iOS 對它的語言層支持非常完善,由協議、代理方、委托方三部分組成。

  • Block:iOS 4.0 引入的回呼機制,可以把回呼邏輯直接寫在 block 區塊裡,讀起來連貫、寫起來整齊。

  • Target-Action:把物件傳給另一個類,在對方那裡把它當成 target 來呼叫方法。從記憶體角度看,與代理相當類似。

  • KVO:本質上是 NSObject 的分類 NSKeyValueObserving,透過監聽屬性來感知數值變化,變化時觸發回呼。

除此之外還有更多回呼手段,這裡只是列出最常見的幾種。

代理的基本用法

代理由三個角色構成:

  • 協議(Protocol):約定代理雙方能做什麼、必須做什麼。

  • 代理方:依照協議,完成委托方交辦的工作。

  • 委托方:依照協議,指定代理去完成哪些功能。

三者的關係可以用下面這張圖來理解:

圖例

Protocol:協議到底是什麼

協議是一份公共的行為定義,內容通常是一串方法清單,也可以宣告屬性。如果協議只服務於單一個類,習慣上就直接寫在該類的標頭檔裡;若多個類共用同一份協議,建議獨立建立一個 Protocol 檔案集中管理。

協議是可以被繼承的。以 UITableView 為例,它繼承自 UIScrollView,因此也把 UIScrollViewDelegate 一併繼承了過來,我們才能用同一套代理方法取得偏移量等狀態。另外要注意:OC 的類不支援多重繼承,但協議可以繼承多個協議。

// 目前協議繼承了三個協議,另外三份協議的方法清單都會被一併繼承
@protocol LoginProtocol <BaseProtocol, UserProtocol, LogProtocol>
- (void)userLoginWithUsername:(NSString *)username password:(NSString *)password;
@end

協議裡有兩個修飾符:@optional 與 @required。不特別標註時,預設就是 @required。它們的作用僅是約束代理方是否必須實作,若 required 方法沒實作,編譯器只會給一個黃色警告,並不具備強制力。

也正因為不具強制力,委托方在呼叫之前一定要先判斷對方是否真的實作了該方法,否則會直接崩潰:

// 先確認代理物件有實作這個方法,否則會崩潰
if ([self.delegate respondsToSelector:@selector(userLoginWithUsername:password:)]) {
    [self.delegate userLoginWithUsername:self.username.text password:self.password.text];
}

用點外賣來理解代理

我在公司寫程式寫得正順,突然口渴想喝一瓶紅茶。於是我拿起手機在外賣 App 上下單,App 再把訂單轉給店家,由店家把紅茶送過來。

這個過程裡,外賣 App 就是我的代理,我是委托方;我付的錢是參數,最後送到的紅茶是處理結果。我不需要知道店家怎麼調度,只要等結果就好。

如果同一時間我還想吃披薩,那就再打開另一個 App 下單——這就是多個代理物件,而我依然是唯一的委托方。

代理

結論很簡單:一個代理可以服務多個委托方,一個委托方也可以同時擁有兩個代理。委托方甚至可以同時為多個代理服務。正因為如此,代理物件在實務上往往是可以重複使用的,後面我會用一個小例子說明控制器代理的複用。

一個最小可用的代理範例

先定義協議檔案,用來存放公共定義:

#import <Foundation/Foundation.h>

@protocol LoginProtocol <NSObject>
@optional
- (void)userLoginWithUsername:(NSString *)username password:(NSString *)password;
@end

接著定義委托方。這裡只做一個很簡單的登入頁,把帳號密碼往外丟,具體登入細節交給代理處理:

#import "LoginProtocol.h"

/**
 *  當前類是委托方。登入之後,把具體細節交給代理物件完成,
 *  委托方本身不需要知道實作內容。
 */
@interface LoginViewController : UIViewController
@property (nonatomic, weak) id delegate;
@end

@implementation LoginViewController

- (void)loginButtonClick:(UIButton *)button {
    // 先判斷代理是否實作,未實作會崩潰
    if ([self.delegate respondsToSelector:@selector(userLoginWithUsername:password:)]) {
        [self.delegate userLoginWithUsername:self.username.text password:self.password.text];
    }
}

@end

最後是代理方,負責真正的登入流程:

// 遵守登入協議
@interface ViewController () <LoginProtocol>
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    LoginViewController *loginVC = [[LoginViewController alloc] init];
    loginVC.delegate = self;
    [self.navigationController pushViewController:loginVC animated:YES];
}

// 代理方實作具體的登入細節
- (void)userLoginWithUsername:(NSString *)username password:(NSString *)password {
    NSLog(@"username : %@, password : %@", username, password);
}

@end

代理的實作原理

在 iOS 裡,代理的本質其實就是「代理物件記憶體位址的傳遞與操作」。我們在委托方設定代理時,做的事只是用一個 id 類型的指標,對代理物件做了一次弱引用。所謂「讓代理執行操作」,實際上是向這個指標所指向的物件發送訊息,而那個物件就是代理物件本身。

代理原理

也就是說,委托方的代理屬性在執行期指的就是代理物件自己;設定代理,等於讓代理物件「在委托方裡呼叫自己的方法」。方法沒實作,自然就崩潰——從 crash 訊息上通常能直接看出是代理方漏掉了協議方法。

而協議只是一套語法層的宣告:它讓編譯器知道委托方那個代理屬性可以送出協議中列出的訊息。方法怎麼實作、有沒有實作,協議方與委托方都不關心,也不需要關心。

代理的記憶體管理

為什麼代理屬性幾乎都用 weak?

我們宣告的指標預設是 __strong,而屬性本質上就是「成員變數 + setter/getter」。強引用會影響一個物件的生命週期,兩兩互相持有就形成循環引用。

強引用

上圖中,代理物件以強引用指標持有它建立的 LoginVC,同時 LoginVC 的 delegate 又強引用代理物件,雙方互咬,最終誰都無法正常釋放。

弱引用

把 delegate 改成弱引用後,代理物件還活著時可以正常協作;一旦代理物件被釋放,委托方也不會因此拿到一個指向已釋放物件的指標而崩潰。

但事情還沒結束——真的就不會崩潰了嗎?下面兩種寫法都聲稱是弱引用,行為卻完全不同:

@property (nonatomic, weak) id delegate;
@property (nonatomic, assign) id delegate;

weak 與 assign 都屬於「非擁有關係」,不會改變被引用物件的引用計數。差別在於:物件被釋放之後,weak 會自動把指標置為 nil,assign 不會。而在 Objective-C 中向 nil 發送訊息是安全的,什麼都不會發生;assign 則會留下野指標,最終報出 unrecognized selector sent to instance。

所以修飾代理屬性,請一律使用 weak,安全得多。

用代理物件替控制器瘦身

專案越做越大,控制器也隨著業務堆疊而不斷膨脹。遇到這種情況,很多人會想到近幾年很紅的 MVVM。但 MVVM 學習曲線不低,新專案可以一步到位,對一個已經很複雜的中大型專案來說,動到整個架構層的成本太高。

日常開發中用得最多的控制項大概就是 UITableView,而某些頁面的 tableView 相關邏輯多到誇張,這正是控制器肥胖的主要來源之一。此時可以考慮把 delegate 與 dataSource 抽出去,交給一個專門的代理物件。

傳統寫法大致如下(圖畫得醜,理解意思即可):

常用寫法

優化之後的控制器結構變成這樣:

代理物件

對比兩張圖不難看出:我們把 UITableView 的 delegate 與 dataSource 整批搬到一個獨立的代理物件類裡,只把「必須由控制器處理」的邏輯回傳給控制器。資料處理、列表展示、簡單的互動都留在代理物件內部;與頁面業務相關的部分則透過 block 拋回控制器。控制器的工作量少了一大截,耦合度也明顯下降。

下面是一個簡單的代理物件實作。標頭檔:

typedef void (^selectCell)(NSIndexPath *indexPath);

/**
 *  代理物件
 *  UITableView 的協議宣告在 .h 中,外部使用時才不會出現黃色警告
 */
@interface TableViewDelegateObj : NSObject <UITableViewDelegate, UITableViewDataSource>

/**
 *  建立代理物件並傳入資料列表
 *  對外傳遞訊息採用 block 方式
 */
+ (instancetype)createTableViewDelegateWithDataList:(NSArray *)dataList
                                        selectBlock:(selectCell)selectBlock;
@end

實作檔:

#import "TableViewDelegateObj.h"

@interface TableViewDelegateObj ()
@property (nonatomic, strong) NSArray *dataList;
@property (nonatomic, copy)   selectCell selectBlock;
@end

@implementation TableViewDelegateObj

+ (instancetype)createTableViewDelegateWithDataList:(NSArray *)dataList
                                        selectBlock:(selectCell)selectBlock {
    return [[[self class] alloc] initTableViewDelegateWithDataList:dataList
                                                       selectBlock:selectBlock];
}

- (instancetype)initTableViewDelegateWithDataList:(NSArray *)dataList
                                      selectBlock:(selectCell)selectBlock {
    self = [super init];
    if (self) {
        self.dataList = dataList;
        self.selectBlock = selectBlock;
    }
    return self;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return self.dataList.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *identifier = @"cell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:identifier];
    if (!cell) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
                                     reuseIdentifier:identifier];
    }
    cell.textLabel.text = self.dataList[indexPath.row];
    return cell;
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    [tableView deselectRowAtIndexPath:indexPath animated:NO];
    // 點擊事件透過 block 拋給外部
    self.selectBlock(indexPath);
}

@end

控制器這邊的呼叫非常輕量,幾行就搞定:

self.tableDelegate = [TableViewDelegateObj createTableViewDelegateWithDataList:self.dataList
                                                                 selectBlock:^(NSIndexPath *indexPath) {
    NSLog(@"點擊了 %ld 行 cell", (long)indexPath.row);
}];
self.tableView.delegate   = self.tableDelegate;
self.tableView.dataSource = self.tableDelegate;

控制器只需要建立一個代理物件,把 UITableView 的 delegate 與 dataSource 都交出去,既解決了控制器肥胖,也完成了與 UITableView 的解耦。上面的程式碼只示範了點擊 cell,其他需求基本上都能在代理物件裡繼續擴充。另外還有一個附加好處:若多個頁面的列表邏輯相同或相似,這個代理物件是可以直接複用的。

非正式協議

在 iOS 2.0 引入 @Protocol 之前,要實作協議的功能只能靠給 NSObject 添加 Category。這種做法相對於後來正式的 @Protocol,被稱為「非正式協議」。

因為本質是 NSObject 的 Category,所有繼承自 NSObject 的子類都自動「獲得」了這份定義。差別在於:正式協議會在編譯期檢查實作情況,非正式協議不會檢查,也沒有 @optional 與 @required 之分。呼叫時同樣必須先判斷方法是否存在:

// 因為是 Category,需要用 self 判斷方法是否實作
if ([self respondsToSelector:@selector(userLoginWithUsername:password:)]) {
    [self userLoginWithUsername:self.username.text password:self.password.text];
}

早期系統 API 大量使用這種手法,例如 CALayerDelegate:

@interface NSObject (CALayerDelegate)
- (void)displayLayer:(CALayer *)layer;
- (void)drawLayer:(CALayer *)layer inContext:(CGContextRef)ctx;
- (void)layoutSublayersOfLayer:(CALayer *)layer;
- (nullable id)actionForLayer:(CALayer *)layer forKey:(NSString *)event;
@end

代理還是 Block,怎麼選

iOS 的回呼方式很多,而代理與 block 的相似度最高,都是直接回呼。哪個更好?其實沒有絕對答案,重點是「什麼場景下用什麼更合適」。以下幾點是我的經驗:

  • 多個訊息傳遞時用 delegate。訊息數量多,delegate 結構更清晰;全部改用 block 會讓程式碼迅速膨脹且難以維護。試想一下 UITableView 那十幾個代理方法都換成 block,畫面大概不太美。

  • 需要多個回呼對象時用 block。一個委托物件的代理屬性只能指向一個代理物件,若希望同時通知多個物件,block 更合適。

代理

上圖中代理 1 設定成功,代理 2、代理 3 被打了叉,因為那兩個操作是錯的。delegate 保存的只是某一個代理物件的位址,反覆賦值等同於覆寫,最後只有一個代理會真正生效。

  • 單例物件盡量不要用 delegate。單例永遠只有一個實例,用 delegate 一定會遇到上述覆寫問題,最終只有一個物件能收到代理方法。

這種場景改用 block 即可。主線程上多個物件共用 block 完全沒問題,下面用一個循環做一次粗暴的壓力測試:

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
queue.maxConcurrentOperationCount = 10;

for (int i = 0; i < 100; i++) {
    [queue addOperationWithBlock:^{
        [[LoginViewController shareInstance] userLoginWithSuccess:^(NSString *username) {
            NSLog(@"TestTableViewController : %d", i);
        }];
    }];
}

這裡建立了一個最大併發數為 10 的佇列,跑 100 次循環,在多執行緒下驗證單例 + block 的組合,結果是可以正常工作的。但仍要提醒:多執行緒環境下因為共用同一個單例,block 內部涉及共享資源的段落要記得加鎖,避免資源爭奪。

  • 代理是可選的,block 不然。不需要回呼時,代理可以不實作;block 則只能傳 nil 進去。這不算大問題,沒有程式碼潔癖的人可以忽略。

[self downloadTaskWithResumeData:resumeData
                   sessionManager:manager
                         savePath:savePath
                    progressBlock:nil
                     successBlock:successBlock
                     failureBlock:failureBlock];
  • 代理更貼近「過程」,block 更貼近「結果」。用 NSXMLParserDelegate 解析 XML 時,解析器會在過程中不斷回呼各階段方法把中間資料往外丟,這種流程式回呼用代理表達最合適;而一次網路請求回來只需要成功/失敗兩條路,用 block 就相當直觀。

  • 效能上 block 略吃虞。block 涉及從堆疊區拷貝到堆區等動作,時間與空間成本都高於代理;代理只是宣告一份方法清單,在遵守協議的類的 protocol list 中掛一個節點,執行期直接發送訊息即可。這篇主題不是 block,就不再展開,有興趣深入的朋友可以參考唐巧介紹 block 的文章。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved