首先理清以下几个概念（也是小编理解RxSwift的突破口）
什么是观察者，什么是可被观察者

实现ObserverType协议的是观察者，比如类 Observer
实现ObservableType协议的是可观察序列，比如类 Observable
实现ControlPropertyType协议（此协议继承了ObserverType和ObservableType）的则既是观察者，也可以是被观察者，比如结构体ControlProperty

土话理解：观察者与可被观察者
观察者：就是观察监听，然后根据其他人的信息接收输入的
可被观察者： 就是被监听的，然后内容输出给他人的

Observable定义

（1）Observable<T>

• Observable<T>这个类是Rx框架的基础，可以称它为可观察序列。
  它的作用是以异步产生一系列的Event（事件），即一个Observable<T>对象会随着事件推移不定期地发出event(element:T)

• 而且这些Event还可以携带数据，它的泛型<T>就是用来指定这个Event携带的数据的类型

• 有了可观察序列，还需要一个Observer（订阅者）来订阅它，这样这个订阅者才能收到Observable<T> 发出的 Event

（2）Event
Even源码如下
Event是一个枚举，也就是说一个Observable是可以发出3种不同类型的Event事件

next: next事件就是那个可以携带数据<T>的事件，可以说它是一个最正常的事件

error:error事件表示一个错误，可以携带具体的错误内容，一旦Observable发出了error event，则这个Observable就等于终止了，以后它不会在发出event事件了

completed: completed事件表示Observable发出的事件正常结束了，跟error一样，一旦Observable发出了completed event，则这个Observable就等于终止了，以后它再也不会发出event事件了

@frozen 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
}

创建可观察序列Observable

1、jus()

传入一个默认值初始化，构建一个只有一个元素的Observable队列，订阅完自动complete

let array = ["A","B"]
/// 创建一个类型为[String]的可被观察者Observable，
/// 那么Observable所发出的事件携带的数据类型必须是[String]类型
Observable<[String]>.just(array)
    .subscribe { (item) in
        print(item)
    } onError: { (erro) in
        print("error")
    } onCompleted: {
        print("completed")
    } onDisposed: {
        print("disposed")
    }.disposed(by: disposeBag)

/// 打印结果
/// ["A", "B"]
/// completed
/// disposed

2、of()

创建一个可以携带多个元素(必须是同类型的)的可观察序列

Observable<String>.of("A","B","C","D")
  .subscribe { (item) in
    print(item)
  } onError: { (error) in
    print(error)
  } onCompleted: {
    print("completed")
  } onDisposed: {
    print("disposed")
  }.disposed(by: disposeBag)

/// 打印结果：
/// A
/// B
/// C
/// D
/// completed
/// disposed

3、from()

（1）将可选内容转为可观察序列，也就是说会对我们的可选类型进行处理（如果可选类型是nil，那么不执行onNext直接执行completed; 如果可选类型不为nil，那么会自动解包）

let a:Int? = 1
Observable.from(optional: a)
    .subscribe { (item) in
        print(item)
    } onError: { (error) in
        print(error)
    } onCompleted: {
        print("completed")
    } onDisposed: {
        print("disposed")
    } .disposed(by: disposeBag)

/// 打印结果：
/// 1
/// completed
/// disposed

（2）从集合（数组，集合，set）中获取序列（有可选项处理，更安全）
有点集合遍历的效果

Observable.from(["A","B","C"])
    .subscribe { (item) in
        print(item)
    } onError: { (error) in
        print(error)
    } onCompleted: {
        print("completed")
    } onDisposed: {
        print("disposed")
    }.disposed(by: disposeBag)

/// 打印结果:
/// A
/// B
/// C
/// completed
/// disposed

4、empty()

创建一个空内容的observable序列

let observable = Observable<Int>.empty()
        observable.subscribe { (value) in
            print(value)
        } onError: { (error) in
            print(error)
        } onCompleted: {
            print("completed")
        } onDisposed: {
            print("disposed")
        }.disposed(by: bag)

/// 打印结果：
/// completed
/// disposed

5、never()

创建一个永不会发出Event（也不会终止）的Observable序列

let observable = Observable<Int>.never()

6、error()

创建一个不做任何操作，直接发送一个错误的Observable序列

enum MyError: Error {
    case A
    case B
}

