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

iOS 應用架構談(二):View 層的組織與調用方案

編輯:iOS 開發基礎

前言

《iOS 應用架構談 開篇》發佈後,很多人催我趕緊出第二篇。這一篇寫得相當艱難——公司瑣事特別多,自己又有點私事,能拿來寫 Blog 的時間實在不夠。現在總算寫完了。

設計 View 層架構的時機通常只有兩種:App 還沒開始開發,或者 App 已經發過幾版、此時需要一次徹底重構。正因為時機特殊,我們必須清楚認識到:View 層架構一旦定型,發版後可修改的餘地就極小了。它與業務關聯最緊密,哪怕動一點點,引發的蝴蝶效應都不一定是業務方能 hold 住的。這就要求我們在實作時程式碼必須改得勤快、不能偷懶,同時抱持充分的自我懷疑,決策時拿捏好尺度。

在我看來,View 層架構是這個系列四個面向中最重要的一塊,沒有之一。理由有兩個。

View 層架構直接影響業務方的迭代週期

產品經理產生需求的速度非常快,尤其在創業初期;而在規模稍大的公司,PM 也喜歡挖大坑在 leader 面前刷存在感。於是業務工程師任務繁重。正常情況下讓 PM 砍需求不太現實,所以作為架構師,架構裡那些「可做可不做」的事,最好能做就做掉,別偷懶——這能幫業務方減負,讓他們寫程式時更專注於業務本身。

我與一些朋友交流時,他們或多或少都抱怨團隊迭代速度不夠快,或者不合理地慢。迭代速度不是想提就能提,它受很多因素影響:一期 PRD 的任務量與複雜度都會決定週期能壓到什麼程度。撇開這些外在因素,從內在原因看,其中一個很可能就是 View 層架構沒做好,導致業務工程師完成一個並不複雜的需求時,得處理太多額外的事。(當然,開會多、工程師水準不足也屬於內部原因,但不在本文討論範圍。)另外,加班不是優化迭代週期的正確方式,嗯。

一般來說,一個不夠好的 View 層架構,主因有以下五種:

  1. 程式碼混亂不規範

  2. 過多繼承導致的複雜依賴關係

  3. 模組化程度不夠高、元件粒度不夠細

  4. 橫向依賴

  5. 架構設計失去傳承

這五點會拖慢業務工程師實現需求的效率,進而拉長迭代週期。其他缺陷也會有影響,但我認為這五項是主要因素。

第五點我想特別強調:架構設計必須有傳承,有傳承的架構整體看起來會非常協調。但現實往往是:一個人走了,另一個頂上,即使交接得再完整,不同人的架構思路終究不同,整個架構的流暢度就會受影響。解法有兩個方向:一是盡量避免單點問題,讓架構師做架構時再帶一個人;二是把架構設計得盡量簡單,壓平接手者的學習曲線。我離開安居客時做過承諾:凡是從我手裡出來的程式碼,終身保修。所以不要以為離職了就什麼都不用管,這不只是職業素養問題,也是你對自己的程式碼是否夠自信的問題。

所以各位 CTO、技術總監、TeamLeader 們,當你覺得迭代週期不夠快時,先別急著吼著招人——《人月神話》早就說過加人不能解決問題。回頭看看是不是 View 層架構不合理,把它弄好也是優化迭代週期的手段之一。

View 層架構是最貼近業務的底層架構

View 層架構雖然也算底層,但沒那麼底層——它與業務的對接面最廣,影響業務層程式碼的程度也最深。所有底層都牽一發時,在 View 架構上牽一發導致業務層動全身的面積最大。

所以 View 架構一旦定型,可修改空間最小。一開始考慮它時,除了實現功能,還要考慮更多規範上的東西。制定規範一方面防止業務程式碼腐蝕架構,另一方面是為了有所傳承——照規範走,總不那麼容易出差錯。

另外,架構師一開始想做的事很多,不可能第一版就全部實現。對一個尚未發版的 App 來說,第一版架構往往只是最小完整功能集;在第二版、第三版的演進中,架構的迭代任務很可能不只你一個人的事,你得與合作者有約定。此外,業務工程師在使用過程中會產生大量修改意見,哪些合理、哪些不合理,也得靠事先約定的規範來篩選。

規範也不是一成不變的。什麼時候槍斃意見、什麼時候改規範,就要靠各位的技術與經驗了。

這篇文章要談什麼

  • View 程式碼結構的規範

  • 關於 View 的佈局

  • 何時用 storyboard、何時用 nib、何時用程式碼寫 View

  • 是否有必要讓業務方統一繼承 ViewController

  • 方便 View 佈局的小工具

  • MVC、MVVM、MVCS、VIPER

  • 本門心法

  • 跨業務時 View 的處理

  • 總結

View 程式碼結構的規範

架構師不是寫個 SDK 交給業務方就沒事了。每家公司都有一套程式碼規範,定義規範也是架構師的職責之一。嚴格說,制定規範不算 View 層架構的事,但它對 View 層架構的未來影響很大,所以放在這裡談。制定 View 層規範的重要性在於:

  1. 提高業務方 View 層的可讀性與可維護性

  2. 防止業務程式碼對架構產生腐蝕

  3. 確保傳承

  4. 讓架構發展方向不輕易被不合理意見左右

我不打算從零定義一整套規範——蘋果有 Coding Guidelines,定結構或規範時首先一定要符合它。相信各位公司也各有規範,具體怎麼定取決於架構師的經驗。我只建議在既有規範之上再加一點。

viewController 的程式碼大致該長這樣:

要點一:所有屬性都用 getter 和 setter

不要在 viewDidLoad 裡初始化 view 再 addSubview,那樣程式碼會很難看。viewDidLoad 只做 addSubview,佈局交給 viewWillAppear(勘誤 1),通知監聽之類的則放 viewDidAppear。屬性的初始化一律交給 getter。

#pragma mark - life cycle

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    [self.view addSubview:self.firstTableView];
    [self.view addSubview:self.secondTableView];
    [self.view addSubview:self.firstFilterLabel];
    [self.view addSubview:self.secondFilterLabel];
    [self.view addSubview:self.cleanButton];
    [self.view addSubview:self.originImageView];
    [self.view addSubview:self.processedImageView];
    [self.view addSubview:self.activityIndicator];
    [self.view addSubview:self.takeImageButton];
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    CGFloat width = (self.view.width - 30) / 2.0f;
    self.originImageView.size = CGSizeMake(width, width);
    [self.originImageView topInContainer:70 shouldResize:NO];
    [self.originImageView leftInContainer:10 shouldResize:NO];

    self.processedImageView.size = CGSizeMake(width, width);
    [self.processedImageView right:10 FromView:self.originImageView];
    [self.processedImageView topEqualToView:self.originImageView];

    CGFloat labelWidth = self.view.width - 100;
    self.firstFilterLabel.size = CGSizeMake(labelWidth, 20);
    [self.firstFilterLabel leftInContainer:10 shouldResize:NO];
    [self.firstFilterLabel top:10 FromView:self.originImageView];
    // ...
}

這樣即使屬性非常多,程式碼依然整齊。盡量不要出現這種情況:

- (void)viewDidLoad {
    [super viewDidLoad];
    self.textLabel = [[UILabel alloc] init];
    self.textLabel.textColor = [UIColor blackColor];
    self.textLabel ... ...
    self.textLabel ... ...
    self.textLabel ... ...
    [self.view addSubview:self.textLabel];
}

這就不夠乾淨,統統丟進 getter 就好了。(關於這點,唐巧的技術部落格有一篇文章與我提倡的做法不同,後面我會詳細論述。)

要點二:getter 和 setter 全部放在最後

一個 ViewController 很可能有非常多 view,就像上面那樣。如果 getter/setter 寫在前面,主要邏輯就會被擠到後面,別人閱讀時得先劃過一大串 getter 和 setter,體驗不好。所以要求業務工程師按順序分配程式碼區塊:life cycle → Delegate 方法實作 → event response → getters and setters。後來者讀程式碼會輕鬆很多。

