当设计应用程序时，可以使用多种对象之间通信的模式。以下是通知、代理、KVO、闭包、单例模式、观察者模式、消息中间件、命令模式、数据绑定等通信模式的整理，包括基本原理、适用场景、运行成本、内存方面的简要分析，并提供了每种模式的简单示例代码：
### 通知（Notification）：
- **基本原理：** 一对多的观察者模式，发布者发布通知，多个订阅者监听并响应。
- **适用场景：** 适用于解耦、一对多的场景，例如系统级别的事件。
- **运行成本：** 相对较低。
- **内存方面：** 通知中心维护通知的观察者列表，可能涉及到引用计数的管理。
```
// 发送通知 [[NSNotificationCenter defaultCenter] postNotificationName:@"MyNotification" object:self];
// 接收通知
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleNotification:) name:@"MyNotification" object:nil];
// 处理通知的方法
- (void)handleNotification:(NSNotification *)notification { // 处理通知的逻辑 }
```
### 代理（Delegate）：
- **基本原理：** 委托模式，一个对象将某些任务委托给另一个对象来完成。
- **适用场景：** 适用于一对一的协作，例如视图控制器与视图之间的通信。
- **运行成本：** 相对较低。
- **内存方面：** 代理是一对一的关系，通常不涉及大量的引用计数管理。
```
// 定义委托协议
@protocol MyDelegate <NSObject>
- (void)delegateMethod;
@end
// 提供委托的类
@interface MyProvider : NSObject
@property (weak) id<MyDelegate> delegate;
@end
// 使用委托的类
@interface MyUser : NSObject <MyDelegate>
@end
// 在使用委托的类中设置委托
MyProvider *provider = [[MyProvider alloc] init];
MyUser *user = [[MyUser alloc] init];
provider.delegate = user;
// 当某个事件发生时，调用委托方法
[provider.delegate delegateMethod];
```
### KVO（Key-Value Observing）：
- **基本原理：** 允许对象监视另一个对象的属性，并在属性发生更改时得到通知。
- **适用场景：** 适用于需要观察对象属性变化的场景。
- **运行成本：** 相对较低。
- **内存方面：** KVO 使用了运行时编程，需要动态生成子类，可能会涉及到一些内存的分配和释放。
```
// 观察者类
@interface MyObserver : NSObject
@end
// 被观察者类
@interface MyObservable : NSObject
@property (nonatomic, strong) NSString *propertyToObserve;
@end
// 在观察者中添加观察者
MyObservable *observable = [[MyObservable alloc] init];
MyObserver *observer = [[MyObserver alloc] init];
[observable addObserver:observer forKeyPath:@"propertyToObserve" options: NSKeyValueObservingOptionNew context:NULL];
// 在观察者中实现观察者方法
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
// 处理观察者方法
}
```
### 闭包（Closure）：
- **基本原理：** 使用闭包传递代码块，允许在需要的时候执行。
- **适用场景：** 适用于简单的回调，特别是在异步操作中。
- **运行成本：** 相对较高。
- **内存方面：** 闭包作为对象时，可能需要在堆上分配内存，使用过程中需要管理闭包的引用计数。
```
// 使用闭包作为回调
func performAsyncTask(completion: @escaping () -> Void) {
DispatchQueue.global().async {
// 执行异步任务
// ...
// 调用闭包回调
completion()
}
} //
调用函数并传递闭包
performAsyncTask {
// 处理异步任务完成后的逻辑
}
```
### 单例模式（Singleton）：
- **基本原理：** 通过单例模式创建的对象可以在整个应用中共享。
- **适用场景：** 适用于需要在多个对象之间共享状态或数据的情况。
- **运行成本：** 相对较低。
- **内存方面：** 单例对象的创建是惰性的，只有在需要的时候才会创建实例。
```
// 单例类
class MySingleton {
static let shared = MySingleton()
private init() {
// 初始化
}
}
// 使用单例
let myInstance = MySingleton.shared
```
### 观察者模式（Observer）：
- **基本原理：** 一对多的依赖关系，当一个对象的状态变化时，所有依赖于它的对象都会得到通知并自动更新。
- **适用场景：** 适用于对象间存在关联关系，一个对象的状态变化需要通知其他相关对象。
- **运行成本：** 相对较低。
- **内存方面：** 观察者模式通过回调机制实现，观察者需要持有被观察对象的引用，可能涉及到引用计数的管理。
```
// 主题协议
protocol Subject {
func addObserver(_ observer: Observer)
func removeObserver(_ observer: Observer)
func notifyObservers()
}
// 观察者协议
protocol Observer: AnyObject {
func update(_ message: String)
}
// 具体的主题类
class ConcreteSubject: Subject {
private var observers = [Observer]()
private var state: String = ""
func setState(_ state: String) {
self.state = state
notifyObservers()
}
func addObserver(_ observer: Observer) {
observers.append(observer)
}
func removeObserver(_ observer: Observer) {
observers = observers.filter { $0 !== observer }
}
func notifyObservers() {
for observer in observers {
observer.update(state)
}
}
}
// 具体的观察者类
class ConcreteObserver: Observer {
private let name: String
init(name: String) {
self.name = name
}
func update(_ message: String) {
print("\(name) received an update: \(message)")
}
}
// 示例用法
let subject = ConcreteSubject()
let observerA = ConcreteObserver(name: "Observer A")
let observerB = ConcreteObserver(name: "Observer B")
subject.addObserver(observerA)
subject.addObserver(observerB)
subject.setState("New State 1")
// 输出:
// Observer A received an update: New State 1
// Observer B received an update: New State 1
subject.removeObserver(observerB)
subject.setState("New State 2")
// 输出:
// Observer A received an update: New State 2
```
其他三种iOS不常用。
### 消息中间件（Message Bus）：
- **基本原理：** 使用消息中间件作为中介，对象通过发送和接收消息进行通信。
- **内存方面：** 消息中间件可能涉及到消息的序列化和传递，会产生一些临时对象，需要注意内存的管理。
- **注意事项：** 消息的内容和生命周期需要合理设计。
### 命令模式（Command）
- **基本原理：** 将请求封装为一个对象，使得可以参数化客户端对象与具体执行请求的对象之间的关系。
- **内存方面：** 命令模式通过将请求封装为对象，可能涉及到额外的对象创建和销毁，需要注意内存的管理。
- **注意事项：** 命令的生命周期需要合理管理。
### 数据绑定（Data Binding）：
- **基本原理：** 允许视图和模型之间的同步，当模型数据发生变化时，视图会自动更新
- **内存方面：** 数据绑定可能需要创建监听器对象，用于监听数据模型的变化，需要注意对象的生命周期。
- **注意事项：** 频繁更新数据模型可能引发性能问题，需要谨慎设计。
总体而言，每种通信模式在内存方面都有其特点，需要开发者在设计和使用时考虑内存的管理和优化。避免潜在的循环引用、滥用观察者等问题，有助于确保内存使用的合理性。