let observable = Observable<Int>.error(MyError.A)
observable.subscribe { (value) in
    print(value)
} onError: { (error) in
    print("error:",error)
} onCompleted: {
    print("completed")
} onDisposed: {
    print("disposed")
}

/// 输出结果：
/// error: A
/// disposed

7、range()

通过指定起始值和结束数值，创建一个以这个范围内所有值作为初始值得Observable序列

let observable = Observable.range(start: 0, count: 5)
observable.subscribe { (value) in
    print(value)
} onError: { (error) in
    print(error)
} onCompleted: {
    print("completed")
} onDisposed: {
    print("disposed")
}.disposed(by: bag)  

/// 输出结果：
/// 0
/// 1
/// 2
/// 3
/// 4
/// completed
/// disposed

8、repeatElement()

创建一个可以无限发出给定元素的Event的Observable序列

let observable = Observable.repeatElement(1)
observable.subscribe { (value) in
    print(value)
} onError: { (error) in
    print(error)
} onCompleted: {
    print("completed")
} onDisposed: {
    print("disposed")
}.disposed(by: bag)


/// 打印结果：
/// 1
/// 1
/// 1
/// 1
/// ...

9、generate()

根据提供的条件判断，如果为true的时候，才会发出动作的observable序列

/// initalState ： 初始值
/// condition ： 产生条件
/// iterate :   迭代变化
let observable = Observable.generate(initialState: 0, condition: {
    $0 <= 10
}, iterate: {
    $0 + 2
})

observable.subscribe { (value) in
    print(value)
} onError: { (error) in
    print(error)
} onCompleted: {
    print("completed")
} onDisposed: {
    print("disposed")
}.disposed(by: bag)


/// 打印结果：
/// 0
/// 2
/// 4
/// 6
/// 8
/// 10
/// completed
/// disposed

10、create()

通过一个block形式的参数，对每一个订阅进行处理

let observable = Observable<String>.create { observer in
    observer.onNext("create")
    observer.onCompleted()
    return Disposables.create()
}

observable.subscribe { (value) in
    print(value)
} onError: { (error) in
    print(error)
} onCompleted: {
    print("completed")
} onDisposed: {
    print("disposed")
}.disposed(by: bag)

/// 打印结果：
/// create
/// completed
/// disposed

11、deferred()

相对于创建一个Observable工厂，通过传入一个block来执行延迟Observable序列创建的行为，而这个block里就是真正实例化序列对象的地方

var isOdd = true

let factory: Observable<Int> = Observable.deferred {
    isOdd = !isOdd
    if isOdd {
        return Observable.of(1,3,5,7)
    }else{
        return Observable.of(2,4,6,8)
    }
}

factory.subscribe{ event in
    print("第一次订阅：",event)
}

factory.subscribe { event in
    print("第二次订阅：",event)
}

/// 打印结果：
第一次订阅： next(2)
第一次订阅： next(4)
第一次订阅： next(6)
第一次订阅： next(8)
第一次订阅： completed
第二次订阅： next(1)
第二次订阅： next(3)
第二次订阅： next(5)
第二次订阅： next(7)
第二次订阅： completed

12、interval()

创建一个Observable序列，每隔一段设定的时间，会发出一个索引的元素，而且它会一直发送下去

/// 创建一个每隔一秒钟就发出事件，并且在主线程执行
let observable = Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
observable.subscribe{ event in
    print(event)
}
.disposed(by: bag)

/// 打印结果：
/// next(0)
/// next(1)
/// next(2)
/// ...

13、timer()

（1）用法一：创建Observable序列在经过设定的一段时间后，产生唯一的一个元素

/// 延时定时器：2秒后发出事件
let observable = Observable<Int>.timer(.seconds(2), scheduler: MainScheduler.instance)
observable.subscribe{ event in
    print(event)
}
.disposed(by: bag)

（2）用法二：创建Observable序列在经过设定的一段时间后，每隔一段时间产生一个元素

/// 定时器：
/// 延时：0秒
/// 时间间隔：1秒
/// 执行线程： 主线程
let observable = Observable<Int>.timer(.seconds(0), period: .seconds(1), scheduler: MainScheduler.instance)
observable.subscribe{ event in
    print(event)
}
.disposed(by: bag)