上一篇文章中，我们已经简单了解了一下RxSwift入门的第一步，在RxCocoa的帮助下，来实现一个登录输入监听校验的功能。
那么我们要如何创建一个属于我们自己的监听序列呢？或者说如何监听我们自己创建的属性呢，比如说一个String。
我们这里先简单说一下Observable与Observer的区别与联系
Observable：可监听序列，从名字上来看，我们就能理解，他是用来被监听的，而不是主动监听的
Observer：观察者，显而易见，它与“可监听序列”相对，它就是用来监听序列的角色。监听事件，然后它需要这个事件做出响应。例如：监听到一个
onNext事件，然后我们对这个事件作出响应。二者相互配合，从而达到响应的效果。
Observable 可监听序列
介绍内容摘取自RxSwift的使用详解3（Observable介绍、创建可观察序列）
Observable 作为 Rx 的根基，我们首先对它要有一些基本的了解。
1. Observable<T>
-
Observable<T>这个类就是Rx框架的基础，我们可以称它为可观察序列。它的作用就是可以异步地产生一系列的Event（事件），即一个Observable<T>对象会随着时间推移不定期地发出event(element : T)这样一个东西。 - 而且这些
Event还可以携带数据，它的泛型<T>就是用来指定这个Event携带的数据的类型。 - 有了可观察序列，我们还需要有一个
Observer（订阅者）来订阅它，这样这个订阅者才能收到Observable<T>不时发出的Event。
2.Event
查看 RxSwift 源码可以发现，事件 Event 的定义如下：
public enum Event<Element> {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
可以看到 Event 就是一个枚举，也就是说一个 Observable 是可以发出 3 种不同类型的 Event 事件：
-
next：
next事件就是那个可以携带数据<T>的事件，可以说它就是一个“最正常”的事件。
-
error：
error事件表示一个错误，它可以携带具体的错误内容，一旦Observable发出了error event，则这个Observable就等于终止了，以后它再也不会发出event事件了。
-
completed：
completed事件表示Observable发出的事件正常地结束了，跟error一样，一旦Observable发出了completed event，则这个Observable就等于终止了，以后它再也不会发出event事件了。
Observer 观察者
在上文我们已经有提到过了Observer就是用来“观察”Observable的，那么是如何观察的呢？
我们使用 subscribe() 方法来订阅（观察）Observable。
上面有提到Observable发出三种事件next、error、completed，那么Observer也对应的能监听到这三种事件
//订阅序列
observable.subscribe(onNext: { (str) in
print(str)
}, onError: { (error) in
print(error)
}, onCompleted: {
print("completed")
}).disposed(by: disposebag)
Observable & Observer 配合使用
1. 最普通的序列创建与订阅
enum MyError: Error {
case errorA
case errorB
}
//创建序列
let testOB = Observable<String>.create { ob in
//发送next事件
ob.onNext("test1")
ob.onNext("test2")
ob.onNext("test3")
//发送error事件
ob.onError(MyError.errorA)
//发送completed事件
ob.onCompleted()
return Disposables.create()
}
//订阅序列
testOB.subscribe(onNext: { (str) in
print(str)
}, onError: { (error) in
print(error)
}, onCompleted: {
print("completed")
}).disposed(by: disposebag)
打印结果：
test1
test2
test3
errorA
细心的朋友已经发现了，我们明明有发送completed，但是为什么没有打印出来，很明显，问题在ob.onError()上。
我们在测试一下，挪动一下ob.onError()的位置
//创建序列
let testOB = Observable<String>.create { ob in
ob.onNext("test1")
ob.onNext("test2")
ob.onError(MyError.errorA)
ob.onNext("test3")
ob.onCompleted()
return Disposables.create()
}
打印结果：
test1
test2
errorA
所以我们能得出结论，一旦观察者有监听到error事件，那么就会在触发onError:闭包结束后，停止监听。后续应该会好好聊聊这个问题。我们先暂且了解就好。
2. 跨类使用
我们新创建一个类FirstViewModel，声明一个Observable<String>类型的变量，然后在初始化方法中直接创建出来。
class FirstViewModel {
var text : Observable<String>!
let disposeBag = DisposeBag()
init() {
text = Observable.create { (observer) -> Disposable in
observer.onNext("test1")
observer.onNext("test2")
observer.onNext("test3")
observer.onCompleted()
return Disposables.create()
}
}
}
然后我们在控制器中，初始化FirstViewModel
class FirstViewController: UIViewController {
var disposeBag = DisposeBag()
override func viewDidLoad() {
super.viewDidLoad()
let vm : FirstViewModel = FirstViewModel.init()
vm.text.subscribe(onNext: { obString in
print(obString)
}, onCompleted: {
print("completed")
}).disposed(by: disposeBag)
}
}
command + R 看 输出结果
msg1
msg2
msg3
completed
3. 点击按钮发送事件
class FirstViewModel {
class func getText() -> Observable<String> {
//创建一个just事件
return .just("你收到了嘛")
}
}
btn.rx.tap.subscribe(onNext: { [weak self] in
self?.btnClick()
}).disposed(by: disposeBag)
//事件
func btnClick() -> Void{
FirstViewModel.getText().subscribe(onNext: { (String) in
print(String)//输出结果： 你收到了嘛
}).disposed(by: disposeBag)
}
这里出现了一个.just，这是什么呢。
创建Observable序列的方法有很多种。
创建Observable 序列其他方法
各个方法的区别于作用，可以看这里
print("----------- this is just ----------- ")
let observable_just = Observable<Int>.just(5)
observable_just.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("just completed")
}).disposed(by: disposeBag)
print("----------- this is of ----------- ")
let observable_of = Observable.of("A", "B", "C")
observable_of.subscribe(onNext: { (String) in
print("\(String)")
}, onCompleted: {
print("of completed")
}).disposed(by: disposeBag)
print("----------- this is from ----------- ")
let observable_from = Observable.from(["A", "B", "C"])
observable_from.subscribe(onNext: { (String) in
print("\(String)")
}, onCompleted: {
print("from completed")
}).disposed(by: disposeBag)
print("----------- this is empty ----------- ")
let observable_empty = Observable<Int>.empty()
observable_empty.subscribe(onNext: { (Int) in
print("this is empty")
}, onCompleted: {
print("empty completed")
}).disposed(by: disposeBag)
print("----------- this is never ----------- ")
let observable_nerver = Observable<Int>.never()
observable_nerver.subscribe(onNext: { (Int) in
print("this is never")
}, onCompleted: {
print("never completed")
}).disposed(by: disposeBag)
print("----------- this is error ----------- ")
enum MyError: Error {
case A
case B
}
let observable_error = Observable<Int>.error(MyError.A)
observable_error.subscribe(onNext: { (Int) in
}, onError: { (Error) in
print(" \(Error)")
}, onCompleted: {
print("error completed")
}).disposed(by: disposeBag)
print("----------- this is range ----------- ")
let observable_range = Observable.range(start: 1, count: 5)
observable_range.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("range completed")
}).disposed(by: disposeBag)
//不能放在主线程，会堵塞
// let observable_repeat = Observable.repeatElement(1)
// observable_repeat.subscribe(onNext: { (Int) in
// print("this is repeat -- \(Int)")
// }, onCompleted: {
// print("repeat completed")
// }).disposed(by: disposeBag)
print("----------- this is generate ----------- ")
//使用generate()方法
let observable_generate = Observable.generate(
initialState: 0,
condition: { $0 <= 10 },
iterate: { $0 + 2 }
)
observable_generate.subscribe(onNext: { (Int) in
print("\(Int)")
}, onCompleted: {
print("generate completed")
}).disposed(by: disposeBag)
print("----------- this is deferred ----------- ")
//用于标记是奇数、还是偶数
var isOdd = true
//使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
//让每次执行这个block时候都会让奇、偶数进行交替
isOdd = !isOdd
//根据isOdd参数，决定创建并返回的是奇数Observable、还是偶数Observable
if isOdd {
return Observable.of(1, 3, 5 ,7)
}else {
return Observable.of(2, 4, 6, 8)
}
}
//第1次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
//第2次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
//第3次订阅测试
factory.subscribe { event in
print("\(isOdd)", event)
}.disposed(by: disposeBag)
print("----------- this is interval ----------- ")
let observable_interval = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable_interval.subscribe { event in
print(event)
}.disposed(by: disposeBag)
print("----------- this is timer ----------- ")
//5秒种后发出唯一的一个元素0
let observable_timer = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable_timer.subscribe { event in
print(event)
}.disposed(by: disposeBag)
//延时5秒种后，每隔1秒钟发出一个元素
let observable_timer2 = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable_timer2.subscribe { event in
print(event)
}.disposed(by: disposeBag)
既是Observable 又是 Observer
怎么说呢，像TextField，我们既可以监听它，又可以把它当做一个观察者。
- 如果是初学者，那么觉得上面这句话很奇怪，这个作为观察者是什么意思？
我们可以这么理解，我们既可以监听文本框的输入，又可以给文本框赋值。
那么接下来我就为你们介绍一下这种情况。
class FifthViewController: UIViewController {
var textF:UITextField!
let disposeBag = DisposeBag()
override func viewDidLoad() {
super.viewDidLoad()
textF = UITextField.init(frame: .init(x: 20, y: 120, width: view.frame.width, height: 40))
textF.borderStyle = .roundedRect
view.addSubview(textF)
//把文本框当做观察者
let observer = textF.rx.text
let text:Observable<String> = Observable<String>.create {
$0.onNext("test")
$0.onNext("test1")
$0.onNext("test2")
return Disposables.create()
}
text.bind(to: observer).disposed(by: disposeBag)
//把文本框当做可监听对象
let observable = textF.rx.text
observable.subscribe(onNext: {
print($0 as Any)
}).disposed(by: disposeBag)
}
}
另外，框架里面定义了一些辅助类型，它们既是可监听序列也是观察者。如果你能合适的应用这些辅助类型，它们就可以帮助你更准确的描述事物的特征：
- AsyncSubject
- PublishSubject
- ReplaySubject
- BehaviorSubject
- ControlProperty”
摘录来自: RxSwift 中文文档。
以上几种辅助类型我将在 RxSwfit 学习笔记（四）中学习探索
