本文原文请见：http://www.raywenderlich.com/46988/ios-design-patterns.
由 @krq_tiger（ http://weibo.com/xmuzyq ）翻译，如果你发现有什么错误，请与我联系谢谢。
适配器（Adapter）模式
适配器可以让一些接口不兼容的类一起工作。它包装一个对象然后暴漏一个标准的交互接口。
如果你熟悉适配器设计模式，苹果通过一个稍微不同的方式来实现它 - 苹果使用了协议的方式来实现。你可能已经熟悉 UITableViewDelegate, UIScrollViewDelegate, NSCoding 和 NSCopying 协议。举个例子，使用 NSCopying 协议，任何类都可以提供一个标准的 copy 方法。
如何使用适配器模式
前面提到的水平滚动视图如下图所示：
为了开始实现它，在工程导航视图中右键点击 View 组，选择 New File... 使用 iOS\Cocoa Touch\Objective-C class 模板创建一个类。命名这个新类为 HorizontalScroller, 并且设置它是 UIView 的子类。
打开 HorizontalScroller.h 文件，在 @end 行后面插入如下代码：
1. @protocolHorizontalScrollerDelegate <NSObject>
2. // methods declaration goes in here
3. @end
上面的代码定义了一个名为 HorizontalScrollerDelegate 的协议，它采用 Objective-C 类继承父类的方式继承自 NSObject 协议。去遵循 NSObject 协议或者遵循一个本身实现了 NSObject 协议的类 是一条最佳实践，这使得你可以给 HorizontalScroller 的委托发送 NSObject 定义的消息。你不久会意识到为什么这样做是重要的。
在 @protocol 和 @end 之间，你定义了委托必须实现以及可选的方法。所以增加下面的方法：
1. @required
2.
3. // ask the delegate how many views he wants to present inside the horizontal scroller
4.
5. - (NSInteger)numberOfViewsForHorizontalScroller:(HorizontalScroller*)scroller;
6.
7.
8.
9. // ask the delegate to return the view that should appear at <index>
10.
11. - (UIView*)horizontalScroller:(HorizontalScroller*)scroller viewAtIndex:(int)index;
12.
13.
14.
15. // inform the delegate what the view at <index> has been clicked
16.
17. - (void)horizontalScroller:(HorizontalScroller*)scroller clickedViewAtIndex:(int)index;
18.
19.
20.
21. @optional
22.
23. // ask the delegate for the index of the initial view to display. this method is optional
24.
25. // and defaults to 0
26.
27. - (NSInteger)initialViewIndexForHorizontalScroller:(HorizontalScroller*)scroller;
这里你既有必需的方法也有可选方法。必需的方法要求委托必须实现它，因为它提供一些必需的数据。在这里，必需的是视图的数量，指定索引位置的视图，以及用户点击视图后的行为，可选的方法是初始化视图；如果它没有实现，那么HorizontalScroller将缺省用第一个索引的视图。
下一步，你需要在 HorizontalScroller 类中引用新建的委托。但是委托的定义是在类的定义之后的，所以在类中它是不可见的，怎么办呢？
解决方案就是前置声明委托协议以便编译器（和 Xcode ）知道协议的存在。如何做？你只需要在 @interface 行前面增加下面的代码即可：
@protocol HorizontalScrollerDelegate;
继续在 HorizontalScroller.h 文件中，在 @interface 和 @end 之间增加如下的语句：
1. @property (weak) id<HorizontalScrollerDelegate> delegate;
2. - (void)reload;
这里你声明属性为 weak. 这样做是为了防止循环引用。如果一个类强引用它的委托，它的委托也强引用那个类，那么你的 app 将会出现内存泄露，因为任何一个类都不能释放调分配给另一个类的内存。
id 意味着 delegate 属性可以用任何遵从 HorizontalScrollerDelegate 的类赋值，这样可以保障一定的类型安全。
reload 方法在 UITableView 的 reloadData 方法之后被调用，它重新加载所有的数据去构建水平滚动视图。
用如下的代码取代 HorizontalScroller.m 的内容：
1. #import "HorizontalScroller.h"
2.
3.
4.
5. // 1
6.
7. #define VIEW_PADDING 10
8.
9. #define VIEW_DIMENSIONS 100
10.
11. #define VIEWS_OFFSET 100
12.
13.
14.
15. // 2
16.
17. @interfaceHorizontalScroller () <UIScrollViewDelegate>
18.
19. @end
20.
21.
22. // 3
23.
24. @implementationHorizontalScroller
25.
26. {
27.
28. UIScrollView *scroller;
29.
30. }
31.
32.
33.
34. @end
让我们来对上面每个注释块的内容进行一一分析：
1. 定义了一系列的常量以方便在设计的时候修改视图的布局。水平滚动视图中的每个子视图都将是 100*100,10 点的边框的矩形 .
2. HorizontalScroller 遵循 UIScrollViewDelegate 协议。因为 HorizontalScroller 使用 UIScrollerView 去滚动专辑封面，所以它需要用户停止滚动类似的事件
3. 创建了 UIScrollerView 的实例。
下一步你需要实现初始化器。增加下面的代码：
1. - (id)initWithFrame:(CGRect)frame
2.
3. {
4.
5. self = [super initWithFrame:frame];
6.
7. if (self)
8.
9. {
10.
11. 0, 0, frame.size.width, frame.size.height)];
12.
13. scroller.delegate = self;
14.
15. [self addSubview:scroller];
16.
17. UITapGestureRecognizer *tapRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(scrollerTapped:)];
18.
19. [scroller addGestureRecognizer:tapRecognizer];
20.
21. }
22.
23. return self;
24.
25. }
滚动视图完全充满了 HorizontalScroller 。 UITapGestureRecognizer 检测滚动视图的触摸事件，它将检测专辑封面是否被点击了。如果专辑封面被点击了，它会通知 HorizontalScroller 的委托。
现在，增加下面的代码：
1. - (void)scrollerTapped:(UITapGestureRecognizer*)gesture
2.
3. {
4.
5. CGPoint location = [gesture locationInView:gesture.view];
6.
7. 't use an enumerator here, because we don't want to enumerate over ALL of the UIScrollView subviews.
8.
9. // we want to enumerate only the subviews that we added
10.
11. 0; index<[self.delegate numberOfViewsForHorizontalScroller:self]; index++)
12.
13. {
14.
15. UIView *view = scroller.subviews[index];
16.
17. if (CGRectContainsPoint(view.frame, location))
18.
19. {
20.
21. [self.delegate horizontalScroller:self clickedViewAtIndex:index];
22.
23. 2 + view.frame.size.width/2, 0) animated:YES];
24.
25. break;
26.
27. }
28.
29. }
30.
31. }
Gesture 对象被当做参数传递，让你通过 locationInView ：导出点击的位置。
接下来，你调用了 numberOfViewsForHorizontalScroller: 委托方法， HorizontalScroller 实例除了知道它可以安全的发送这个消息给委托之外，它不知道其它关于委托的信息，因为委托必须遵循 HorizontalScrollerDelegate 协议。
对于滚动视图中的每个子视图，通过 CGRectContainsPoint 方法发现被点击的视图。当你已经找到了被点击的视图，给委托发送 horizontalScroller:clickedViewAtIndex: 消息。在退出循环之前，将被点击的视图放置到滚动视图的中间。
现在增加下面的代码去重新加载滚动视图：
1. - (void)reload
2.
3. {
4.
5. 1
6.
7. if (self.delegate == nil) return;
8.
9.
10.
11. 2
12.
13. [scroller.subviews enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
14.
15. [obj removeFromSuperview];
16.
17. }];
18.
19.
20.
21. 3
22.
23. CGFloat xValue = VIEWS_OFFSET;
24.
25. 0; i<[self.delegate numberOfViewsForHorizontalScroller:self]; i++)
26.
27. {
28.
29. 4
30.
31. xValue += VIEW_PADDING;
32.
33. UIView *view = [self.delegate horizontalScroller:self viewAtIndex:i];
34.
35. view.frame = CGRectMake(xValue, VIEW_PADDING, VIEW_DIMENSIONS, VIEW_DIMENSIONS);
36.
37. [scroller addSubview:view];
38.
39. xValue += VIEW_DIMENSIONS+VIEW_PADDING;
40.
41. }
42.
43.
44.
45. 5
46.
47. [scroller setContentSize:CGSizeMake(xValue+VIEWS_OFFSET, self.frame.size.height)];
48.
49.
50.
51. 6
52.
53. if ([self.delegate respondsToSelector:@selector(initialViewIndexForHorizontalScroller:)])
54.
55. {
56.
57. int initialView = [self.delegate initialViewIndexForHorizontalScroller:self];
58.
59. 2*VIEW_PADDING)), 0) animated:YES];
60.
61. }
62.
63. }
我们来一步步的分析代码中有注释的地方：
1. 如果没有委托，那么不需要做任何事情，仅仅返回即可。
2. 移除之前添加到滚动视图的子视图
3. 所有的视图的位置从给定的偏移量开始。当前的偏移量是 100 ，它可以通过改变文件头部的 #DEFINE 来很容易的调整。
4. HorizontalScroller 每次从委托请求视图对象，并且根据预先设置的边框来水平的放置这些视图。
5. 一旦所有视图都设置好了以后，设置 UIScrollerView 的内容偏移（ contentOffset ）以便用户可以滚动的查看所有的专辑封面。
6. HorizontalScroller 检测是否委托实现了 initialViewIndexForHorizontalScroller: 方法，这个检测是需要的，因为这个方法是可选的。 如果委托没有实现这个方法， 0 就是缺省值。最后设置滚动视图为协议规定的初始化视图的中间。
当数据已经发生改变的时候，你要执行 reload 方法。当增加 HorizontalScroller 到另外一个视图的时候，你也需要调用 reload 方法。增加下面的代码来实现后面一种场景：
1. - (void)didMoveToSuperview
2. {
3.
4. [self reload];
5.
6. }
didMoveToSuperview 方法会在视图被增加到另外一个视图作为子视图的时候调用，这正式重新加载滚动视图的最佳时机。
最后我们需要确保所有你正在浏览的专辑数据总是在滚动视图的中间。为了这样做，当用户的手指拖动滚动视图的时候，你将需要做一些计算。
再一次在 HorizontalScroller.m 中增加如下方法：
1. - (void)centerCurrentView
2.
3. {
4.
5. 2) + VIEW_PADDING;
6.
7. 2*VIEW_PADDING));
8.
9. 2*VIEW_PADDING));
10.
11. 0) animated:YES];
12.
13. [self.delegate horizontalScroller:self clickedViewAtIndex:viewIndex];
14.
15. }
为了计算当前视图到中间的距离，上面的代码考虑了滚动视图当前的偏移量，视图的尺寸以及边框。最后一行代码是重要的，一当子视图被置中，你将需要将这种变化通知委托。
为了检测用户在滚动视图中的滚动，你必需增加如下的 UIScrollerViewDelegate 方法：
1. - (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
2.
3. {
4.
5. if (!decelerate)
6.
7. {
8.
9. [self centerCurrentView];
10.
11. }
12.
13. }
14.
15.
16.
17. - (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
18.
19. {
20.
21. [self centerCurrentView];
22.
23. }
scrollViewDidEndDragging:willDecelerate: 方法在用户完成拖动的时候通知委托。如果视图还没有完全的停止，那么 decelerate 参数为 true. 当滚动完全停止的时候，系统将会调用 scrollViewDidEndDecelerating. 在两种情况下，我们都需要调用我们新增的方法去置中当前的视图，因为当前的视图在用户拖动以后可能已经发生了变化。
你的 HorizontalScroller 现在已经可以使用了。浏览你刚刚写的代码，没有涉及到任何与 Album 或 AlbumView 类的信息。这个相对的棒，因为这意味着这个新的滚动视图是完全的独立和可复用的。
构建的工程确保每个资源可以正确编译。
现在 HorizontalScroller 完整了，是时候去在 app 使用它了。打开 ViewController.m 增加下面的导入语句：
1. #import "HorizontalScroller.h"
2. #import "AlbumView.h"
增加 HorizontalScrollerDelegate 协议为 ViewController 遵循的协议：
1. @interfaceViewController ()<UITableViewDataSource, UITableViewDelegate, HorizontalScrollerDelegate>
在类的扩展中增加下面的实例变量：
HorizontalScroller *scroller;
现在你可以实现委托方法；你可能会感到惊讶，因为只需要几行代码就可以实现大量的功能啦。
在 ViewController.m 中增加下面的代码：
1. #pragma mark - HorizontalScrollerDelegate methods
2.
3. - (void)horizontalScroller:(HorizontalScroller *)scroller clickedViewAtIndex:(int)index
4. {
5. currentAlbumIndex = index;
6.
7. [self showDataForAlbumAtIndex:index];
8.
9. }
它设置保存当前专辑数据的变量，然后调用 showDataForAlbumAtIndex: 方法显示专辑数据。
注意 : 在 #pragma mark 指令后面写方法代码是一种通用的实践。 c 编译器会忽略调这些行，但是如果你通过 Xcode 的弹出框的时候，你将看到这些指令会帮你把代码组织成有独立和粗体标题的组。这可以帮你使得你的代码更方便在 Xcode 中导航。
接下来，增加下面的代码：
1. - (NSInteger)numberOfViewsForHorizontalScroller:(HorizontalScroller*)scroller
2. {
3. return allAlbums.count;
4. }
正如你意识到的，这个是返回滚动视图所有子视图数量的协议方法。因为滚动视图要显示所有专辑的封面，这个数量就是专辑记录的数量。
现在，增加下面的代码：
1. - (UIView*)horizontalScroller:(HorizontalScroller*)scroller viewAtIndex:(int)index
2. {
3.
4. Album *album = allAlbums[index];
5.
6. 0, 0, 100, 100) albumCover:album.coverUrl];
7.
8. }
这里你创建了一个新的AlbumView，并且将它传递给HorizontalScroller。
够了，仅仅三个简短的方法就可以显示一个漂亮的水平滚动视图。
是的，你任然需要创建滚动视图，并且把它增加到你的主视图中，但是在这样做之前，你增加下面的方法先：
1. - (void)reloadScroller
2.
3. {
4.
5. allAlbums = [[LibraryAPI sharedInstance] getAlbums];
6.
7. 0) currentAlbumIndex = 0;
8.
9. 1;
10.
11. [scroller reload];
12.
13.
14.
15. [self showDataForAlbumAtIndex:currentAlbumIndex];
16.
17. }
这个方法通过 LibraryAPI 加载专辑数据，然后根据当前视图的索引设置当前显示的视图。如果当前的视图索引小于 0 ，意味着当前没有选定任何视图，此时可以选择第一个专辑来显示，否则下面一个专辑将会显示。
现在在 viewDidLoad 的 [self showDataForAlbumAtIndex:0] 之前增加下面的代码来初始化滚动视图：
1. scroller = [[HorizontalScroller alloc] initWithFrame:CGRectMake(0, 0, self.view.frame.size.width, 120)];
2.
3. scroller.backgroundColor = [UIColor colorWithRed:0.24f green:0.35f blue:0.49f alpha:1];
4.
5. scroller.delegate = self;
6.
7. [self.view addSubview:scroller];
8.
9.
10.
11. [self reloadScroller];
上 面的代码简单的创建了一个 HorizontalScroller 类的实例，设置它的背景色，委托，增加它到主视图，然后加载所有子视图去显示专辑数据。
注意 : 如果一个协议变得特别冗长，包含太多的方法。你应该考虑将它氛围更家细粒度的协议。 UITableViewDelegate 和 UITableViewDataSource 是一个好的例子。因为它们都是 UITableView 的协议。试着设计你的协议以便每个协议都关注特定的功能。
构建并运行你的 on 过程，查看一下你帅气十足的水平滚动视图吧：
对了，等等。水平滚动视图没问题，但是为什么没有显示封面呢？
是的，那就对了 - 你还没有实现下载封面的代码。为了实现这个功能，你需要去新增一个下载图片的方法。因为所有对服务的访问都通过 LibraryAPI, 那我们就可以在 LibraryAPI 中实现新的方法。然而我们首先需要虑一些事情：
1. AlbumView 不应该直接和 LibraryAPI 交互。你不想混淆显示逻辑和网络交互逻辑。
2. 同样的原因， LibraryAPI 也不应该知道 AlbumView 。
3. 一旦封面已经下载， LibraryAPI 需要通知 AlbumView ，因为 AlbumView 显示专辑封面。
听上去是不是挺糊涂的？不要灰心。你将学习如何使用观察者模式来实现它。
观察者（Observer）模式
在观察者模式中，一个对象任何状态的变更都会通知另外的对改变感兴趣的对象。这些对象之间不需要知道彼此的存在，这其实是一种松耦合的设计。当某个属性变化的时候，我们通常使用这个模式去通知其它对象。
此模式的通用实现中，观察者注册自己感兴趣的其它对象的状态变更事件。当状态发生变化的时候，所有的观察者都会得到通知。苹果的推送通知（ Push Notification ）就是一个此模式的例子。
如果你要遵从 MVC 模式的概念，你需要让模型对象和视图对象在不相互直接引用的情况下通信。这正是观察者模式的用武之地。
Cocoa 通过通知（ Notifications ）和 Key-Value Observing(KVO) 来实现观察者模式。
通知（Notifications）
不要和远程推送以及本地通知所混淆，通知是一种基于订阅 - 发布模式的模型，它让发布者可以给订阅者发送消息，并且发布者不需要对订阅者有任何的了解。
通知在苹果官方被大量的使用。举例来说，当键盘弹出或者隐藏的时候，系统会独立发送 UIKeyboardWillShowNotification / UIKeyboardWillHideNotification 通知。当你的应用进入后台运行的时候，系统会发送一个 UIApplicationDidEnterBackgroundNotification 通知。
注意 : 打开 UIApplication.h, 在文件的末尾，你将看到一个由系统发出的超过 20 个通知组成的列表。
如何使用通知（Notifications）
打开 AlbumView.m ，在 initWithFrame:albumCover:: 方法的 [self addSubview:indicator]; 语句之后加入如下代码：
1. [[NSNotificationCenterdefaultCenter] postNotificationName:@"BLDownloadImageNotification"
2. object:self
3. "imageView":coverImage, @"coverUrl":albumCover}];
这行代码通过 NSNotificationCenter 单例发送了一个通知。这个通知包含了 UIImageView 和需要下载的封面 URL ，这些是你下载任务所需要的所有信息。
在 LibraryAPI.m 文件 init 方法的 isOnline=NO 之后，增加如下的代码：
1. [[NSNotificationCenterdefaultCenter] addObserver:self selector:@selector(downloadImage:) name:@"BLDownloadImageNotification"
这个是观察者模式中两部分的另外一部分：观察者。每次 AlbumView 发送一个 BLDownloadImageNotification 通知，因为 LibraryAPI 已经注册为同样的通知的观察者，那么系统就会通知 LibraryAPI,LibraryAPI 又会调用 downloadImage: 来响应。
然而在你实现 downloadImage: 方法之前，你必须在你的对象销毁的时候，退订所有之前订阅的通知。如果你不能正确的退订的话，一个通知发送给一个已经销毁的对象会导致你的 app 崩溃。
在 Library.m 中增加下面的代码 :
1. - (void)dealloc
2. {
3. [[NSNotificationCenterdefaultCenter] removeObserver:self];
4.
5. }
当对象被销毁的时候，它将移除所有监听通知的观察者。
还有一件事情需要去做，将已经下载的封面图片本地存储起来是个不错的主意，这样可以避免每次都重新下载相同的封面。
打开 PersistencyManager.h 文件，增加下面两个方法原型：
1. - (void)saveImage:(UIImage*)image filename:(NSString*)filename;
2.
3. - (UIImage*)getImage:(NSString*)filename;
在 PersistencyManager.m 文件中，增加方法的实现：
1. - (void)saveImage:(UIImage*)image filename:(NSString*)filename
2.
3. {
4.
5. "/Documents/%@", filename];
6.
7. NSData *data = UIImagePNGRepresentation(image);
8.
9. [data writeToFile:filename atomically:YES];
10.
11. }
12.
13.
14.
15. - (UIImage*)getImage:(NSString*)filename
16.
17. {
18.
19. "/Documents/%@", filename];
20.
21. NSData *data = [NSDatadataWithContentsOfFile:filename];
22.
23. return [UIImage imageWithData:data];
24.
25. }
上面的代码相当直接。下载的图片会被保存在文档（ Documents ）目录，如果在文档目录不存在指定的文件， getImage: 方法将返回 nil.
现在在 LibraryAPI.m 中增加下面的方法：
1. - (void)downloadImage:(NSNotification*)notification
2.
3. {
4.
5. 1
6.
7. "imageView"];
8.
9. "coverUrl"];
10.
11.
12.
13. 2
14.
15. imageView.image = [persistencyManager getImage:[coverUrl lastPathComponent]];
16.
17.
18.
19. if (imageView.image == nil)
20.
21. {
22.
23. 3
24.
25. 0), ^{
26.
27. UIImage *image = [httpClient downloadImage:coverUrl];
28.
29.
30.
31. 4
32.
33. dispatch_sync(dispatch_get_main_queue(), ^{
34.
35. imageView.image = image;
36.
37. [persistencyManager saveImage:image filename:[coverUrl lastPathComponent]];
38.
39. });
40.
41. });
42.
43. }
44.
45. }
下面是以上代码分段描述：
1. downloadImage 方法是通过通知被执行的，所以通知对象会当作参数传递。 UIImageView 和图片 URL 都会从通知中获取。
2. 如果图片已经被下载过了，直接从 PersistencyManager 方法获取。
3. 如果图片还没有被下载，通过 HTTPClient 去获取它。
4. 当图片下载的时候，将它显示在 UIImageView 中，同时使用 PersistencyManager 保存到本地。
再一次，你使用了门面（ Facade ）模式隐藏了下载图片的复杂性。通知的发送者不需要关心图片是来自网络还是来自本地文件系统。
构建并运行你的应用，看看那些在滚动视图中的漂亮封面吧：
停止你的应用再一次运行它，你会注意到不会存在加载图片的延迟，因为它们都已经被保存到了本地。甚至你可以断开网络，你的应用也可以完美地运行。然而这里有点奇怪，图片上的提示转盘一直在转动，出了什么问题呢？
当开始下载图片的时候，你启动了提示图片正在加载的旋转提示器，但是你还没有实现图片下载完成后停止它的逻辑。你应该在每次图片下载完成的时候发送一个通知，但是这里你使用 KVO 这种观察者模式。
Key-Value Observing(KVO)模式
在 KVO 中，一个对象可以要求在它自身或者其它对象的属性发送变化的时候得到通知。如果你对 KVO 感兴趣的话，你可以更进一步的阅读这篇文章： Apple’s KVO Programming Guide .
如何使用KVO
正如上面所说的， KVO 机制让对象可以感知到属性的变化。在本例中，你可以使用 KVO 去观察 UIImageView 的 image 属性的变化。
打开 AlbumView.m 文件，在 initWithFrame:albumCover: 方法 [self addSubview:indicator] 这一行后，增加下面的代码：
1. [coverImage addObserver:self forKeyPath:@"image" options:0
这里它增加了它自己（当前的类）作为 image 属性的观察者。
当完成的时候，你同样需要注销相应的观察者。仍然在 AlbumView.m 中增加下面的代码：
1. - (void)dealloc
2. {
3. "image"];
4.
5. }
最后增加下面的方法：
1. - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
2.
3. {
4.
5. "image"])
6.
7. {
8.
9. [indicator stopAnimating];
10.
11. }
12.
13. }
你必须在每个观察者类中实现这个方法。系统会在被观察的属性发送变化的时候通知观察者。在上面的代码中，当 image 属性变化的时候，你停止了封面上面的旋转提示器。这样以来，当图片加载完后，旋转提示器将会停止。
构建并运行的你的工程。旋转提示器应该会消失：
注意 : 你要总是记得去移除已经销毁的观察者，否则当给不存在的观察者发送消息的时候，你的应用可能会崩溃。
如果你玩一回你的应用后终止它，你会发现你的应用状态没有被保存，你上次查看的专辑不是下次启动时候的缺省专辑。
为了修正这个问题，你可以使用列表中的下个模式：备忘录（ Memento ）模式 .
