美文网首页
一文道尽对象之间通信的模式

一文道尽对象之间通信的模式

作者: 读_心 | 来源:发表于2024-01-18 15:58 被阅读0次

当设计应用程序时,可以使用多种对象之间通信的模式。以下是通知、代理、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):

  -  **基本原理:** 允许视图和模型之间的同步,当模型数据发生变化时,视图会自动更新

  -  **内存方面:** 数据绑定可能需要创建监听器对象,用于监听数据模型的变化,需要注意对象的生命周期。

  -  **注意事项:** 频繁更新数据模型可能引发性能问题,需要谨慎设计。

总体而言,每种通信模式在内存方面都有其特点,需要开发者在设计和使用时考虑内存的管理和优化。避免潜在的循环引用、滥用观察者等问题,有助于确保内存使用的合理性。

相关文章

  • 第23条:通过委托与数据源协议进行对象间通信

    对象之间需要相互通信,一种名叫“委托模式”的编程设计模式来实现对象之间的通信。 该模式主旨是:定义一套接口,某对象...

  • 通过委托与数据源协议进行对象间通信--Effective笔记

    OC中对象之间经常需要相互通信,而通信方式有很多种。常用使用“委托模式”来实现对象间的通信。该模式的主旨是:定义一...

  • 设计模式:中介者模式

    中介者模式 中介者模式用来接触对象和对象之间的耦合关系。假如现在有一堆同父类的对象之间需要相互通信,每个对象之间都...

  • 设计模式(22)之中介者模式

    中介者模式(Mediator Pattern)用来降低多个对象之间的通信耦合问题,这样各对象之间具有了松耦合性,避...

  • 5. 行为模式

    行为模式涉及到算法和对象间职责的分配。行为模式不仅描述对象或类的模式,还描述它们之间的通信模式。这些模式刻划了在运...

  • 《Effective Objective-C 2.0 》 阅读笔

    第23条:通过委托与数据源协议进行对象间通信 1. 委托模式 对象之间经常需要相互通信,在iOS中通信有委托和Bl...

  • 中介者模式

    中介者模式是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类,该类通常处理不同类之间的通信,并支持送...

  • 浅谈设计模式之【中介者模式】| Java,ES6语法

    【中介者模式】中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性。这种模式提供了...

  • 设计模式-中介者模式

    模式定义: 中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性。这种模式提供了一...

  • 设计模式-中介者模式

    中介者模式 中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性。这种模式提供了一...

网友评论

      本文标题:一文道尽对象之间通信的模式

      本文链接:https://www.haomeiwen.com/subject/yefdodtx.html