RxSwift-中介者模式

proxy.png

中介者模式，顾名思义，通过中介来连接买家和供应商，减少买家和供应商的联系成本。在RxSwift中存在很多中介者来帮我们处理很多事情，如map来帮我们处理数据并转化为新的序列；filter来帮我们筛选数据并产生新序列；zip来帮助我们将多个序列合成为一个序列。这些内部复杂的实现不可能每次在用到时重新实现一边，通过中介者达到一个很好的复用及管理。

map

Observable<Int>.of(1,2,3,4,5,6)
    .map{
        $0+10
    }
    .subscribe(onNext: { (val) in
        print(val)
    }).disposed(by: disposeBag)

• 输出结果在原有序列元素的基础上+10
• 输出结果为：11 12 13 14 15 16

filter

Observable<Int>.of(1,2,3,4,5)
    .filter {$0>4}
    .subscribe(onNext: { (val) in
        print(val)
    }).disposed(by: disposeBag)

• 给filter中介者筛选条件，筛选数据
• 输出结果为：5

以上RxSwift操作符均是我们的中介者，下面我们来看一下定时器中介者的演化。

普通实现

实现一个定时器并打印：

self.timer = Timer.init(timeInterval: 1, target: self, selector: #selector(timerFire), userInfo: nil, repeats: true)
RunLoop.current.add(self.timer!, forMode: .common)

@objc func timerFire() {
    print("timer")
}

deinit {
    print("\(self.classForCoder) 销毁")
}

运行打印，能够跑起来，到这很多人觉得，这不就行了吗，有定时器直接用就好。我们来检查一下，界面是否能够正常释放。这里说明当前页面是push进来的页面，点击返回即可。

返回后发现我们的deinit并没有消失，那就说明当前页面出现了循环引用，那么此处循环引用肯定是在timer和self之间的。

• self持有timer，timer持有当前self构成循环引用

当然有人会想到，在deinit中给timer置空不就打破了吗，可以吗？当然不行，self不能释放就不会执行deinit。那如果在页面快消失的时候使定时器失效，并置空呢？如下：

override func viewDidDisappear(_ animated: Bool) {
    self.timer?.invalidate()
    self.timer = nil
    print("viewDidDisappear")
}

打印：SecondController 销毁

运行push再pop能够正常销毁，但此处会显着很刺眼，难道我们每一个定时器都要在这个地方处理吗。当然在iOS10系统中苹果提供了block，只需弱引用控制器即可。下面来感受一下（此处没有引用当前控制器）：

self.timer = Timer.init(timeInterval: 1, repeats: true, block: {(timer) in
    print("timer")
})
RunLoop.current.add(self.timer!, forMode: .common)

打印：
SecondController 销毁
timer

我们可以看到，当前控制器被销毁了，但是定时器好像并没有停止打印，因此这里定时器并没有销毁，其实定时器是被RunLoop所持有，为解决这一问题，我们还是需要像上面那样使定时器失效并置空才能解决。

以上方法都不便于我们对定时器的管理，而我们理想中的定时器需要跟随引用者的释放而释放，我们只负责创建和处理定时器事件。那么我们就引入中介者，把timer的失效和置空交给中介者解决就行。

中介者实现

首先中介者要知道外界的方法选择器便于调用，再者为打破self->timer->self的循环引用，中介者内部对self做弱引用。声明属性如下：

weak var target: NSObjectProtocol?
var sel: Selector?
var timer: Timer? = nil

• 管理外界对象，外界选择器，及内部的timer定时器

仿造Timer定时器方法，对外设置定时器方法接受外部调用对象即选择器：

func hb_scheduledTimer(timeInterval ti: TimeInterval, target aTarget: Any, selector aSelector: Selector, userInfo: Any?, repeats yesOrNo: Bool){
    self.timer = Timer.init(timeInterval: ti, target: self, selector: #selector(hb_timerFire), userInfo: userInfo, repeats: yesOrNo)
    RunLoop.current.add(self.timer!, forMode: .common)
    //此处对外self是弱引用
    self.target = (aTarget as! NSObjectProtocol)
    self.sel = aSelector
}

• 内部定义定时器，设定target为当前中介者类
• 设定定时器触发方法为中介者类的方法
• 定时器加入到RunLoop中
• 保存外界目标对象及选择器

重点在中介者定时器触发方法中：

@objc fileprivate func hb_timerFire(){
    if self.target != nil{
        self.target!.perform(self.sel)
    }else{
        self.timer?.invalidate()
        self.timer = nil
    }
}
deinit {
    print("\(self.classForCoder) 走了 ")
}

• 有目标对象，通过perform调用目标对象的方法
• 没有目标对象，即清除定时器，解除RunLoop对定时器的引用

以上中介者已构建完成，下面调用测试一下：

class SecondController: UIViewController{
    let proxy = TimerProxy()

    override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = .white
        self.proxy.hb_scheduledTimer(timeInterval: 1, target: self, selector: #selector(timerFire), userInfo: nil, repeats: true)
    }
    @objc func timerFire() {
        print("timer")
    }
    deinit {
        print("\(self.classForCoder) 销毁")
    }
}

push再pop页面打印如下：

timer
timer
SecondController 销毁
TimerProxy 走了 

• 所有对象均被销毁，由于中介者内部对当前self是弱引用，所以当前控制器能够正常销毁
• 当前控制器销毁后，proxy内部弱引用对象target也会被销毁
• proxy内部定时器执行判断target时，发现target为nil即释放了定时器
• proxy不持有timer，timer也不持有proxy，即proxy会被销毁

RxSwift定时器

let timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
timer.subscribe(onNext: { (time) in
    print(time)
}).disposed(by: disposeBag)

以上序列其实就是一个中介者，在RxSwift中管理了Timer对象，在当前对象销毁时清除垃圾袋并销毁定时器对象。

以上就是中介者对象的作用，直接使用，不用再对项目中定时器做释放操作。中介者其实就是封装复杂繁琐的操作，和不便于管理的业务，简化操作流程，让开发变得更简洁更高效。