要點三:每個 delegate 都標上對應的 protocol 名稱

例如 UITableViewDelegate 的方法就老實寫上 #pragma mark - UITableViewDelegate。好處是:當別人閱讀一個不熟悉的 delegate 實作時,只要按住 command 點一下 protocol 名稱,Xcode 立刻跳到定義處,省得他到處找。

要點四:event response 專門開一個區塊

所有 button、gestureRecognizer 的回應事件都放在這裡,不要四處亂放。

要點五:private methods 一般情況下不該出現在 ViewController 裡

不是 delegate 方法、不是 event response、不是 life cycle 的,就是 private method 了。正常情況下 ViewController 裡通常不存在 private methods——它們一般是一些日期換算、圖片裁剪之類的小功能。這種小功能要麼寫成一個 category,要麼做成一個模組,哪怕這個模組只有一個函式也行。

ViewController 是大部分業務的載體,本身已經相當複雜,跟業務關聯不大的東西能不放進來就不放。另外,這個 private method 現在只有你用得到,但未來很可能別處也要用,一開始就獨立出來,有利於後續復用。

為什麼要這樣要求?

我見過無數 ViewController,程式碼佈局亂得一塌糊塗,這裡一個 delegate、那裡一個 getter,檔案還死長死長的,看了就頭疼。定好規範,ViewController 就能條理清晰,業務方很清楚哪些該放進來、哪些不該;可讀性與可維護性也隨之提高。

關於 View 的佈局

寫 View 時逃不掉的命題。用 Frame 也好、用 Auto Layout 也好,若沒精心設計過,佈局部分一定慘不忍睹。

直接用 CGRectMake 可讀性很差,光看幾個數字無從得知 view 之間的相對關係;Auto Layout 可讀性好一些,但生成 Constraint 的程式碼實在太長,觀感不佳。

Auto Layout 這邊可以考慮使用 Masonry,可讀性會好很多。如果還在用 Frame,可以考慮這個專案。

該專案提供了 Frame 相關的便捷方法(UIView+LayoutMethods),基本涵蓋所有佈局需求,可讀性非常好,用了它就能跟 CGRectMake 說再見。天貓直到最近才切換到支援 iOS 6,因此之前都是用 Frame 佈局;在天貓 App 中,首頁、範兒等頁面的佈局就用了這些方法,效果事半功倍。

專案也提供了 Auto Layout 方案下生成 Constraints 的便捷方法(UIView+AEBHandyAutoLayout),可讀性比原生好很多。我當初寫這系列方法時還不知道有 Masonry,後來特地去看了一下,Masonry 果然強大;不過這系列方法雖然沒那麼強,但也夠用。當時安居客 iPad 版 App 全部用 Auto Layout 做 View 佈局,用的就是這個專案,可讀性很好。

讓業務工程師用順手的好工具做佈局,能提高效率、減少 bug 發生。架構師不光要關心高大上的東西,也要多給業務方提供方便易用的小工具,這才是架構師價值的體現。

何時用 storyboard、nib 或純程式碼?

唐巧的部落格也談過這個問題,我的意見與他基本一致。這裡再補充一些。

具備一定規模的團隊化 iOS 開發(10 人以上)有幾個特點:

  1. 同一份程式碼檔案的作者會有很多,不同作者同時修改同一份檔案的情況也不少見,因此用 Git 做版本管理時出現 Conflict 的機率也比較大。

  2. 需求變化非常頻繁,為了完成需求而針對現有程式碼微調、以及部分復用現有程式碼的情況比較多。

  3. 複雜介面元素、複雜動畫場景的開發任務比較多。

如果這三點你一看就懂,下面的解釋可以跳過。

衝突成本

iOS 開發中最蛋疼的兩種 Conflict,一個是 project.pbxproj,另一個是 StoryBoard 或 XIB。這些檔案的可讀性非常差;蘋果在 Xcode 5 中對 StoryBoard 的檔案描述方式做過優化,但只是把可讀性從「非常差」提升到「很差」。

而 StoryBoard 往往包含多個頁面,這些頁面幾乎不可能都由一個人完成。如果另一個人在操作 StoryBoard 時出於某種目的動了一下不屬於他的頁面(比如為了美觀調了調位置),而另一個人為了新增頁面又調整了某個其他頁面的位置——這種情況下我除了說個「呵呵」,就只能說「祝你好運」。看清楚,這還沒動具體頁面內容呢。

如果用程式碼繪製 View,Conflict 一樣會發生,但好解很多,你懂的。

需求頻繁變動與部分復用

我覺得 PM 一時一個主意不一定是他的錯,他自己也可能是被逼的。公司裡所有人都會來摻和一下產品設計,上至 CEO、下至基層員工,只要某處用得不爽(極大可能是個人喜好)又正好跟 PM 搭得上話,就會提出各種意見。PM 躲不起也惹不起,有時也是沒辦法,嗯。

但落到工程師這邊就很蛋疼。這種改變有時不只是 UI,UI 對應的邏輯也要改,工程師得兩邊檔案都動:原本 link 的 view 現在不 link 了,對應的 outlet 也要刪,這兩部分只要漏一個,編譯通過、跑一下 App,一會兒就 crash。看似不是大事,但很影響心情。

另外,如果出现部分程式碼復用——比如某頁面的某個 View 也想放到另一個頁面——操作就不是複製貼上這麼簡單,你還得重新 link 一遍。同樣影響心情。

複雜介面與動畫

想在以 StoryBoard 為基礎的專案裡做一個動畫,很煩;做幾個複雜介面元素,也很煩。有時我們掛 Custom View 上去,在 StoryBoard 裡看來就是一個空白 View。而且當 layout 出問題需要調整時,還挺難定位問題所在,尤其在複雜介面元素的情況下。

所以針對 View 層,我也建議不要用 StoryBoard:實現簡單的東西,用程式碼一樣簡單;實現複雜的東西,程式碼比 StoryBoard 更簡單。我更提倡用程式碼畫 view。

是否有必要讓業務方統一繼承 ViewController?

基於記錄使用者操作行為資料、或統一配置頁面的需要,我們常會從 UIViewController 繼承一個自己的 ViewController 來執行通用邏輯。例如天貓客戶端要求所有 ViewController 都繼承自 TMViewController,這個統一父類對 ViewController 的所有生命週期都做了些設定(具體設定對本文不重要)。問題是:為了統一設定或執行統一邏輯,使用繼承的手段有必要嗎?

我覺得沒有必要,理由有兩條:

  1. 使用繼承比不使用繼承更容易增加業務方的使用成本

  2. 不使用繼承一樣能達到統一設定的目的

為什麼繼承會提高業務方成本?

其實不光是業務方成本,架構的維護成本也會上升。具體來自三處:

集成成本。假設業務方自己開了個獨立 Demo,快速完成了某個獨立流程,現在想把它整併進來。問題來了:他得把所有獨立的 UIViewController 改成 TMViewController。那為什麼不一開始就用 TMViewController?因為要引入它,就得引入整個天貓 App 的所有業務線與基礎庫——這個父類裡牽涉很多天貓環境才有的東西,拔出蘿蔔帶出泥。你只想繼承一下就能搞定的事,光是搭環境就得弄半天,然後小 Demo 才跑得起來。

業務層的所有父類都很容易跟專案其他程式碼糾纏不清,於是業務方遇到一個兩難:要麼把所有依賴全部搞定、直接在 App 環境(比如天貓)下開發 Demo,要麼先寫好自己的 Demo,之後再按環境要求改程式碼。兩條路都有成本,都會拖累迭代進度。

舉個我在阿里的真實例子:最近在開發某濾鏡 Demo 與相關頁面流程,最終要合併進天貓。用天貓環境開發的話,pod install 完所有依賴差不多要 10 分鐘,打開 workspace 後還要再等約 1 分鐘讓 Xcode 建好索引,才能正式開始工作(這裡要感謝則平做了很多優化,讓這 1 分鐘比原本短很多)。而如果天貓環境有更新,你就得再重複一次整個流程,否則很可能編譯不過。

