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

依賴注入:給你的代碼打一針強心劑

編輯:iOS 開發基礎

本文由 CocoaChina 譯者 @祈祈祈祈祈祈 翻譯自 Square 的技術博客。

原文:Dependency Injection: Give Your iOS Code a Shot in the Arm


什麼是依賴注入(Dependency Injection)?

在許多程序設計語言裡,比如 Java、C#,依賴注入(DI)都是一種頗為流行的設計模式,但它在 Objective-C 中並未得到廣泛應用。本文旨在用 Objective-C 的例子對依賴注入做簡要介紹,同時介紹在 Objective-C 代碼中使用依賴注入的實用方法。儘管文章主要針對 Objective-C,但提到的所有概念對 Swift 同樣適用。

依賴注入的概念十分簡單:一個對象應該通過依賴傳遞獲得,而不是自己創建它們。推薦閱讀 Martin Fowler 關於這個主題的精彩討論作為背景材料。

依賴可以通過 initializer(初始化器/構造器)或屬性(set 方法)傳遞給對象,它們通常被稱為「constructor injection」(構造器注入)和「setter injection」(set 方法注入)。

Constructor Injection:

- (instancetype)initWithDependency1:(Dependency1 *)d1                  dependency2:(Dependency2 *)d2;

Setter Injection:

@property (nonatomic, retain) Dependency1 *dependency1; @property (nonatomic, retain) Dependency2 *dependency2;

根據 Fowler 的描述,一般情況下首選構造器注入,只有在構造器注入不適用的情況下才選擇 setter 注入。雖然使用構造器注入時很可能仍要為這些依賴定義屬性,但你可以把屬性設為 read only,從而簡化對象的 API。

為什麼要使用依賴注入?

使用依賴注入有諸多優點:

1. 依賴聲明清晰。一個對象需要進行的操作一目了然,同時容易消除危險的隱藏依賴,比如全局變量。

2. 組件化。依賴注入提倡「組合優於繼承」,以提高代碼的重用性。

3. 更易定制。創建對象時,在特殊情況下更易對對象進行部分定制。

4. 明確從屬關係。特別是在使用構造器依賴注入時,對象所有權規則被嚴格執行——可以建立一個直接、無環的對象圖。

5. 易測試性。依賴注入比其他方法更能提高對象的易測試性。因為通過構造器創建對象很簡單,也無需管理隱藏的依賴;此外,模擬依賴也變得簡單,從而能把測試集中在被測試的對象上。

在代碼中使用依賴注入

你的代碼庫可能還沒採用依賴注入模式,但轉換起來很簡單。依賴注入的一大好處是:你不需要讓整個工程的代碼全部改用該模式,相反,你可以在代碼庫的特定區域運用,再從那裡逐步擴展開來。

各種類型的注入

首先,把類分為兩種:基本類型和復雜類型。基本類型沒有依賴,或只依賴其他基本類型。基本類型基本不用被繼承,因為它們功能清晰、不易變動,也不需要鏈接外部資源。許多基本類型都來自 Cocoa 自身,比如 NSString、NSArray、NSDictionary 和 NSNumber。

復雜類型則相反,它們有復雜的依賴,包括應用級別的邏輯(需要修改的部分),或訪問額外資源,例如磁盤、網絡或全局內存服務。應用中絕大多數類都是復雜的,包括幾乎所有的控制器對象和模型對象。很多 Cocoa 類型也很復雜,例如 NSURLConnection 或 UIViewController。

基於以上分類,使用依賴注入模式最簡單的方法是:先選擇應用中一個復雜的類,找到類中初始化其他復雜對象的地方(找 "alloc] init" 或 "new" 關鍵字),然後引入依賴注入,把原本由類自己實例化的對象,改為作為初始化參數在類中傳入。

在初始化時分配依賴

讓我們看一個例子:子對象(依賴)在母體的初始化函數中被初始化。原始代碼如下:

@interface RCRaceCar () @property (nonatomic, readonly) RCEngine *engine; @end @implementation RCRaceCar - (instancetype)init {    ...    // Create the engine. Note that it cannot be customized or    // mocked out without modifying the internals of RCRaceCar.    _engine = [[RCEngine alloc] init];        return self; } @end

採用依賴注入後,只需做很小的改動:

@interface RCRaceCar () @property (nonatomic, readonly) RCEngine *engine; @end @implementation RCRaceCar // The engine is created before the race car and passed in // as a parameter, and the caller can customize it if desired. - (instancetype)initWithEngine:(RCEngine *)engine {    ...        _engine = engine;        return self; } @end

惰性初始化依賴

有些對象可能一段時間後才用到,或者初始化之後才用到,甚至永遠不會用到。下面是未使用依賴注入前的例子:

@interface RCRaceCar () @property (nonatomic) RCEngine *engine; @end @implementation RCRaceCar - (instancetype)initWithEngine:(RCEngine *)engine {    ...        _engine = engine;    return self; } - (void)recoverFromCrash {    if (self.fire != nil) {       RCFireExtinguisher *fireExtinguisher = [[RCFireExtinguisher alloc] init];       [fireExtinguisher extinguishFire:self.fire];    } } @end

一般來說,賽車通常不會撞車,所以我們永遠用不到滅火器。由於需要這個對象的概率很低,我們不想在初始化方法裡立即創建它而拖慢每輛賽車的創建。另外,如果一輛賽車需要從多次撞車中恢復,就得創建多個滅火器。對於這種情況,我們可以使用工廠設計模式。

工廠設計模式是標準的 Objective-C blocks 語法,它不需要參數並返回一個對象實例。一個對象可以在不需要知道創建細節的情況下,用 blocks 來創建依賴。

下面是一個使用依賴注入(即工廠設計模式)來創建滅火器的例子:

typedef RCFireExtinguisher *(^RCFireExtinguisherFactory)(); @interface RCRaceCar () @property (nonatomic, readonly) RCEngine *engine; @property (nonatomic, copy, readonly) RCFireExtinguisherFactory fireExtinguisherFactory; @end @implementation RCRaceCar - (instancetype)initWithEngine:(RCEngine *)engine        fireExtinguisherFactory:(RCFireExtinguisherFactory)extFactory {    ...        _engine = engine;    _fireExtinguisherFactory = [extFactory copy];    return self; } - (void)recoverFromCrash {    if (self.fire != nil) {       RCFireExtinguisher *fireExtinguisher = self.fireExtinguisherFactory();       [fireExtinguisher extinguishFire:self.fire];    } } @end

當我們需要創建未知個數的依賴時,工廠模式也很有用,甚至在初始化器裡就可以這麼做,比如:

@implementation RCRaceCar - (instancetype)initWithEngine:(RCEngine *)engine                    transmission:(RCTransmission *)transmission                    wheelFactory:(RCWheel *(^)())wheelFactory; {    self = [super init];    if (self == nil) {       return nil;    }        _engine = engine;    _transmission = transmission;        _leftFrontWheel = wheelFactory();    _leftRearWheel = wheelFactory();    _rightFrontWheel = wheelFactory();    _rightRearWheel = wheelFactory();        // Keep the wheel factory for later in case we need a spare.    _wheelFactory = [wheelFactory copy];        return self; } @end

避免笨重的配置

如果一個對象不應該在其他對象裡被 alloc,那它應該在哪裡被 alloc?這樣的依賴是不是很難配置?難道每次 alloc 它們都一樣困難?對這些問題的解決,要依靠類型的簡潔初始化器(例如 +[NSDictionary dictionary])。我們把對象圖的配置從普通對象中剝離出來,使它們保持純淨、可測試,業務邏輯清晰。

在添加類型簡易初始化方法之前,先確認它確有必要。如果一個對象在 init 方法裡只有少量參數,且這些參數沒有合理的默認值,那麼這個類型就不需要簡潔初始化方法,直接調用標準的 init 即可。

我們會從以下 4 類來源收集依賴,來配置對象:

  • 沒有合理默認值的值。比如每個實例都可能包含不同的布爾值或數值,這些值應作為參數傳給類型的簡潔初始化器。

  • 現存的共享對象。這些對象應作為參數傳給類型的簡潔初始化器(例如某段無線電頻率)。它們都是之前可能被評估成單例,或通過父類指針傳遞的對象。

  • 新創建的對象。如果我們的對象不能與其他對象共享這些依賴,那麼合作的對象應在類型簡潔初始化函數中新建一個實例。這些都是之前在對象的 implementation 裡直接分配、由對象自己創建的對象。

  • 系統單例。這些是 Cocoa 提供的單例,可以直接使用。對於在你的 app 中預計只需產生一個實例的類型,可以使用這類單例,系統中有很多這樣的單例。

一個賽車類的簡潔初始化方法如下:

+ (instancetype)raceCarWithPitRadioFrequency:(RCRadioFrequency *)frequency; {    RCEngine *engine = [[RCEngine alloc] init];    RCTransmission *transmission = [[RCTransmission alloc] init];        RCWheel *(^wheelFactory)() = ^{       return [[RCWheel alloc] init];    };        return [[self alloc] initWithEngine:engine                             transmission:transmission                             pitRadioFrequency:frequency                           wheelFactory:wheelFactory]; }

你的類型便利初始化方法應該放在合適的位置:常用或可復用的配置文件作為對象放在 .m 文件裡,而只由某個特殊對象(如 RaceCar)使用的配置器,則應放在該類的 @interface 裡。
系統單例

在 Cocoa 庫裡,很多對象只有一個實例存在,例如 [UIApplication sharedApplication]、[NSFileManager defaultManager]、[NSUserDefaults standardUserDefaults]、[UIDevice currentDevice]。如果一個對象依賴於以上這些對象,就應該把它放進初始化器的參數裡。即使你的代碼中可能只有一個實例,測試時你仍可能想模擬它,或創建一個專用於測試的實例,以避免測試之間相互依賴。

作者建議大家在自己的代碼中避免創建全局引用的單例,也不要在一個對象第一次需要時、或注入所有依賴於它的對象時,才創建它的單個實例。

不可變的構造器

偶爾會遇到這種情況:一個類的初始化器/構造器不能被改變,或無法直接調用。此時就應該使用 setter injection,例如:

// An example where we can't directly call the the initializer. RCRaceTrack *raceTrack = [objectYouCantModify createRaceTrack]; // We can still use properties to configure our race track. raceTrack.width = 10; raceTrack.numberOfHairpinTurns = 2;

setter injection 允許你配置對象,但它給對象設計引入了額外的可變性,需要額外測試和處理。所幸,導致初始化無法訪問或無法修改的兩種主要場景都可以避免。

類註冊

使用類註冊的工廠模式,意味著對象無法修改它們的初始化器。

NSArray *raceCarClasses = @[    [RCFastRaceCar class],    [RCSlowRaceCar class], ]; NSMutableArray *raceCars = [[NSMutableArray alloc] init]; for (Class raceCarClass in raceCarClasses) {    // All race cars must have the same initializer ("init" in this case).    // This means we can't customize different subclasses in different ways.    [raceCars addObject:[[raceCarClass alloc] init]]; }

對於這樣的問題,可以用工廠模式 blocks 簡單替代類聲明的列表。

typedef RCRaceCar *(^RCRaceCarFactory)(); NSArray *raceCarFactories = @[    ^{ return [[RCFastRaceCar alloc] initWithTopSpeed:200]; },    ^{ return [[RCSlowRaceCar alloc] initWithLeatherPlushiness:11]; } ]; NSMutableArray *raceCars = [[NSMutableArray alloc] init]; for (RCRaceCarFactory raceCarFactory in raceCarFactories) {    // We now no longer care which initializer is being called.    [raceCars addObject:raceCarFactory()]; }

Storyboards
storyboard 提供了便捷的方式來布置用戶界面,但卻給依賴注入帶來了問題。尤其突出的是,在 storyboard 中初始化 View Controller 不允許你選擇調用哪個初始化方法;同樣地,當在 storyboard 中定義頁面跳轉時,目標 View Controller 也不會給你自定義初始化方法來產生實例。

解決方法就是避免使用 storyboard。這聽起來是個極端方案,但我們會發現使用 storyboard 會滋生大量其他問題。另外,如果不想失去 storyboard 帶來的便利,可以改用 XIB,而且 XIB 能讓你自定義初始化器。

公有 vs. 私有

依賴注入鼓勵你在公共接口中暴露更多的對象。如前所述,這有諸多優點。在搭建框架時,它能大大充實你的公共 API。而且運用依賴注入,公共對象 A 可以使用私有對象 B(這樣輪流下去,B 又可以使用私有對象 C),但對象 B 和 C 從未暴露在框架之外。對象 A 在初始化器中依賴注入對象 B,而對象 B 的構造器又創建了對象 C。

// In public ObjectA.h. @interface ObjectA // Because the initializer uses a reference to ObjectB we need to // make the Object B header public where we wouldn't have before. - (instancetype)initWithObjectB:(ObjectB *)objectB; @end @interface ObjectB // Same here: we need to expose ObjectC.h. - (instancetype)initWithObjectC:(ObjectC *)objectC; @end @interface ObjectC - (instancetype)init; @end

你也不希望框架的使用者去操心對象 B 和對象 C 的實現細節,這可以通過協議來解決。

@interface ObjectA - (instancetype)initWithObjectB:(id )objectB; @end // This protocol exposes only the parts of the original ObjectB that // are needed by ObjectA. We're not creating a hard dependency on // our concrete ObjectB (or ObjectC) implementation. @protocol ObjectB - (void)methodNeededByObjectA; @end

結束語

依賴注入很適合 Objective-C 以及後來的 Swift。恰當運用,能讓你的代碼庫更易讀、更易測試、更易維護。

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