拜託,我只是想做個 Demo 而已,不想搞這麼複雜。

上手接受成本。新來的業務工程師不一定記得每個 ViewController 都必須繼承自 TMViewController 而非直接繼承 UIViewController。他不能照蘋果原生的做法做事,得額外學習一條規則。

架構維護難度。盡可能少用繼承能提高專案可維護性,具體我在《跳出面向對象思想(一)繼承》裡說過,這裡就不重複。

對業務方來說,主要還是第一個集成成本最蛋疼,因為它是長痛,每次做點什麼都會遇到;第二點是短痛;第三點與業務工程師無關。

不用繼承,那用什麼?

我的建議是 AOP。

在實作具體方案前,架構師必須想清楚三個問題:

  1. 方案的效果,以及最終要達到的目的是什麼?

  2. 在自己的知識體系裡,是否具備實現這個方案的能力?

  3. 業界已有的開源元件裡,是否有可以直接拿來用的輪子?

依序回答完,方案自然就出來了。

第一個問題:效果與目的。方案的效果應該是:

  1. 業務方可以不用繼承,而框架仍能對 ViewController 做到統一配置。

  2. 業務方即使脫離框架環境,不改任何程式碼也能跑完;一旦把 ViewController 丟入框架環境,不改任何程式碼,框架就能發揮應有作用。

說白了,就是要實現「不透過業務程式碼主動迎合框架,業務也能被框架感知」。細分為兩個問題:框架要能攔截 ViewController 的生命週期,以及攔截的時機。

方法攔截很容易想到 Method Swizzling:可以寫一段在 App 啟動時掛上針對 UIViewController 的攔截。另一種做法是用 NSObject 的 load 函式,在應用啟動時自動監聽。後者的好處是:這個模組只要被專案包含就能發揮作用,不必在專案裡添加任何程式碼。

另外要考慮的是,原本的 TMViewController 也會提供額外方法給子類使用。Method Swizzling 只支援針對既有方法的操作,要擴展方法——嗯,當然是用 Category。我個人不贊成過度使用 Category,但既然 Category 是最典型的「化繼承為組合」手段,在這個場景下仍然合適。而 Method Swizzling 實現方法攔截,業界已有現成的開源庫:Aspects,可以直接拿來用。

這裡有個非常小的 Demo 可以給大家參考,它只是一個點睛之筆,一些話我也寫在裡面了。各位架構師可以依各自公司 App 的需求去擴展。這個 Demo 不包含 Category(畢竟 Category 還得你們自己寫~)。這套方案能完成原本靠繼承才能完成的所有任務,同時允許業務方不必添加任何程式碼,直接用原生的 UIViewController。

要提醒的是,這方案的目的是消除不必要的繼承,不限於 UIViewController,但它有適用範圍:適合繼承的地方還是要老實繼承。比如你有一整套由基本模型繼承而來的資料模型,那就老實用繼承。何時該繼承,相信各位架構師能拿捏好,也可以參考我前面提到的那篇文章。

關於 MVC、MVVM 等一堆思想

這些都是相對通用的思想,萬變不離其宗的還是我在開篇提到的三個角色:資料管理者、資料加工者、資料展示者。這些五花八門的思想,無非是制定了一個規範,規定這三個角色應當如何交換資料。但它們同時也是爭議最多的話題,所以我在這裡把幾個主流思想梳理一遍,供你做 View 層架構時參考。

MVC

MVC(Model-View-Controller)是最老牌的思想,老牌到四人幫的書裡把它歸成了一種模式:Model 是資料管理者,View 是資料展示者,Controller 是資料加工者;Model 與 View 都由 Controller 依業務需求調配,所以 Controller 還肩負資料流調配的功能。

在 iOS 開發領域,我們應當如何進行 MVC 的劃分?這裡其實有兩個問題:為什麼我們會糾結於 iOS 的 MVC 劃分?以及怎樣才算劃分得正確?

關於第一個,我猜(也歡迎討論)是因為:UIViewController 自帶一個 View,並控制 View 的整個生命週期(viewDidLoad、viewWillAppear...),而常識告訴我們 Controller 不該和 View 有這麼緊密的聯繫,所以大家才困惑。

在服務端開發領域,Controller 與 View 的互動方式是這樣(以 Yii 為例):

/*
    ...
    資料庫取資料
    ...
    處理資料
    ...
*/
// 此處 $this 就是 Controller
$this->render("plan", array(
    'planList' => $planList,
    'plan_id' => $_GET['id'],
));

這裡 Controller 與 View 區分得非常明顯:Controller 做完自己的事,就把所有關於 View 的工作交給頁面渲染引擎,自己不碰任何 View 相關的事,連生成 View 都由渲染引擎代勞。

但服務端 View 的概念和 Native 應用 View 的概念,真正的區別在於:嚴格劃分的話,服務端其實根本沒有 View。拜 HTTP 協議所賜,我們平時討論的 View 只是「用於描述 View 的字串」(更實質地說應該稱為資料),真正的 View 是瀏覽器。

所以服務端只管生成對 View 的描述,至於 View 的長相、UI 事件監聽與處理,都由瀏覽器負責。但在 Native 這邊,原本屬於瀏覽器的任務也逃不掉要自己做。那這件事由誰做最合適?蘋果的答案是:UIViewController。

蘋果在這一層做了很多努力,讓 iOS 工程師不必親自實作這些;而且它把所有功能都放在 UIView 上,並把 UIView 做成一個既能展示 UI、又能作為容器的物件。

看到這兒你明白了嗎?UIView 的另一個身份其實是容器!UIViewController 自帶的那個 view,主要任務就是作為一個容器。如果把它相關的命名都改成 ViewContainer,程式碼會變成這樣:

- (void)viewContainerDidLoad {
    [self.viewContainer addSubview:self.label];
    [self.viewContainer addSubview:self.tableView];
    [self.viewContainer addSubview:self.button];
    [self.viewContainer addSubview:self.textField];
}
// ...

只改了個名字,是不是清晰很多?

我們平常認為的服務端 MVC 是這樣劃分的:

但事實上,整套流程的 MVC 劃分是這樣:

也就是說,服務端開發在這個概念下只涉及 M 與 C 的開發工作;瀏覽器作為 View 的容器,負責展示與事件監聽。對應到 iOS 客戶端,就是這樣:

唯一區別在於:View 的容器在服務端由 Browser 負責,在整個網站流程中這非常合理;在 iOS 客戶端,View 的容器由 UIViewController 的 view 負責——我認為蘋果這個選擇非常正確明智。

因為瀏覽器與服務端之間關係非常鬆散,分屬兩個陣營:服務端生成 View 描述後交給瀏覽器展示,而一旦 view 上有事件產生,基本上很少傳回伺服器(要傳也可以:AJAX),都在瀏覽器這邊做掉。所以這種情況下,View 容器適合放在瀏覽器(V)這邊。

但在 iOS 開發領域,雖然也有讓 View 監聽事件的做法,但非常少見;一般都是把事件回傳給 Controller,再由 Controller 另行調度。所以此時 View 的容器放在 Controller 就非常合適——Controller 可以依不同事件很方便地更換容器內容:加載失敗時換成失敗頁面的 View,無網絡時換成無網絡的 View,等等。

那怎樣才算劃分得正確?總結如下:

M 應該做的事:

  1. 給 ViewController 提供資料

  2. 給 ViewController 儲存資料並提供介面

  3. 提供經過抽象的業務基本元件,供 Controller 調度

C 應該做的事:

  1. 管理 View Container 的生命週期

  2. 負責生成所有 View 實例並放入 View Container

  3. 監聽來自 View 的、與業務有關的事件,透過與 Model 合作完成對應業務

V 應該做的事:

  1. 回應與業務無關的事件,並因此引發動畫效果、點擊回饋等(若合適,盡量放在 View 做)

  2. 介面元素表達

之所以用服務端 MVC 對比來回答,是因為我知道很多 iOS 工程師是從服務端轉過來的——我也是。進安居客之前我做服務端開發,學 iOS 時也曾對 MVC 劃分產生過疑惑,疑惑的點就是前面猜測的那個。如果有人問我 iOS 該怎麼做 MVC 劃分,我就會像上面這麼回答。

MVCS

蘋果自身採用的就是這種思路,從名字也能看出它基於 MVC 衍生。概念上,它拆分的是 Model 部分,抽出一個專門負責資料存取的 Store;但從實作角度看,它拆開的其實是 Controller。

這算是「瘦 Model」的一種方案:瘦 Model 只用來表達資料,儲存與處理都交給外面。MVCS 的前提是假設你採用瘦 Model,且資料的儲存與處理都在 Controller 做——所以 Controller 會變得非常龐大,於是把它專門負責存取資料的那部分抽離成 Store。這樣調整之後,結構就成了真正意義上的 MVCS。

關於胖 Model 與瘦 Model

我在面試與聊天時發現,知道胖 Model 與瘦 Model 概念的人不多。大約兩三年前國外業界對此有過非常激烈的討論,主題就是 Fat model, skinny controller。現在討論少了,但直到今天業界仍無定論,算是懸而未解的爭議。我在這裡補充一下。

什麼叫胖 Model?胖 Model 包含了部分弱業務邏輯,目的是讓 Controller 從它這裡拿到資料後,不用額外操作或只要極少操作,就能把資料直接應用在 View 上。例如:

Raw Data:
    timestamp: 1234567

FatModel:
    @property (nonatomic, assign) CGFloat timestamp;
    - (NSString *)ymdDateString;  // 2015-04-20 15:16
    - (NSString *)gapString;      // 3分鐘前、1小時前、一天前、2015-3-13 12:34

Controller:
    self.dateLabel.text = [FatModel ymdDateString];
    self.gapLabel.text = [FatModel gapString];

把 timestamp 轉換成業務需要的字串屬於業務程式碼,算是弱業務。FatModel 做了這些弱業務之後,Controller 就能變得非常 skinny,只需關注強業務。眾所周知,強業務變動的可能性遠大於弱業務,弱業務相對穩定,所以塞進 Model 沒問題。另一方面,弱業務重複出現的頻率高於強業務,對復用性的要求更高;若寫在 Controller,類似程式碼會灑得到處都是,一旦弱業務要改(頻率低不代表不會改),就是一場災難。放進 Model,改一處很多地方就能跟著改。

缺點在於:胖 Model 相對難移植,雖然只是弱業務,但好歹也是業務,遷移時很容易拔出蘿蔔帶出泥。另外,MVC 的思想更傾向於 Model 是一個 Layer 而非一個 Object,不該把一個 Layer 該做的事交給一個 Object。最後,軟體會成長,FatModel 很可能越來越 Fat,最終難以維護。

什麼叫瘦 Model?瘦 Model 只負責業務資料的表達,所有業務無論強弱一律扔到 Controller。目的是盡一切可能編寫細粒度 Model,並配套各種 helper 類或方法對弱業務做抽象,強業務依舊交給 Controller。例如:

Raw Data:
{
    "name": "casa",
    "sex": "male",
}

SlimModel:
    @property (nonatomic, strong) NSString *name;
    @property (nonatomic, strong) NSString *sex;

Helper:
    #define Male 1;
    #define Female 0;
    + (BOOL)sexWithString:(NSString *)sex;

Controller:
    if ([Helper sexWithString:SlimModel.sex] == Male) {
        ...
    }

由於 SlimModel 與業務完全無關,它的資料可以交給任何能處理它的 Helper 或其他物件來完成業務。程式碼遷移時獨立性很強,很少出現拔出蘿蔔帶出泥的情況。而且由於它只是資料表達,維護成本幾乎為 0,軟體膨脹得再厲害,SlimModel 也不會大到哪兒去。

缺點是:Helper 這種做法不見得更好(這裡有一篇文章批判了這件事);而且由於 Model 的操作會出現在各種地方,SlimModel 在一定程度上違背了 DRY(Don't Repeat Yourself),Controller 仍不可避免會出現程式碼膨脹。

我的態度?嗯,我在本門心法那節再說。

回到 MVCS:它是基於瘦 Model 的一種架構思路,把原本 Model 要做的事中關於資料儲存的程式碼抽象成 Store,一定程度降低了 Controller 的壓力。

MVVM

MVVM 去年在國內外都討論得非常熱烈,尤其在 ReactiveCocoa 成熟之後,ViewModel 與 View 的信號機制在 iOS 下終於有了一個相對優雅的實作。

MVVM 本質上也是從 MVC 衍生,它著重解決的問題是盡可能減少 Controller 的任務。MVVM 也好、MVCS 也好,它們的共識都是:Controller 會隨著軟體成長而變得巨大、難維護、難測試。只是前提不同——MVCS 認為 Controller 做了一部分 Model 的事,要拆出來變成 Store;MVVM 認為 Controller 做了太多資料加工的事,所以把資料加工從 Controller 中解放出來,讓 Controller 只需專注資料調配,ViewModel 負責資料加工並透過通知機制讓 View 響應變化。

MVVM 是基於胖 Model 的架構思路建立的,然後在胖 Model 中拆出兩部分:Model 與 ViewModel。這裡要做個額外解釋:胖 Model 先為 Controller 減負,然後由於 Model 變胖,再在此基礎上拆出 ViewModel。這與業界普遍認為「MVVM 本質上是為 Controller 減負」並不矛盾,因為胖 Model 做的事也是為 Controller 減負。

另外,我說「MVVM 把資料加工的任務從 Controller 中解放出來」與「MVVM 拆分的是胖 Model」也不矛盾:要做到解放 Controller,首先你得有個胖 Model,然後再把它拆成 Model 與 ViewModel。

那 MVVM 究竟應該如何實現?這大概是多數人糾結的問題,我憑個人經驗試著回答,歡迎在評論區交流。

在 iOS 領域大部分 MVVM 架構都會使用 ReactiveCocoa。但用了 ReactiveCocoa 的 iOS 應用就是 MVVM 嗎?当然不是。我覺得很多人存在這個誤區——面試過的一些人提到 ReactiveCocoa 也提到 MVVM,但他們的理解膚淺得讓我忍俊不禁。

MVVM 的關鍵是要有 View Model,而不是 ReactiveCocoa(勘誤 2)。

ViewModel 做什麼?就是把 RawData 變成能直接被 View 使用的物件的一種 Model。例如:

Raw Data:
    {
        (
            (123, 456),
            (234, 567),
            (345, 678)
        )
    }

假設這些是經緯度(數字隨便寫的,別太在意),而你有一個地圖模組。把經緯度陣列全部轉變成 MKAnnotation 或其派生類,對 Controller 來說是弱業務(記住,胖 Model 就是用來做弱業務的),因此我們用 ViewModel 直接把它轉成 MKAnnotation 的 NSArray,交給 Controller 後直接就能用。

這就是 ViewModel 要做的事,是不是覺得很簡單、看不出優越性?

安居客 Pad 應用也有地圖模組,我在這裡設計了一個名為 reformer 的物件(其實就是 ViewModel),專門幹這件事。優越性體現在哪?安居客分三大業務:租房、二手房、新房,對應三個 API 開發團隊各自為政,結果是:三個團隊回饋給客戶端的資料內容雖然一致,格式卻不一致——相同 value 對應的 key 不同。但展示地圖的 ViewController 不可能寫三份,所以少不了要有一層 API 資料相容邏輯,我就把它放在 reformer 裡,於是業務流程變成:

這樣一來,原本複雜的 MKAnnotation 組裝邏輯就從 Controller 裡拆分了出來,Controller 直接拿 reformer 回傳的資料展示即可。APIManager 屬於 Model,reformer 屬於 ViewModel。reformer 此時扮演的 ViewModel 角色很好地為 Controller 減負,維護成本也大幅降低——經過 reformer 產出的永遠都是 MKAnnotation,Controller 可以直接使用。

另外還有一個業務需求是「取附近的房源」,地圖 API 請求本來就能 hold 住這個需求,所以其他地方都不用變,在 fetchDataWithReformer 時換一個 reformer 就好,其他都交給 reformer。

那 ReactiveCocoa 應該扮演什麼角色?不用 ReactiveCocoa 也能 MVVM,用了則能更好地體現 MVVM 的精髓。前面舉的例子只是資料從 API 走向 View 的方向;View 的操作也會產生「資料」,只不過這裡的「資料」更多體現在表達使用者的操作上——輸入了什麼內容,資料就是 text;選了哪個 cell,資料就是 indexPath。而在資料從 View 走向 API 或 Controller 的方向上,就是 ReactiveCocoa 發揮的地方。

我們知道 ViewModel 本質上算是 Model 層(因為是從胖 Model 分出來的),所以 View 並不適合直接持有 ViewModel。那 View 一旦產生資料了怎麼辦?扔信號給 ViewModel。用誰扔?ReactiveCocoa。

在 MVVM 中使用 ReactiveCocoa 的第一個目的就是如此;第二個目的在於,ViewModel 有可能並不只服務於特定的單一 View,使用更鬆散的綁定關係能降低 ViewModel 與 View 之間的耦合度。

那 Controller 在 MVVM 中扮演什麼角色?大部分國內外資料闡述 MVVM 時都是這樣排布的:View ↔ ViewModel ↔ Model,造成了「MVVM 不需要 Controller」的錯覺,現在甚至有這樣的聲音出現了。其實 MVVM 一定需要 Controller 參與——雖然 MVVM 在一定程度上弱化了 Controller 的存在感,並為它減負瘦身(這也是 MVVM 的主要目的),但這不代表不需要它。兩者的關係應該是:

(來源:https://www.sprynthesis.com/2014/12/06/reactivecocoa-mvvm-introduction/)

也就是 View ↔ C ↔ ViewModel ↔ Model。所以「用了 MVVM 就不需要 Controller」的說法是不正確的;嚴格來說 MVVM 其實是 MVCVM。從圖中可知,Controller 夾在 View 與 ViewModel 之間,做的主要事情之一就是將兩者綁定。邏輯上,Controller 知道該展示哪個 View,也知道該用哪個 ViewModel,而 View 與 ViewModel 彼此互不知情,所以由 Controller 負責控制它們的綁定關係——這才是它叫「Controller/控制器」的原因。

歸根結底一句話:在 MVC 的基礎上,把 C 拆出一個 ViewModel 專門負責資料處理,就是 MVVM。然後為了讓 View 與 ViewModel 之間能有比較鬆散的綁定關係,我們使用 ReactiveCocoa,因為蘋果本身並未提供適合這種情況的綁定方式。iOS 領域裡 KVO、Notification、block、delegate、target-action 都能用來做資料通信從而實現綁定,但都不如 RACSignal 優雅;不用 ReactiveCocoa,綁定關係可能做不到那麼鬆散,但並不影響它仍然是 MVVM。

在實際 iOS 應用架構中,MVVM 應該已出現在大部分創業公司或老牌公司新 App 的架構圖裡。據我所知,易寶支付旗下的某個 iOS 應用就整體採用了 MVVM 架構,他們抽出一個 Action 層來裝各種 ViewModel,也是相對合理的結構。

所以 Controller 在 MVVM 中,一方面負責 View 與 ViewModel 之間的綁定,另一方面也負責常規的 UI 邏輯處理。

VIPER

VIPER(View、Interactor、Presenter、Entity、Routing)。我並沒有實際使用過,是在 objc.io 第 13 期看到的。

但凡出現一個新架構或我不熟悉的新架構,有一點我能非常肯定:這傢伙一定又是把 MVC 的哪個部分給拆開了(壞笑,判斷的理論依據在第一篇文章裡講過)。事實上 VIPER 確實拆了很多——除了 View 沒拆,其他都拆了。

我提到的那兩篇文章對 VIPER 講得很詳細,一看就懂。但實際使用 VIPER 時會有什麼坑、會有哪些爭議,我不是很清楚,硬要寫就只能靠 YY,所以想想還是算了。如果有讀者在實際 App 中採用 VIPER,或對它很有興趣,歡迎在評論區提出來交流。

本門心法

重劍無鋒,大巧不工。——《神鵰俠侶》

這是楊過挑劍時,玄鐵重劍旁刻的一段話,我深表認同。提它的目的是想說:具體做 View 層架構設計時,不需要拘泥於 MVC、MVVM、VIPER 等規矩。這些都是招式,告訴你你就知道了,然後怎麼玩都可以。但心法不同,心法是大巧,說出來很簡單,能不能在實際設計時牢記並照規矩辦事,就看個人了。

拆分的心法

天下功夫出少林,天下架構出 MVC。—— Casa Taloyum

MVC 其實是非常高層次的抽象,也就是說在 MVC 體系下還可以再衍生無數架構方式,但萬變不離其宗的是,它一定符合 MVC 的規範。這句話不是我能想出來的,是某個英文資料裡看到的(時过境遷,我已找不到出處),我很贊同。我採用的架構嚴格來說也是 MVC,但也做了很多拆分。根據前面幾節的洗禮,相信各位也明白了:拆分方式的不同誕生了各種不同的衍生架構方案(MVCS 拆胖 Controller,MVVM 拆胖 Model,VIPER 什麼都拆),但再怎麼多樣都只是招式;而拆分的規範,就是心法。

第一心法:保留最重要的任務,拆分其他不重要的任務。在 iOS 領域,UIViewController 承載了非常多事情:View 初始化、業務邏輯、事件回應、資料加工等等。但我們知道有一件事 Controller 肯定逃不掉:協調 V 與 M。也就是說,不管怎麼拆,協調工作是拆不掉的。

剩下的事就可以拆了,比如 UITableView 的 DataSource。唐巧的部落格有篇文章提到他和另一位工程師關於是否拆分 DataSource 爭論了好久。拆分 DataSource 算是通用做法:在不複雜的應用裡,它可能確實看起來只是一個陣列;但在複雜情況下,它背後可能涉及檔案內容讀取、資料同步等複雜邏輯。這篇文章第一節就提倡了這個做法,我也蠻提倡的。

除了這些,任何比較大的、放在 ViewController 裡比較髒的、只要不是 Controller 核心邏輯的東西,都可以考慮拆出去,在架構時作為獨立模組去定義與實作。

第二心法:拆分後的模組要盡可能提高可復用性,盡量做到 DRY。依第一心法拆出來的東西,很可能仍是強業務相關的,這種情況有時無法避免。但我們也要拆得好看:拆出來的部分最好能歸成某一類物件,並抽出通用邏輯使其可復用;即使抽不出通用邏輯,也盡量抽象出一個 protocol 來實現 IOP(面向介面程式設計),優越性可參考相關文章。

第三心法:要盡可能提高拆分模組後的抽象度。也就是說,拆分粒度要盡可能大一點,封裝要透明一些。唐巧說「一切隱藏都是對程式碼複雜性的增加,除非它帶來了好處」,這在一定程度上有道理,沒有好處的隱藏確實都不好(笑)。提高抽象度事實上就是加大封裝力度,把一個複雜的業務抽象成只需很少輸入就能完成,就是高度抽象。嗯,繼承很多層雖然也提高了抽象程度,但我不建議這麼玩。

提高抽象程度的好處在於:對業務方來說,他只需要收集很少的資訊(最小充要條件)、做很少的調度(Controller 負責大模組調度,大模組內部再做小模組調度),就能完成任務——這才是給 Controller 減負的正確姿勢。

如果拆出來的模組抽象度不夠、對外界要求的參數太多,那 Controller 裡關於收集參數的程式碼就會很多。若一部分參數收集邏輯能由模組自己完成,也能幫 Controller 減輕負擔;否則就感覺拆得不夠乾淨。

如果拆分粒度太小,Controller 完成任務時的調度程式碼要寫很多,也不太好。導致粒度小的首要因素是業務本身比較複雜。拆分粒度小並不是不好,能大就大一點;如果小了,那也沒問題,針對這種情況可以採用 Strategy 模式。

舉個實際例子,來自我朋友在做聊天應用的訊息發送模組。當訊息是文字時直接發送;當訊息是圖片時,需要先向伺服器申請上傳資源、取得資源 ID,再上傳圖片,拿到圖片 URL 後,帶著 URL 把訊息發出去。

這時我們拆模組可以拆成:資料發送(A 模組)、上傳資源申請(B 模組)、內容上傳(C 模組)。發送文字訊息,Controller 調度 A 就好;發送圖片訊息,Controller 調度 B → C → A。假設未來還有上傳其他類型訊息的任務,又依賴 D/E/F 模組,那這事就很蛋疼:邏輯複雜了,Controller 要區分的情況多了,Controller 就膨脹了。

怎麼處理?採用 Strategy 模式。我們再分析一下:Controller 要完成任務,初始條件是什麼?它擁有這條訊息的所有資料,也知道訊息類型。它最終需要什麼?訊息發送的結果:成功或失敗。

也就是:Controller 只要把訊息丟給 MessageSender,讓 MessageSender 去做,做完告訴 Controller 就好。那 MessageSender 內部怎麼調度?它可以有一個 StrategyList,存放表達各種邏輯的 Block 或 Invocation(Target-Action)。先定義一個 Enum,規定每種任務所需的調度邏輯:

typedef NS_ENUM(NSUInteger, MessageSendStrategy) {
    MessageSendStrategyText = 0,
    MessageSendStrategyImage = 1,
    MessageSendStrategyVoice = 2,
    MessageSendStrategyVideo = 3
};

然後 MessageSender 裡的 StrategyList 是這樣:

@property (nonatomic, strong) NSArray *strategyList;

self.strategyList = @[TextSenderInvocation,
                      ImageSenderInvocation,
                      VoiceSenderInvocation,
                      VideoSenderInvocation];

// 對外提供這個介面,同時有一個 delegate 用來回調
- (void)sendMessage:(BaseMessage *)message withStrategy:(MessageSendStrategy)strategy;

@property (nonatomic, weak) id<MessageSenderDelegate> delegate;

@protocol MessageSenderDelegate <NSObject>
@required
- (void)messageSender:(MessageSender *)messageSender
     didSuccessSendMessage:(BaseMessage *)message
                  strategy:(MessageSendStrategy)strategy;

- (void)messageSender:(MessageSender *)messageSender
       didFailSendMessage:(BaseMessage *)message
                 strategy:(MessageSendStrategy)strategy
                    error:(NSError *)error;
@end

Controller 裡這樣用:

[self.messageSender sendMessage:message withStrategy:MessageSendStrategyText];

MessageSender 裡是這樣:

[self.strategyList[strategy] invoke];

而在某個 Invocation 裡面,就是這樣:

[A invoke];
[B invoke];
[C invoke];

這樣就好啦。即便拆分粒度因為客觀原因無法細化,也能把複雜的判斷邏輯與調度邏輯從 Controller 中抽出來,真正為 Controller 減負。總之能大粒度就盡量大粒度,實在做不到,就用 Strategy 把它 hold 住。

設計心法

針對 View 層的架構,不光是看重如何合理拆分 MVC 來為 UIViewController 減負,也要照顧業務方的使用成本。最好的情況是業務方什麼都不知道,把程式碼放進去就能跑,還能獲得框架提供的種種功能。

比如天安門廣場上的觀眾看台,就是我認為最好的設計,因為沒人會注意到它。

第一心法:盡可能減少繼承層級,涉及蘋果原生物件的盡量不要繼承。繼承是罪惡,盡量不要繼承。就我目前了解的情況,除了安居客的 Pad App 沒有在框架級針對 UIViewController 做繼承設計以外,其他公司或多或少都對 UIViewController 有繼承,包括安居客 iPhone app(那時我已經無能為力,可見 View 架構在一開始就設計好有多麼重要)。甚至有的還對 UITableView 有繼承,這是多麼令人髮指、多麼慘絕人寰、多麼喪心病狂的事情啊。

雖然有些情況我們不得不從蘋果原生物件繼承(比如 UITableViewCell),但我還是建議盡量不要透過繼承來給原生物件添加功能。前面提到的 Aspects 方案與 Category 方案都能用:用 Aspect + load 實現重載函數,用 Category 實現添加函數,當然耍點手段用 Category 添加 property 也沒問題。這些方案已經覆蓋了繼承的全部功能,而且非常好維護,對業務方也更透明,何樂而不為。

不用繼承在思路上不會那麼直觀,但好處足以抵得上壞處。順便我要給 Category 正一下名:業界對 Category 的態度比較曖昧,在多種場合都宣揚過盡可能不要使用 Category。它們說的都有一定道理,但我認為 Category 是蘋果提供的最好的「以組合代替繼承」方案,只是它對架構師的設計能力要求也很高,請合理使用。而且蘋果自己也在很多場合使用 Category,把一個原本可能很大的物件依不同場景拆成不同 Category,从而提高可維護性。

不使用繼承放到 iOS 架構來看,還能再多兩個好處:一是業務方做業務開發或做 Demo 時,可以脫離 App 環境,或花更少時間搭建環境;二是對業務方來說功能更透明,也更符合開發時的第一直覺。

第二心法:做好程式碼規範,規定好程式碼在檔案中的佈局,尤其是 ViewController。這主要是為了提高可維護性。在一個檔案非常大的物件中,尤其要限制好不同類型程式碼的佈局。寫 ViewController 時,我給團隊定的規範是:先是 life cycle(viewDidLoad 之類都在這裡),然後是要實作的各種 Delegate,再下面是 event response(Button 或 GestureRecognizer 的都在這裡),最後是 private method。一般情況下,如果做好拆分,private method 那一段是沒有方法的。後來隨著時間推移,我發現開頭放 getter 和 setter 太影響閱讀,所以改成全放在 ViewController 的最後。

第三心法:能不放在 Controller 做的事就盡量不要放在 Controller 裡。Controller 會變龐大的原因有兩個:一是它承載業務邏輯,這是 MVC 對 Controller 的定義,天經地義;二是在 MVC 中 Model 與 View 的定義都非常明確,很少有人會把屬於 M 或 V 的東西放到其他地方,於是除了 M 和 V 以外,還會剩下很多模稜兩可的東西——概念上都算 Controller,而且因為 M 和 V 定義得那麼明確,直覺上這些東西放進 M 或 V 都不合適,於是就往 Controller 裡塞。

正是這兩方面導致了 Controller 膨脹。仔細想想:Model 膨脹和 View 膨脹,要拆其實相對容易;Controller 膨脹之後,拆分就顯得艱難無比。所以如果能在一開始就盡量把「能不放在 Controller 做的事」放到別處,就能讓這部分未來可能被拆分的程式碼遠離業務邏輯。我們要稍微轉變思路:模稜兩可的模組,就不要塞到 Controller 去了,塞到 V 或 M 或其他任何地方,都比塞進 Controller 好,便於將來拆分。

所以關於前面按下不表的胖 Model 與瘦 Model 之爭,我的態度是更傾向胖 Model。客觀地說,業務膨脹之後程式碼規模少不了,不管你技術再好、經驗再豐富,程式碼量最多只能優化,該膨脹還是要膨脹;而且優化之後程式碼往往比較難看,使用各種奇技淫巧也是有代價的。針對程式碼量優化的結果,往往要麼犧牲可讀性,要麼犧牲可移植性。Every magic always needs a pay, you have to make a trade-off.

既然膨脹出來的程式碼遲早要拆分,那不如放進 Model,這樣未來拆分胖 Model 會比拆分胖 Controller 容易得多。我還在安居客時,安居客 Pad app 承載最複雜業務的 ViewController 才不到 600 行,其他多數 Controller 都在 300–400 行之間,這為後面接手的人降低了非常多上手難度與維護複雜度,拆出來的東西也都能直接遷移給 iPhone app 使用。現在看天貓的 ViewController,動不動就幾千行,看不了多久頭就暈了;問了一下,大家都表示很習慣這樣的程式碼長度,攤手。

第四心法:架構師是為業務工程師服務的,而不是去使喚業務工程師的。架構師在公司的職級與地位往往高於業務工程師,技術實力與經驗往往也更高,所以你值得在公司裡獲得較高的地位。但在公司裡的地位高,不代表在軟體工程裡面的角色地位也高。架構師是要為業務工程師服務的,是他們使喚你,而不是你使喚他們。制定規範一方面約束業務程式碼,但更重要的是:這其實是利用你的能力幫業務工程師避免他無法預見的危機。所以地位高有好處——畢竟夏蟲不可語冰,有時不一定解釋得通,因此高地位隨之而來的是更強的說服力。但在軟體工程裡,一定要保持謙卑,一定要多為業務工程師考慮。

不懂這個道理的架構師,設計出來的東西往往複雜難用,因為他只願意做核心的部分,周邊不想做的都期望交給業務工程師,甚至有時只做了個 Demo 就交出去,業務工程師變成給他打工的。而懂這個道理的架構師,設計出來的東西會非常好用,業務方只需丟很少的參數然後拿結果,這樣的架構才叫好架構。

舉個保存圖片到本地的例子:一種做法是提供 - (NSString *)saveImageWithData:(NSData *)imageData,另一種是 - (NSString *)saveImage:(UIImage *)image。後者更好,原因自己想。

你的態度越謙卑,就越能設計出好的架構,這是我設計心法裡的最後一條,也是最重要的一條。即使你現在技術實力不是業界大牛級別,但只要保持這個心態去做架構、做設計,就已經是合格的架構師了,要成為業界大牛也會非常快。

小總結

針對 View 層的架構設計,主要做好三點:程式碼規範、架構模式、工具集。

程式碼規範對 View 層意義重大,畢竟 View 層非常重業務,如果程式碼佈局混亂,後來者很難接手,也很難維護。

架構模式如何選擇,完全取決於業務複雜度:業務相當複雜可以用 VIPER,相對簡單就 MVC 稍微改改。每一種已成定式的架構模式不見得都適合各自公司的業務,需要架構師依情況做一些拆分或改變。拆分一般不會出問題;改變的時候,只要別把 MVC 三個角色搞混就好——M 該做啥做啥,C 該做啥做啥,V 該做啥做啥。我認為最重要的還是後面的心法,模式只是招式,熟悉心法才能大巧不工。

View 層的工具集主要集中在如何對 View 進行佈局,以及一些特定的 View(比如帶搜尋提示的搜尋框)。本文只提到佈局工具集,其他的更取決於各自公司的業務,自行實作或使用 CocoaPods 裡現成的都不難。

對於小規模或中等規模的 iOS 團隊,做好以上三點就足夠了。在大規模團隊中,還有一個額外問題要考慮:跨業務頁面調用方案的設計。

跨業務頁面調用方案的設計

跨業務頁面調用是指:當一個 App 中存在 A 業務、B 業務等多個業務時,B 業務可能需要展示 A 業務的某個頁面,反之亦然。在小規模 App 中,直接 import 其他業務的某個 ViewController 然後 push 或 present,不會產生特別大的問題;但 App 規模非常大、涉及業務數量非常多時,再這麼直接 import 就會出問題。

可以看出,跨業務的頁面調用在多業務組成的 App 中會導致橫向依賴。這樣的橫向依賴若不設法解決,會導致:

  1. 當一個需求需要多業務合作開發時,直接依賴會使某些依賴鏈上端的業務工程師前期空轉,下端的工程師任務繁重,整個需求的完成速度變慢——影響的是團隊開發迭代速度。

  2. 當要開闢一個新業務時,如果已有業務間存在直接依賴,而新業務又依賴某個舊業務,就會導致新業務的開發環境搭建困難,因為必須把所有相關業務都塞進開發環境才能開發——影響的是新業務的響應速度。

  3. 當某個被其他業務依賴的頁面有所修改時(比如改名),牽涉的修改面會特別大——影響的是任務量與維護成本雙雙上升。

當然,App 規模特別小時這三點的影響也會特別小。但在阿里這樣大規模的團隊中,像天貓/淘寶這種量級的 App,一旦遇上其中任何一件事,就特別坑爹。

那該怎麼處理?讓依賴關係下沉。

怎麼下沉?引入 Mediator 模式。所謂引入 Mediator 來讓依賴下沉,實質上就是每次呼叫頁面時,透過一個中間人去召喚另一個頁面,這樣每個業務只需依賴這個中間人;而中間人的角色可以放在業務層的下面一層——這就是依賴關係下沉。

當 A 業務需要調用 B 業務的某個頁面時,把請求交給 Mediator,由 Mediator 透過某種手段取得 B 業務頁面的實例,交還給 A。實作這個機制時有兩個問題要解決:

  1. 設計一套通用的請求機制,且必須與業務剝離,使不同業務的頁面請求都能被 Mediator 處理。

  2. 設計 Mediator 如何依請求取得其他業務的頁面——Mediator 需要知道怎麼處理請求、上哪兒找到需要的頁面。

這看起來非常像 Web 開發時的 URL 機制:發送一個 Get 或 Post 請求,CGI 調用腳本把請求分發給某個 Controller 下的某個 Action,然後把 HTML 字串返回瀏覽器解析。蘋果本身也實作了一套跨 App 調用機制,同樣基於 URL 機制運轉,只不過它想解決的是跨 App 的資料交流與頁面調用,而我們想解決的是降低各業務的耦合度。

不過我們不能直接使用蘋果原生的這套機制,因為它無法回傳物件實例;而我們希望能拿到物件實例,這樣不光能做跨業務頁面調用,也能做跨業務的功能調用。另外,我們又希望自己的 Mediator 能與蘋果原生的跨 App 調用相容,這樣又能幫業務方省掉一部分開發量。

就我目前知道的情況,AutoCad 旗下某款 iOS 應用(時間有點久,不記得是哪款了,如果你是 AutoCad 的 iOS 開發,可以在評論區補充)就採用了這種頁面調用方式。天貓裡面目前也在使用這套機制,只是這一塊由於歷史原因存在新老版本混用的情況,因此暫時還沒能很好地發揮應有的作用。

嗯,想跟我要 Demo 的同學,我可以很大方地告訴你:沒有。不過我打算抽時間寫一個出來,現在除了已經想好名字叫 Summon 以外,其他什麼都沒做,哈哈。

關於 Getter 和 Setter?

我比較習慣把一個物件的「私有」屬性寫在 extension 裡,然後這些屬性的初始化全部放在 getter 裡做;在 init 和 dealloc 之外,不會出現任何類似 _property 的寫法。就是這樣:

@interface CustomObject ()

@property (nonatomic, strong) UILabel *label;

@end

@implementation CustomObject

#pragma mark - life cycle

- (void)viewDidLoad {
    [super viewDidLoad];
    [self.view addSubview:self.label];
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    self.label.frame = CGRectMake(1, 2, 3, 4);
}

#pragma mark - getters and setters

- (UILabel *)label {
    if (_label == nil) {
        _label = [[UILabel alloc] init];
        _label.text = @"1234";
        _label.font = [UIFont systemFontOfSize:12];
        // ...
    }
    return _label;
}

@end

唐巧說他喜歡的做法是用 _property,然後透過 [self setupProperty] 這種方式做初始化。從上面的程式碼來看,就是要在 viewDidLoad 裡多調一個 setup 方法;而我推薦的方法是不用多調 setup,直接走 getter。

怎麼說呢,其實兩種做法都能完成需求。但從另一個角度看,蘋果之所以讓 [self getProperty] 與 self.property 可以互相通用,這種設計已經很明顯地表達了蘋果的傾向:希望每個 property 都透過 getter 方法來獲得。

早在 2003 年,Allen Holub 就發了篇文章《Why getter and setter methods are evil》,自此業界產生了各種爭議。雖然是從 Java 開始說的,但發展到後面各種語言都參與了進來;現在討論少了,但依舊屬於沒有定論的狀態。setter 的情況比較複雜,也不是我這節的重點,我這裡主要說 getter。從 objc 的設計來看,蘋果的設計者更傾向於 getter is not evil。

認為 getter is evil 的原因非常多,隨著爭論進行,大家慢慢聚焦到一個原因:Getter 和 Setter 提供了一個能讓外部修改物件內部資料的方式,這是 evil 的;正常情況下,一個物件自己私有的變數應該只有自己關心。

回到 iOS 領域,objc 同樣面臨這個問題,甚至更嚴重:objc 並沒有像 Java 那麼嚴格的私有概念。但在實際工作中,我們不太會去操作標頭檔裡沒有的變數,這是從規範上就被禁止的。

認為 getter is not evil 的原因也可以聚焦到一個:高度的封裝性。getter 事實上是工廠方法,有了它之後,業務邏輯可以更專注於調用,而不必擔心當前變數是否可用。想一下:假設一個 ViewController 有 20 個 subview 要加入 view,這 20 個 subview 的初始化程式碼是肯定逃不掉的,放在哪裡比較好?放在哪裡都比放在 addSubview 的地方好,我個人認為最好的地方還是 getter——結合單例模式之後,程式碼會非常整齊,生產的地方與使用的地方得到了很好的區分。

所以放到 iOS 來說,我還是覺得使用 getter 會比較好,因為 evil 的地方在 iOS 這邊基本都避免了,not evil 的地方都能享受到,還不錯。

總結

要做一個 View 層架構,主要從三方面入手:

  1. 制定良好的規範

  2. 選擇合適的模式(MVC、MVCS、MVVM、VIPER)

  3. 依業務情況針對 ViewController 做好拆分,並提供一些小工具方便開發

當然你還會遇到其他很多問題,這時可以參考本文提出的心法;在跨業務頁面調用方案的設計中,你也能看到我一些心法的影子。

對於 iOS 客戶端來說,它並不像 Python、PHP 那樣有那麼多非官方通用框架。客觀原因在於蘋果已經為我們做了非常多的事情。在蘋果已做這麼多的基礎上,架構師做 View 層方案時,最好還是盡量遵守蘋果既有的規範與設計思想,然後依自己過去開發 iOS 的經驗,盡可能為業務方在開發業務時減負、提高業務程式碼的可維護性——這就是 View 層架構方案的最大目標。

補充一:關於 AOP

AOP(Aspect Oriented Programming),面向切片程式設計,也是「面向 XX 程式設計」系列術語之一,但它跟我們熟知的物件導向程式設計沒什麼關係。

什麼是切片?程式要完成一件事,一定有一些步驟,1、2、3、4 這樣。這裡分解出的每一個步驟,我們可以認為是一個切片。

什麼是面向切片程式設計?你針對每一個切片的間隙塞一些程式碼進去,讓程式在正常執行 1、2、3、4 步的間隙跑到你塞進去的程式碼,那你寫這些程式碼就是面向切片程式設計。

為什麼會出現 AOP?要在每個步驟中間做自己的事,不用 AOP 也一樣能達到目的,直接往步驟之間塞程式碼就好。但現實往往很複雜,直接塞的主要問題在於:塞進去的程式碼很可能是跟原業務無關的程式碼,在同一份檔案裡摻雜多種業務,這會帶來業務間耦合。為了降低這種耦合度,我們引入了 AOP。

如何實現 AOP?AOP 一般需要一個攔截器,在每個切片執行之前與之後(或任何你希望的地方),透過調用攔截器的方法把這個 jointpoint 扔到外面,在外面取得 jointpoint 時執行相應程式碼。

在 iOS 領域,Objective-C 的 runtime 提供了一系列方法,能讓我們攔截某個方法的調用來實現攔截器,這種手段稱為 Method Swizzling。Aspects 就是用這個手段實現了針對某個類與某個實例中方法的攔截。

另外,也可以用 protocol 的方式實現攔截器:

@protocol RTAPIManagerInterceptor <NSObject>
@optional
- (void)manager:(RTAPIBaseManager *)manager beforePerformSuccessWithResponse:(AIFURLResponse *)response;
- (void)manager:(RTAPIBaseManager *)manager afterPerformSuccessWithResponse:(AIFURLResponse *)response;
- (void)manager:(RTAPIBaseManager *)manager beforePerformFailWithResponse:(AIFURLResponse *)response;
- (void)manager:(RTAPIBaseManager *)manager afterPerformFailWithResponse:(AIFURLResponse *)response;
- (BOOL)manager:(RTAPIBaseManager *)manager shouldCallAPIWithParams:(NSDictionary *)params;
- (void)manager:(RTAPIBaseManager *)manager afterCallingAPIWithParams:(NSDictionary *)params;
@end

@interface RTAPIBaseManager : NSObject
@property (nonatomic, weak) id<RTAPIManagerInterceptor> interceptor;
@end

這麼做對比 Method Swizzling 有個額外好處:你可以透過攔截器給實現者提供更多資訊,便於外部實現更了解當前切片的情況;而且你能更精細地劃分切片。Method Swizzling 的切片粒度是函式粒度,自己實作的攔截器可以比函式更小、更精細。缺點是:你得自己在每個插入點把調用攔截器的程式碼寫上(笑)。用 Aspects(本質上就是 Method Swizzling)來實現 AOP,就能輕鬆一些。

補充二:Constraint 該寫在哪?

文章發佈後,很多人針對勘誤 1 有很多看法,以至於我覺得有必要在這裡做一份補充。過程很多很複雜,這篇文章也已經很長了,我就直接說結果。

蘋果在文件中指出,updateViewConstraints 是用來做 add constraints 的地方。但有回答者說 updateViewConstraints 並不適合做添加 Constraints 的事。

綜合我自己與評論區關心這個問題的各位的測試與各種文件,我現在覺得還是在 viewDidLoad 裡開一個 layoutPageSubviews 方法,在其中建立 Constraints 並添加,會比較好:

- (void)viewDidLoad {
    [super viewDidLoad];
    [self.view addSubview:self.firstView];
    [self.view addSubview:self.secondView];
    [self.view addSubview:self.thirdView];
    [self layoutPageSubviews];
}

- (void)layoutPageSubviews {
    [self.view addConstraints:xxxConstraints];
    [self.view addConstraints:yyyConstraints];
    [self.view addConstraints:zzzConstraints];
}

最後要感謝評論區各位關心這個問題、提出自己意見,甚至親自測試後告訴我結果的兄弟們:@fly2never、@Wythe、@wtlucky、@lcddhr、@李新星、@Meigan Fang、@匿名、@Xiao Moch。

這個做法是目前我自己覺得比較合適的,當然也歡迎其他同學繼續提出看法,我們來討論。

勘誤

我的前同事 @ddaajing 看完這篇文章後,給我提出了以下兩個勘誤,以及很多行文上的問題,在此對他表示非常感謝:

勘誤 1:其實在 viewWillAppear 這裡改變 UI 元素不是很可靠,Auto Layout 發生在 viewWillAppear 之後。嚴格來說這裡通常不做視圖位置的修改,而是用來更新 Form 資料。改變位置可以放在 viewWillLayoutSubview 或 didLayoutSubview 裡,而且在 viewDidLayoutSubview 確定 UI 位置關係之後設定 Auto Layout 比較穩妥。另外,viewWillAppear 在每次頁面即將顯示都會調用;viewWillLayoutSubviews 雖然在 lifeCycle 中的調用順序在 viewWillAppear 之後,但只有在頁面元素需要調整時才會調用,避免了 Constraints 的重複添加。

勘誤 2:MVVM 要有 ViewModel,以及 ReactiveCocoa 帶來的信號通知效果,在 ReactiveCocoa 裡就是 RAC 等相關巨集來實現的。另外,使用 ReactiveCocoa 能夠比較優雅地實現 MVVM 模式,就是因為有 RAC 等相關巨集的存在。就像它的名字一樣——Reactive,響應式,這也是區分 MVVM 的 VM 與 MVC 的 C、MVP 的 P 的一個重要面向。

本文遵守 CC-BY。請保持轉載後文章內容的完整,以及文章出處。本人保留所有版權相關權利。

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