一生信仰
一生信仰

RxSwift 简单理解

RxSwift核心

1. Observable - 可被监听的序列

Observable 可以用于描述元素异步产生的序列。这样我们生活中许多事物都可以通过它来表示: Observable 温度
例如：你可以将温度看作是一个序列，然后监测这个温度值，最后对这个值做出响应。例如：当室温高于 33 度时，打开空调降温

特征序列
  • Single

Single 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能发出一个元素，要么产生一个 error 事件。
A.发出一个元素，或一个 error 事件
B.不会共享状态变化

  • Completable

Completable 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能产生一个 completed 事件，要么产生一个 error 事件。
A.发出零个元素
B.发出一个 completed 事件或者一个 error 事件
C.不会共享状态变化

  • Maybe

Maybe 是 Observable 的另外一个版本。它介于 Single 和 Completable 之间，它要么只能发出一个元素，要么产生一个 completed 事件，要么产生一个 error 事件。
A.发出一个元素或者一个 completed 事件或者一个 error 事件
B.不会共享状态变化”

  • Driver

Driver（司机？） 是一个精心准备的特征序列。它主要是为了简化 UI 层的代码。不过如果你遇到的序列具有以下特征，你也可以使用它：
A.不会产生 error 事件
B.一定在 MainScheduler 监听（主线程监听）
C.共享状态变化

*ControlEvent

ControlEvent 专门用于描述 UI 控件所产生的事件，它具有以下特征：
A.不会产生 error 事件
B.一定在 MainScheduler 订阅（主线程订阅）
C.一定在 MainScheduler 监听（主线程监听）
D.共享状态变化

2. Observer - 观察者

观察者 是用来监听事件，然后它需要这个事件做出响应。例如：弹出提示框就是观察者，它对点击按钮这个事件做出响应。

例如：当室温高于 33 度时，打开空调降温
打开空调降温就是观察者 Observer。

创建观察者：
创建观察者最直接的方法就是在 Observable 的 subscribe 方法后面描述，事件发生时，需要如何做出响应。而观察者就是由后面的 onNext，onError，onCompleted的这些闭包构建出来的。

特征观察者
  • AnyObserver

AnyObserver 可以用来描叙任意一种观察者

*Binder

Binder 主要有以下两个特征：
A.不会处理错误事件
B.确保绑定都是在给定 Scheduler 上执行（默认 MainScheduler）
一旦产生错误事件，在调试环境下将执行 fatalError，在发布环境下将打印错误信息。

let observer: AnyObserver = AnyObserver { [weak self] (event) in
    switch event {
    case .next(let isHidden):
        self?.usernameValidOutlet.isHidden = isHidden
    default:
        break
    }
}

//observer
usernameValid.bind(to: observer).disposed(by: disposeBag)

extension Reactive where Base: UIView {
  public var isHidden: Binder {
      return Binder(self.base) { view, hidden in
          view.isHidden = hidden
      }
  }
}

usernameValid.bind(to: usernameValidOutlet.rx.isHidden).disposed(by: disposeBag)

3. Observable & Observer 既是可被监听的序列也是观察者

在我们所遇到的事物中，有一部分非常特别。它们既是可被监听的序列也是观察者。
例如：textField的当前文本。它可以看成是由用户输入，而产生的一个文本序列。也可以是由外部文本序列，来控制当前显示内容的观察者：

// 作为可被监听的序列
let observable = textField.rx.text
observable.subscribe(onNext: { text in show(text: text) })

// 作为观察者
let observer = textField.rx.text
let text: Observable = ...
text.bind(to: observer)
Subject

*AsyncSubject

AsyncSubject 将在源 Observable 产生完成事件后，发出最后一个元素（仅仅只有最后一个元素），如果源 Observable 没有发出任何元素，只有一个完成事件。那 AsyncSubject 也只有一个完成事件。
它会对随后的观察者发出最终元素。如果源 Observable 因为产生了一个 error 事件而中止， AsyncSubject 就不会发出任何元素，而是将这个 error 事件发送出来。

AsyncSubject.png
AsyncSubject.png 
let disposeBag = DisposeBag()
let subject = AsyncSubject()

subject
  .subscribe { print("Subscription: 1 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("")
subject.onNext("")
subject.onNext("")
subject.onCompleted()

输出结果：
Subscription: 1 Event: next()
Subscription: 1 Event: completed

*PublishSubject

PublishSubject 将对观察者发送订阅后产生的元素，而在订阅前发出的元素将不会发送给观察者。如果你希望观察者接收到所有的元素，你可以通过使用Observable 的 create 方法来创建 Observable，或者使用 ReplaySubject。
如果源 Observable 因为产生了一个 error 事件而中止， PublishSubject 就不会发出任何元素，而是将这个 error 事件发送出来。

PublishSubject.png
PublishSubject.png 
let disposeBag = DisposeBag()
let subject = PublishSubject()

subject
  .subscribe { print("Subscription: 1 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("")
subject.onNext("")

subject
  .subscribe { print("Subscription: 2 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("️")
subject.onNext("️")

输出结果：
Subscription: 1 Event: next()
Subscription: 1 Event: next()
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)

*ReplaySubject

ReplaySubject 将对观察者发送全部的元素，无论观察者是何时进行订阅的。
这里存在多个版本的 ReplaySubject，有的只会将最新的 n 个元素发送给观察者，有的只会将限制时间段内最新的元素发送给观察者。
如果把 ReplaySubject 当作观察者来使用，注意不要在多个线程调用 onNext, onError 或 onCompleted。这样会导致无序调用，将造成意想不到的结果。

ReplaySubject.png 
let disposeBag = DisposeBag()
let subject = ReplaySubject.create(bufferSize: 1)

subject
  .subscribe { print("Subscription: 1 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("")
subject.onNext("")

subject
  .subscribe { print("Subscription: 2 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("️")
subject.onNext("️")

输出结果：
Subscription: 1 Event: next()
Subscription: 1 Event: next()
Subscription: 2 Event: next()
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)

*BehaviorSubject

当观察者对 BehaviorSubject 进行订阅时，它会将源 Observable 中最新的元素发送出来（如果不存在最新的元素，就发出默认元素）。然后将随后产生的元素发送出来。如果源 Observable 因为产生了一个 error 事件而中止， BehaviorSubject 就不会发出任何元素，而是将这个 error 事件发送出来

98C97A0E-D2A0-4C84-964D-90A2BF88B2EC.png
413FA601-5878-433B-BDC1-FA57A4196385.png 
let disposeBag = DisposeBag()
let subject = BehaviorSubject(value: "")

subject
  .subscribe { print("Subscription: 1 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("")
subject.onNext("")

subject
  .subscribe { print("Subscription: 2 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("️")
subject.onNext("️")

subject
  .subscribe { print("Subscription: 3 Event:", $0) }
  .disposed(by: disposeBag)

subject.onNext("")
subject.onNext("")

输出结果：
Subscription: 1 Event: next()
Subscription: 1 Event: next()
Subscription: 1 Event: next()
Subscription: 2 Event: next()
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)
Subscription: 1 Event: next(️)
Subscription: 2 Event: next(️)
Subscription: 3 Event: next(️)
Subscription: 1 Event: next()
Subscription: 2 Event: next()
Subscription: 3 Event: next()
Subscription: 1 Event: next()
Subscription: 2 Event: next()
Subscription: 3 Event: next()
Variable

在 Swift 中我们经常会用 var 关键字来声明变量。RxSwift 提供的 Variable 实际上是 var 的 Rx 版本，你可以将它看作是 RxVar。
我们来对比一下 var 以及 Variable 的用法：

使用 var：

// 在 ViewController 中
var model: Model? = nil {
    didSet { updateUI(with: model) }
func updateUI(with model: Model?) { ... }

let model: Variable = Variable(nil)

override func viewDidLoad() {
    super.viewDidLoad()

    model.asObservable()
        .subscribe(onNext: { [weak self] model in
            self?.updateUI(with: model)
        })
        .disposed(by: disposeBag)

func updateUI(with model: Model?) { ... }
func getModel() -> Model { ... }

第一种使用 var 的方式十分常见，在 ViewController 中监听 Model 的变化，然后刷新页面。
第二种使用 Variable 则是 RxSwift 独有的。Variable 几乎提供了 var 的所有功能。另外，加上一条非常重要的特性，就是可以通过调用 asObservable() 方法转换成序列。然后你可以对这个序列应用操作符，来合成其他的序列。所以，如果我们声明的变量需要提供 Rx 支持，那就选用 Variable 这个类型。

说明
Variable 封装了一个 BehaviorSubject，所以它会持有当前值，并且 Variable 会对新的观察者发送当前值。它不会产生 error 事件。Variable 在 deinit 时，会发出一个 completed 事件

Operator - 操作符
6800A280-ADA2-4F79-A87B-11891FCF0158.png

操作符可以帮助大家创建新的序列，或者变化组合原有的序列，从而生成一个新的序列。
我们之前在输入验证例子中就多次运用到操作符。例如，通过 map 方法将输入的用户名，转换为用户名是否有效。然后用这个转化后来的序列来控制红色提示语是否隐藏。我们还通过 combineLatest 方法，将用户名是否有效和密码是否有效合并成两者是否同时有效。然后用这个合成后来的序列来控制按钮是否可点击。
这里 map 和 combineLatest 都是操作符，它们可以帮助我们构建所需要的序列。现在，我们再来看几个例子：

Filter:


99EE92D6-D016-4605-BB95-BA1FF5BAD869.png

Map:


D382E434-EC82-438B-B50A-A4297FFA708E.png

5. Disposable - 可被清除的资源

Disposable - 可被清除的资源

通常来说，一个序列如果发出了 error 或者 completed 事件，那么所有内部资源都会被释放。如果你需要提前释放这些资源或取消订阅的话，那么你可以对返回的 可被清除的资源（Disposable） 调用 dispose 方法：

F5A2FE7F-5526-4347-A7AB-80A37D135B12.png 
var disposable: Disposable?
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    self.disposable = textField.rx.text.orEmpty
        .subscribe(onNext: { text in print(text) })
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    self.disposable?.dispose()
}

调用 dispose 方法后，订阅将被取消，并且内部资源都会被释放。通常情况下，你是不需要手动调用 dispose 方法的。我们推荐使用 清除包（DisposeBag） 或者 takeUntil 操作符 来管理订阅的生命周期。

DisposeBag - 清除包

因为我们用的是 Swift ，所以我们更习惯于使用 ARC 来管理内存。那么我们能不能用 ARC 来管理订阅的生命周期了。答案是肯定了，你可以用 清除包（DisposeBag） 来实现这种订阅管理机制

404F9871-3ED0-4063-993F-3545B78FD9FD.png 
var disposeBag = DisposeBag()

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    textField.rx.text.orEmpty
        .subscribe(onNext: { text in print(text) })
        .disposed(by: self.disposeBag)
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)

    self.disposeBag = DisposeBag()
}

当 清除包 被释放的时候，清除包 内部所有 可被清除的资源（Disposable） 都将被清除。

takeUntil
8E12A1D5-9ED6-4018-86A0-DC6D5FB1CF2F.png

另外一种实现自动取消订阅的方法就是使用 takeUntil 操作符，上面那个输入验证的演示代码也可以通过使用 takeUntil 来实现：

override func viewDidLoad() {
“super.viewDidLoad()

    ...

    _ = usernameValid
        .takeUntil(self.rx.deallocated)
        .bind(to: passwordOutlet.rx.isEnabled)

    _ = usernameValid
        .takeUntil(self.rx.deallocated)
        .bind(to: usernameValidOutlet.rx.isHidden)

    _ = passwordValid
        .takeUntil(self.rx.deallocated)
        .bind(to: passwordValidOutlet.rx.isHidden)

    _ = everythingValid
        .takeUntil(self.rx.deallocated)
        .bind(to: doSomethingOutlet.rx.isEnabled)
}

这将使得订阅一直持续到控制器的 dealloc 事件产生为止。

6. Schedulers - 调度器

13FA831F-BA09-4DF5-9D93-2385BF472352.png

Schedulers 是 Rx 实现多线程的核心模块，它主要用于控制任务在哪个线程或队列运行。

let rxData: Observable = ...

rxData.subscribeOn(ConcurrentDispatchQueueScheduler(qos: .userInitiated))
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { [weak self] data in
        self?.data = data
    })
    .disposed(by: disposeBag)

使用 subscribeOn

我们用 subscribeOn 来决定数据序列的构建函数在哪个 Scheduler 上运行。以上例子中，由于获取 Data 需要花很长的时间，所以用 subscribeOn 切换到 后台 Scheduler 来获取 Data。这样可以避免主线程被阻塞。

使用 observeOn

我们用 observeOn 来决定在哪个 Scheduler 监听这个数据序列。以上例子中，通过使用 observeOn 方法切换到主线程来监听并且处理结果。
一个比较典型的例子就是，在后台发起网络请求，然后解析数据，最后在主线程刷新页面。你就可以先用 subscribeOn 切到后台去发送请求并解析数据，最后用 observeOn 切换到主线程更新页面。

MainScheduler

MainScheduler 代表主线程。如果你需要执行一些和 UI 相关的任务，就需要切换到该 Scheduler 运行。

SerialDispatchQueueScheduler

SerialDispatchQueueScheduler 抽象了窜行 DispatchQueue。如果你需要执行一些窜行任务，可以切换到这个 Scheduler 运行。

ConcurrentDispatchQueueScheduler

ConcurrentDispatchQueueScheduler 抽象了并行 DispatchQueue。如果你需要执行一些并发任务，可以切换到这个 Scheduler 运行。

OperationQueueScheduler

OperationQueueScheduler 抽象了 NSOperationQueue。
它具备 NSOperationQueue 的一些特点，例如，你可以通过设置 maxConcurrentOperationCount，来控制同时执行并发任务的最大数量。

7. Error Handling - 错误处理

一旦序列里面产出了一个 error 事件，整个序列将被终止。RxSwift 主要有两种错误处理机制：

  • retry - 重试
  • catch - 恢复
retry - 重试

retry 可以让序列在发生错误后重试：

// 请求 JSON 失败时，立即重试，
// 重试 3 次后仍然失败，就将错误抛出

let rxJson: Observable = ...

rxJson
    .retry(3)
    .subscribe(onNext: { json in
        print("取得 JSON 成功: \(json)")
    }, onError: { error in
        print("取得 JSON 失败: \(error)")
})
    .disposed(by: disposeBag)

以上的代码非常直接 retry(3) 就是当发生错误时，就进行重试操作，并且最多重试 3 次

retryWhen

如果我们需要在发生错误时，经过一段延时后重试，那可以这样实现：

let retryDelay: Double = 5  // 重试延时 5 秒

rxJson
    .retryWhen { (rxError: Observable) -> Observable in
        return Observable.timer(retryDelay, scheduler: MainScheduler.instance)
    }
    .subscribe(...)
    .disposed(by: disposeBag)

这里我们需要用到 retryWhen 操作符，这个操作符主要描述应该在何时重试，并且通过闭包里面返回的 Observable 来控制重试的时机：

闭包里面的参数是 Observable 也就是所产生错误的序列，然后返回值是一个 Observable。当这个返回的Observable 发出一个元素时，就进行重试操作。当它发出一个 error 或者 completed 事件时，就不会重试，并且将这个事件传递给到后面的观察者。

如果需要加上一个最大重试次数的限制:

// 请求 JSON 失败时，等待 5 秒后重试，
// 重试 4 次后仍然失败，就将错误抛出

let maxRetryCount = 4       // 最多重试 4 次
let retryDelay: Double = 5  // 重试延时 5 秒

rxJson
    .retryWhen { (rxError: Observable) -> Observable in
        return rxError.flatMapWithIndex { (error, index) -> Observable in
            guard index < maxRetryCount else {
                return Observable.error(error)
            }
        return Observable.timer(retryDelay, scheduler: MainScheduler.instance)
        }
    }
    .subscribe(...)
    .disposed(by: disposeBag)

我们用 flatMapWithIndex 这个操作符，因为它可以给我们提供错误的索引数 index。然后用这个索引数判断是否超过最大重试数，如果超过了，就将错误抛出。如果没有超过，就等待 5 秒后重试。

catchError - 恢复

catchError 可以在错误产生时，用一个备用元素或者一组备用元素将错误替换掉：

searchBar.rx.text.orEmpty
    ...
    .flatMapLatest { query -> Observable<[Repository]> in
        ...
        return searchGitHub(query)
            .catchErrorJustReturn([])
    }
    ...
    .bind(to: ...)
    .disposed(by: disposeBag)

我们开头的 Github 搜索就用到了catchErrorJustReturn。当错误产生时，就返回一个空数组，于是就会显示一个空列表页。

你也可以使用 catchError，当错误产生时，将错误事件替换成一个备选序列：

// 先从网络获取数据，如果获取失败了，就从本地缓存获取数据

let rxData: Observable = ...      // 网络请求的数据
let cahcedData: Observable = ...  // 之前本地缓存的数据

rxData
    .catchError { _ in cahcedData }
    .subscribe(onNext: { date in
        print("获取数据成功: \(date.count)")
    })
    .disposed(by: disposeBag)

常用操作符

  • catchError
    从一个错误事件中恢复，将错误事件替换成一个备选序列


    catchError

    catchError 操作符将会拦截一个 error 事件，将它替换成其他的元素或者一组元素，然后传递给观察者。这样可以使得 Observable 正常结束，或者根本都不需要结束。

let disposeBag = DisposeBag()

let sequenceThatFails = PublishSubject()
let recoverySequence = PublishSubject()

sequenceThatFails
    .catchError {
        print("Error:", $0)
        return recoverySequence
    }
    .subscribe { print($0) }
    .disposed(by: disposeBag)

sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onError(TestError.test)

recoverySequence.onNext("")

输出结果：
next()
next()
next()
next()
Error: test
next()
  • catchErrorJustReturn
    catchErrorJustReturn 操作符会将error 事件替换成其他的一个元素，然后结束该序列。
let disposeBag = DisposeBag()
let sequenceThatFails = PublishSubject()

sequenceThatFails
    .catchErrorJustReturn("")
    .subscribe { print($0) }
    .disposed(by: disposeBag)

sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onNext("")
sequenceThatFails.onError(TestError.test)

输出结果：
next()
next()
next()
next()
next()
completed
  • combineLatest
    当多个 Observables 中任何一个发出一个元素，就发出一个元素。这个元素是由这些 Observables 中最新的元素，通过一个函数组合起来的
combineLatest

combineLatest 操作符将多个 Observables 中最新的元素通过一个函数组合起来，然后将这个组合的结果发出来。这些源 Observables 中任何一个发出一个元素，他都会发出一个元素（前提是，这些 Observables 曾经发出过元素）。

let disposeBag = DisposeBag()
let first = PublishSubject()
let second = PublishSubject()

Observable.combineLatest(first, second) { $0 + $1 }
          .subscribe(onNext: { print($0) })
          .disposed(by: disposeBag)

first.onNext("1")
second.onNext("A")
first.onNext("2")
second.onNext("B")
second.onNext("C")
second.onNext("D")
first.onNext("3")
first.onNext("4")

输出结果：
1A
2A
2B
2C
2D
3D
4D
  • concat
    让两个或多个 Observables 按顺序串连起来
concat

concat 操作符将多个 Observables 按顺序串联起来，当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。

concat 将等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。如果后一个是“热” Observable ，在它前一个 Observable 产生完成事件前，所产生的元素将不会被发送出来。

startWith 和它十分相似。但是startWith不是在后面添加元素，而是在前面插入元素。

merge 和它也是十分相似。merge并不是将多个 Observables 按顺序串联起来，而是将他们合并到一起，不需要 Observables 按先后顺序发出元素。

let disposeBag = DisposeBag()

let subject1 = BehaviorSubject(value: "")
let subject2 = BehaviorSubject(value: "")

let variable = Variable(subject1)

variable.asObservable()
        .concat()
        .subscribe { print($0)
}.disposed(by: disposeBag)

subject1.onNext("")
subject1.onNext("")

variable.value = subject2

subject2.onNext("I would be ignored")
subject2.onNext("")

subject1.onCompleted()

subject2.onNext("")

输出结果：
next()
next()
next()
next()
next()
  • concatMap
    将 Observable 的元素转换成其他的 Observable，然后将这些 Observables 串连起来
concatMap

concatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。然后让这些 Observables 按顺序的发出元素，当concatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。然后让这些 Observables 按顺序的发出元素，当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。

let disposeBag = DisposeBag()

let subject1 = BehaviorSubject(value: "")
let subject2 = BehaviorSubject(value: "")

let variable = Variable(subject1)

variable.asObservable()
        .concatMap { $0 }
        .subscribe { print($0) }
        .disposed(by: disposeBag)

subject1.onNext("")
subject1.onNext("")

variable.value = subject2
subject2.onNext("I would be ignored")
subject2.onNext("")

subject1.onCompleted()

subject2.onNext("")

输出结果：
next()
next()
next()
next()
next()
  • connect
    通知可被连接的 Observable 可以开始发出元素了
connect

可被连接的 Observable 和普通的 Observable 十分相似，不过在被订阅后不会发出元素，直到 connect 操作符被应用为止。这样一来你可以等所有观察者全部订阅完成后，才发出元素。

  • create
    通过一个构建函数完整的创建一个 Observable
create

create 操作符将创建一个 Observable，你需要提供一个构建函数，在构建函数里面描述事件（next，error，completed）的产生过程。

通常情况下一个有限的序列，只会调用一次观察者的 onCompleted 或者 onError 方法。并且在调用它们后，不会再去调用观察者的其他方法。

创建一个 [0, 1, ... 8, 9] 的序列：

let id = Observable.create { observer in
    observer.onNext(0)
    observer.onNext(1)
    observer.onNext(2)
    observer.onNext(3)
    observer.onNext(4)
    observer.onNext(5)
    observer.onNext(6)
    observer.onNext(7)
    observer.onNext(8)
    observer.onNext(9)
    observer.onCompleted()
    return Disposables.create()
}
  • debug

打印所有的订阅，事件以及销毁信息

let disposeBag = DisposeBag()

let sequence = Observable.create { observer in
    observer.onNext("")
    observer.onNext("")
    observer.onCompleted()
    return Disposables.create()
}

sequence
    .debug("Fruit")
    .subscribe()
    .disposed(by: disposeBag)

输出结果：
2017-11-06 20:49:43.187: Fruit -> subscribed
2017-11-06 20:49:43.188: Fruit -> Event next()
2017-11-06 20:49:43.188: Fruit -> Event next()
2017-11-06 20:49:43.188: Fruit -> Event completed
2017-11-06 20:49:43.189: Fruit -> isDisposed
  • delay

将 Observable 的每一个元素拖延一段时间后发出

delay

delay 操作符将修改一个 Observable，它会将 Observable 的所有元素都拖延一段设定好的时间， 然后才将它们发送出来。

  • delaySubscription

进行延时订阅

delaySubscription

delaySubscription 操作符将在经过所设定的时间后，才对 Observable 进行订阅操作。

  • distinctUntilChanged

阻止 Observable 发出相同的元素

distinctUntilChanged

distinctUntilChanged 操作符将阻止 Observable 发出相同的元素。如果后一个元素和前一个元素是相同的，那么这个元素将不会被发出来。如果后一个元素和前一个元素不相同，那么这个元素才会被发出来。

let disposeBag = DisposeBag()

Observable.of("", "", "", "", "", "", "")
    .distinctUntilChanged()
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

输出结果：
  • elementAt

只发出 Observable 中的第 n 个元素

elementAt

elementAt 操作符将拉取 Observable 序列中指定索引数的元素，然后将它作为唯一的元素发出。

let disposeBag = DisposeBag()

Observable.of("", "", "", "", "", "")
    .elementAt(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

输出结果：
  • empty

创建一个空 Observable

empty

empty 操作符将创建一个 Observable，这个 Observable 只有一个完成事件。

//创建一个空 Observable：
let id = Observable.empty()

//它相当于：
let id = Observable.create { observer in
    observer.onCompleted()
    return Disposables.create()
}
  • error
    创建一个只有 error 事件的 Observable
error

error 操作符将创建一个 Observable，这个 Observable 只会产生一个 error 事件。

//创建一个只有 error 事件的 Observable：
let error: Error = ...
let id = Observable.error(error)

//它相当于：
let error: Error = ...
let id = Observable.create { observer in
    observer.onError(error)
    return Disposables.create()
}
  • filter

仅仅发出 Observable 中通过判定的元素

filter

filter 操作符将通过你提供的判定方法过滤一个 Observable。

let disposeBag = DisposeBag()
Observable.of(2, 30, 22, 5, 60, 1)
          .filter { $0 > 10 }
          .subscribe(onNext: { print($0) })
          .disposed(by: disposeBag)

输出结果：
30
22
60
  • flatMap

将 Observable 的元素转换成其他的 Observable，然后将这些 Observables 合并

flatMap

flatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。 然后将这些 Observables 的元素合并之后再发送出来。

这个操作符是非常有用的，例如，当 Observable 的元素本生拥有其他的 Observable 时，你可以将所有子 Observables 的元素发送出来。

let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "")
let second = BehaviorSubject(value: "️")
let variable = Variable(first)

variable.asObservable()
        .flatMap { $0 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

first.onNext("")
variable.value = second

second.onNext("️")
first.onNext("")
输出结果：



️
️
  • flatMapLatest

将 Observable 的元素转换成其他的 Observable，然后取这些 Observables 中最新的一个

flatMapLatest

flatMapLatest 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。一旦转换出一个新的 Observable，就只发出它的元素，旧的 Observables 的元素将被忽略掉。


tips：与 flatMap 比较更容易理解

let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "")
let second = BehaviorSubject(value: "️")
let variable = Variable(first)

variable.asObservable()
        .flatMapLatest { $0 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

first.onNext("")
variable.value = second
second.onNext("️")
first.onNext("")

输出结果：


️
️
  • from

将其他类型或者数据结构转换为 Observable

from

当你在使用 Observable 时，如果能够直接将其他类型转换为 Observable，这将是非常省事的。from 操作符就提供了这种功能。

//将一个数组转换为 Observable：
let numbers = Observable.from([0, 1, 2])

//它相当于：
let numbers = Observable.create { observer in
    observer.onNext(0)
    observer.onNext(1)
    observer.onNext(2)
    observer.onCompleted()
    return Disposables.create()
}

//将一个可选值转换为 Observable
let optional: Int? = 1
let value = Observable.from(optional: optional)

//它相当于：
let optional: Int? = 1
let value = Observable.create { observer in
    if let element = optional {
        observer.onNext(element)
    }
    observer.onCompleted()
    return Disposables.create()
}
  • just

创建 Observable 发出唯一的一个元素

just

just 操作符将某一个元素转换为 Observable。

//一个序列只有唯一的元素 0：
let id = Observable.just(0)

//它相当于：
let id = Observable.create { observer in
    observer.onNext(0)
    observer.onCompleted()
    return Disposables.create()
}
  • map

通过一个转换函数，将 Observable 的每个元素转换一遍

map

map 操作符将源 Observable 的每个元素应用你提供的转换方法，然后返回含有转换结果的 Observable。

let disposeBag = DisposeBag()
Observable.of(1, 2, 3)
    .map { $0 * 10 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

输出结果：
10
20
30
  • merge

将多个 Observables 合并成一个

merge

通过使用 merge 操作符你可以将多个 Observables 合并成一个，当某一个 Observable 发出一个元素时，他就将这个元素发出。

如果，某一个 Observable 发出一个 onError 事件，那么被合并的 Observable 也会将它发出，并且立即终止序列。

let disposeBag = DisposeBag()
let subject1 = PublishSubject()
let subject2 = PublishSubject()

Observable.of(subject1, subject2)
    .merge()
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

subject1.onNext("A")

subject1.onNext("B")

subject2.onNext("1")

subject2.onNext("2")

subject1.onNext("AB")

subject2.onNext("3")

输出结果：
A
B
1
2
AB
3

你可能感兴趣的:(RxSwift 简单理解)

  • 经验笔记：理解和保障JWT的安全性 漆黑的莫莫 计算机网络笔记
    经验笔记：理解和保障JWT的安全性引言在软件开发领域，特别是Web应用开发中，JWT(JSONWebTokens)是一种广泛使用的认证机制。JWT不仅能够简化客户端与服务端之间的身份验证流程，还能增强数据传输的安全性。本文将深入探讨JWT的工作原理，并重点讲解如何确保JWT在实际应用中的安全性，特别是在防止JWT被篡改方面。JWT的工作原理JWT是一种开放标准（RFC7519），它定义了一种紧凑且
  • ARM的九种寻址方式 Aspirant-GQ S3C2440学习笔记计算机基础ARM寻址
    文章目录1.立即数寻址2.寄存器寻址3.寄存器间接寻址4.寄存器偏移寻址5.寄存器基址变址寻址6.批量寄存器寻址7.相对寻址8.堆栈寻址9.块拷贝寻址寻址方式就是CPU根据指令中的地址信息，找出物理地址也就是内存地址的方式，通俗理解就是ARM指出内存地址的方式。寻址的目的就是找出操作数，比如ARM要做一个除法运算，就需要除数和被除数，除数和被除数都是除法指令的操作数，要找到这些操作数，可以有多种方
  • 7.0 践行打卡 D42 星月格格
    一天不练都不行1.运动打羽毛球呼啦圈2.阅读《高能要事》第七章复读每一次重复去阅读，都会有不一样的感悟与心得，刚开始只能摘抄一些金句，进一步可以顺着思路做一些自己可以做的……不批判他人当在不断的尝试，不断的总结和践行时，可能会理解老师最深层次的一些东西。特别能理解和体会这几句话：是可以通过努力，找到人生方向，那么通过学习，理清思路，找到方法人需在事上磨，方能立得住，如果不去经历，不去磨练，就可能永
  • 微服务的负载均衡不同的场景应用 Wade_Crab 微服务负载均衡架构
    这些负载均衡策略各有不同的优点和应用场景。以下是每种负载均衡策略的详细解释及其适用场景：1.RandomLoadBalance（随机算法）描述:随机算法通过随机选择一个服务器来处理请求。对于性能较好的服务器，可以设置更大的权重值，使得它们被选中的概率更高。应用场景:简单负载分配:适用于服务负载均衡策略较简单的场景。适合负载相对均匀且没有严格性能要求的应用场景。权重调节:通过设置权重，可以在一定程度
  • 没有尽头的日子 左武右文
    吃过早饭带着她信步走进一个长辈家，大学的时候在他家院子里学过简单的刀法，想着他可能还住在这里，就去看看。进入大门后，却只看到一位老人正坐在当门做鞋，不知道姓名，但还是问候了奶奶好，她便热情地邀请我们坐下。问到她在做什么，她回答说出来不怕你笑话，卧迪的奶奶去世时，是我给她穿的寿衣，她那个鞋买小了，脚趾头都难套进去，这不我也担心那样，正给自己做鞋呢，死的时候好穿……活着的人为自己的死做准备，这是一种悲
  • Doctor MichelleNing
    ✨老外说You'rethedoctor，可别理解为“你是医生”！千万别搞错了!‍️‍说起doctor大家首先想到的一般是“医生”不过当外国朋友对你说“You'rethedoctor”可不要理解为“你是医生”对方只是尊重你的想法1“You'rethedoctor”是什么意思？最早的时候You'rethedoctor出现在病人和医生的对话中病人生病了去医院看病医生通过问诊和身体检查以后告诉病人接下来的
  • 浅说——婚姻 一亩田生活资讯
    说说婚姻吧！用我这尚且不成熟的眼光去审视它。也许是因为我和夫携手多年的婚姻历程，让我或多或少的有点感慨和领悟！一直是个柔弱而现实的人。犹记得，那年，母亲的去世，让我觉得自己像逐流在水中的浮萍。家没了，我害怕极了。。。。。。我的成长经历让我对亲情的渴求胜于一切。只是想要一个家，遮风避雨，知冷知暖的家。“他会疼我的”就这样一个最简单，也是最奢侈的理由，我匆匆地把自己嫁了。许多年后的今天，夫仍然会心有不
  • Scratch编程新纪元：网络请求与数据解析的探索之旅 2401_85812053 开发语言
    标题：“Scratch编程新纪元：网络请求与数据解析的探索之旅”引言Scratch，这个由麻省理工学院媒体实验室开发的图形化编程工具，自2007年问世以来，就以其独特的拖拽式编程方式，深受全球青少年编程爱好者的喜爱。它不仅让编程变得简单有趣，更激发了无数孩子的创造力和逻辑思维能力。随着技术的发展，Scratch也在不断进化，那么，它是否支持网络请求和数据解析呢？本文将带你一探究竟。Scratch的
  • 《CSS 3D 变形探秘：开启网页设计新维度》 小刘| css3d前端
    一、移动：精确控制元素位置translate函数为我们提供了强大的移动能力。可以沿x轴、y轴甚至z轴来调整元素的位置。无论是简单地在平面上平移，还是在三维空间中进行精准定位，translate都能轻松胜任。它让元素的布局更加灵活多变，为设计师提供了无限的创意空间。translate(tx[,ty]:沿x轴移动tx距离，沿y轴移动ty的距离ty可以省略，如果省略则ty默认为0ranslate(tx,
  • 计算机网络面试题总结 你臭显摆什么呀
    转载：https://www.cnblogs.com/inception6-lxc/p/9152691.html1.OSI，TCP/IP，五层协议的体系结构，以及各层协议image.png1）物理层该层为上层协议提供了一个传输数据的可靠的物理媒体。简单的说，物理层确保原始的数据可在各种物理媒体上传输。两个重要的设备名称，中继器（Repeater，也叫放大器）和集线器。2）数据链路层该层的作用包括：
  • XSS LABS - Level 17 过关思路 SRC_BLUE_17 网络安全#网络安全靶场笔记xss前端网络安全web安全
    关注这个靶场的其他相关笔记：XSS-LABS——靶场笔记合集-CSDN博客0x01：过关流程进入靶场，空空如也，右击页面，查看网页源码，找找可疑点：可以看到，靶场默认传参，都传递到了标签内，并且分别作为key和value的格式。那这个就很简单了，直接给他传个监听事件即可（这个靶场推荐在Google浏览器中完成，FireFox中容易出现下面这个情况，即标签不显示）。XSSPayload，以及攻击流程
  • 2022-06-22 卿林
    雨点夏天的雨是比太阳更好一些的，当然这是说雨量适可的那种。这两年气候的反常，必须得先说好希望的是怎样的雨。其实，凡事也都是只有适可了才是好。早上出门前专门看了最新的天气预报才关电视，这边是中到大雨，所以在包里装了凉鞋和伞。说到电视，已经被最新人类抛弃不见的电器，我想我是会一直用的，反复看个纪录片，回放或者投屏看球赛，还是习惯电视，操作简单一点。这边的湿热夏天模式已完全开启，雨不下透就更加桑拿。可是
  • K-means聚类算法：从原理到实践的全面解读 一休哥助手 人工智能算法kmeans聚类
    引言在当今数据驱动的时代，机器学习技术的发展已经成为各行各业的重要驱动力。在机器学习中，聚类算法是一类被广泛应用的技术之一。聚类旨在将数据集中的样本划分为不同的组，使得组内的样本相似度高，组间的相似度低。K-means聚类算法作为聚类算法中的一种经典方法，因其简单、高效的特性被广泛应用于各个领域。在本文中，我们将深入探讨K-means聚类算法，从基本原理到实际应用，以及算法的优化和实现方法。首先，
  • 20190109素心慢时光～每个人都希望被温柔以待 素心001
    20190109·大雪当一个人被认同、理解、尊重的时候，一般都会比较柔软。中午在姐妹几个的小群里进行了一场头脑风暴，小妹是个很努力且要强的人，她发了一些近期学习的收获和见解，我正忙着看了一遍之后没顾上寒暄直截了当的指出存在的问题，小妹向我提建议说我应该先鼓励赞扬下她然后再批评，一上来就直接挑毛病是泼了她的冷水。我顿住想了一下，噢，也对，她满心欢喜的在努力学习，有了收获出来分享，观点成熟也好不成熟也
  • 有时候，我们的一句随口说说，却是孩子的整个世界...... 美式学习零距离
    跟我小时候比起来，现在的孩子生活条件好了，各种物质诱惑也多。而孩子在学习道路上，父母也会紧跟其后，不断督促孩子认真学习，生怕自己一放松，孩子功课就会落下。如果这时我问一个问题，“让你一个月不管孩子的学习行不行？”家长们肯定纷纷跳出来，“那怎么行！孩子不自觉，我不督促的话，他肯定不会认真学习了”。虽然说，孩子的学习在一定程度上，取决于父母对孩子的关注有多少，但从这个简单的问题中，其实还折射出了另一个
  • 用户故事3：用户故事该怎么写？ Clorio
    实际的开发过程中，我们运用如禅道、TAPD等团队协作软件建立管理用户故事，对于故事我们就可以进行更加丰富的记录，一个完整的用户故事需要写的内容包含：展现形式如下：（1）故事标题用户故事的描述在列表中进行管理时，不利于快速理解，也不能一行展示。为每个故事取个标题（名字）就很有必要，而且像禅道、TAPD软件的需求表述格式中标题也是必填项。就行邮件的主题，用户故事的标题是为了让读者能快速了解这个用户故事
  • 互联网最火的创业项目，今年网上最火的赚钱项目是什么？ 好项目高省
    很多年轻人想要自己创业，但是一开始他们都非常迷茫，不知道什么行业的前景比较好，什么行业最能挣钱，有哪些好的创业项目推荐？其实，做项目不是大家看好，而是自己看好，大家看好的生意还有你的机会吗？而要找适合自己发展的项目。二、都有哪些创业致富项目？现在新冠已经全面开放，地摊经济开始了，可以学简易好做的1.关于油炸类，只需要穿串，备好调味料2.米线类，也是提前调好口味，煮熟米线等可以3.肉夹馍等等都是简单
  • 后端开发刷题 | 面试篇4 jingling555 面试面试职场和发展java开发语言
    Redis有哪些数据类型字符串（Strings）：字符串是Redis中最基本的数据类型，它可以包含任何类型的数据，如整数、浮点数、字符串等。Redis的字符串是二进制安全的，这意味着你可以在其中存储任何类型的数据，如图片或序列化的对象。列表（Lists）：Redis的列表是简单的字符串列表，按照插入顺序排序。你可以从列表的两端添加或删除元素。列表的一个常见用途是消息队列。集合（Sets）：Redi
  • Spring Cloud全解析：网关之GateWay简介 拾光师 springcloudjava
    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
  • 留给思考的时间越来越少了 化浊
    标题这话是从哪儿冒出来的呢？哦，中国男足。但凡转播男足的比赛，临近末尾，主持人们经常需要艰难地喊一声，“留给中国男足的时间越来越少了。”这不，我也依样画葫芦，喊一句“留给思考的时间越来越少了”。之所以有这样的感慨，兴许是因前一阵，抖音突然大火。大家看着很乐呵，刷刷刷，不知不觉一天就过去了。相比阅读，看视频显然是更不需费脑的，而相比普通的视频，十五秒的短视频，则更直接、更不需深思，简简单单地刺激人的
  • «人生的意义»“提问与回答”读后感 那就明天早起
    其实从懂事就开始思考，我们活着的意义是什么，有些思想家认为人生的意义问题本身并没有意义，说是意义是一个语言层面的东西，无关实体，第一章我就反复看了几遍，感觉作者讲的东西有些深奥甚至生涩难懂，但是我认为这也是一个困扰了很多人并且值得思考的问题。我认为其实人生的目的很简单，就是活的开心快乐，而这又分为两个层次，一个是身体上的，还有精神上的。在«哲学研究»这本著作中，维特斯根告诉我们，语法可以蒙蔽人的的
  • 理解链接之链接的基本概念 Yonah潇
    前言我们知道，开发程序的基本流程是：设计-代码编写-编译-链接-执行每一个步骤展开都是一个很大的课题，链接是一个被人忽略的课题，因为它并不是很复杂，相对于编译来说它还是比较简单的，但是并不代表它不重要。现在编译链接的环节基本上由IDE帮助我们完成了，于是我们很少关注编译链接。虽然说不懂编译链接对开发程序并没有很大影响，但是如果要成为大牛，计算机底层的知识还是要掌握的。编译的知识很多，不是几篇文章能
  • java实用工具类hutool 华木公子
    cn.hutoolhutool-all5.5.8Hutool工具详细教程地址:###模块介绍1.hutool-aopJDK动态代理封装，提供非IOC下的切面支持；2.hutool-bloomFilter布隆过滤，提供一些Hash算法的布隆过滤；3.hutool-cache简单缓存实现；4.hutool-core核心，包括Bean操作,日期，各种Util等等；5.hutool-cron定时任务模块，
  • Elasticsearch 压测方案之 esrally 简介 叫小七的剑客
    由于Elasticsearch（后文简称es）的简单易用及其在大数据处理方面的良好性能，越来越多的公司选用es作为自己的业务解决方案。然而在引入新的解决方案前，不免要做一番调研和测试，本文便是介绍官方的一个es压测工具esrally，希望能为大家带来帮助。为什么要压测？关于压测，我们先来看下百度百科上的一个定义。压测，即压力测试，是确立系统稳定性的一种测试方法，通常在系统正常运作范围之外进行，以考
  • 排序算法之插入排序详细解读（附带Java代码解读） 南城花随雪。 算法分析排序算法java算法
    插入排序（InsertionSort）是一种简单直观的排序算法，通常用于少量数据的排序。它的工作方式与我们整理扑克牌类似：每次将一张牌插入到已经排好序的牌堆中。算法思想开始排序：假设第一个元素已经排好序。逐步插入：从第二个元素开始，依次将每个元素插入到前面已经排好序的部分，使得插入后依然有序。重复步骤2：直到数组的最后一个元素。过程示例假设有一个待排序的数组：[12,11,13,5,6]初始状态:
  • Openlayers用图片填充面 Jinuss 玩转OpenlayersjavascriptOplayers
    概述我们知道openlayers通常设置feature要素的方式主要是通过ol.style.stroke描边和ol.style.fill填充,这对比较简单的样式设置十分有效。如果要设置feature的图标，还可以通过ol.style.Icon加载外部图片资源，但是如果要设置面的填充，就需要稍微复杂的设置。效果解决方案colorlikeopenlayers中定义了colorlike类型,通过ol.c
  • Openlayers用图片填充线 Jinuss 玩转Openlayers前端Oplayers前端
    概述上文中提过Openlayers如何用图片填充面，那么我们如何用图片或图标去填充线条呢？在面的填充，我们是平铺的，没有方向，在水平垂直方向重复就完事，但是在线的填充就没有这么简单粗暴了，因为线往往是首尾两端有方向的，比如当线条表示线路图时，pattern就有些力不从心了。效果解决方案StyleFunctionOpenlayers中设置样式除了Style的stroke和fill往，还提供了另一种方
  • 探索C++设计模式：一个实用的学习资源 曹俐莉
    探索C++设计模式：一个实用的学习资源项目简介在编程世界中，设计模式是解决常见问题的最佳实践和模板，它们为复杂软件设计提供了可重用的解决方案。是一个专门针对C++编程语言的设计模式实现库。这个开源项目不仅提供了各种设计模式的实例代码，还包含了详细的注释和解释，帮助开发者理解和应用这些模式。技术分析该项目覆盖了GOF（Gamma,Erich;Helm,Richard;Johnson,Ralph;Vl
  • CSS属性 - display coolchaobing 前端学习小记css前端css3
    CSS中有个display属性，能修改元素的显示类型，有4个常用值block：让元素显示为块级元素；inline：让元素显示为行内级元素；inline-block：让元素同时具备行内级、块级元素的特征；none：隐藏元素；特性block元素独占父元素的一行；可以随意设置宽高；高度默认由内容决定；inline-block元素跟其他行内级元素在同一行显示；可以随意设置宽高；可以这样理解；✓对外来说，它
  • IDEA集成Resin Java_xiaoman
    由于公司的线上是使用的Resin,就强制我们本地调试都使用Resin,简单装了一下;官网:https://caucho.com/1.下载,解压,放到喜欢的地方;image.png2.idea安装resin插件image.png3.配置启动image.pngimage.pngimage.png开始你的表演吧;
  • tomcat基础与部署发布 暗黑小菠萝 Tomcat java web
    从51cto搬家了，以后会更新在这里方便自己查看。 做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 一、Tomcat安装     安装方式：①运行.exe安装包      &n
  • 网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
  • [信息与安全]数据库的备份问题 comsci 数据库
          如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题   如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢?    是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢?  &n
  • 使用maven tomcat plugin插件debug关联源代码 商人shang mavendebug查看源码tomcat-plugin
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
  • 大访问量高并发 oloz 大访问量高并发
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
  • cache 服务器 小猪猪08 cache
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 　　1.Cache   是怎么样工作的? 　　Cache   是分配在服务器上
  • mysql存储过程 香水浓 mysql
    Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
  • CSS的class、id、css文件名的常用命名规则 agevs JavaScriptUI框架Ajaxcss
      CSS的class、id、css文件名的常用命名规则     (一)常用的CSS命名规则 　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
  • 全局数据源 AILIKES javatomcatmysqljdbcJNDI
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
  • MYSQL的随机查询的实现方法 baalwolf mysql
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
  • JAVA的getBytes()方法 bijian1013 javaeclipseunixOS
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！      String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
  • AngularJS中操作Cookies bijian1013 JavaScriptAngularJSCookies
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。         幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
  • [Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
    Maven聚合   在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
  • 【JVM七】JVM知识点总结 bit1129 jvm
      1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
  • linux下查看nginx、apache、mysql、php的编译参数 ronin47
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
  • unity中运用Resources.Load的方法？ brotherlamp unity视频unity资料unity自学unityunity教程
    问：unity中运用Resources.Load的方法？ 答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
  • 线段树-入门 bylijinnan java算法线段树
    /** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
  • 全选与反选 chicony 全选
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
  • vim一些简单记录 chenchao051 vim
    mac在/usr/share/vim/vimrc linux在/etc/vimrc   1、问：后退键不能删除数据，不能往后退怎么办？       答：在vimrc中加入set backspace=2   2、问：如何控制tab键的缩进？       答：在vimrc中加入set tabstop=4 (任何
  • Sublime Text 快捷键 daizj 快捷键sublime
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
  • php 引用(&)详解 dcj3sjt126com PHP
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容  复制代码代码如下: <?  $a="ABC";  $b =&$a;  echo
  • SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
  • 对软件设计的思考 e200702084 设计模式数据结构算法ssh活动
    软件设计的宏观与微观    软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
  • 同步、异步、阻塞、非阻塞 geeksun 非阻塞
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。   同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。   异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 实现：
  • Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
    實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
  • Hibernate中的缓存 Josh_Persistence 一级缓存Hiberante缓存查询缓存二级缓存
    Hibernate中的缓存   一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
  • 对象关系行为模式之延迟加载 home198979 PHP架构延迟加载
    形象化设计模式实战     HELLO!架构   一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。     二、实现延迟加载 实现Lazy Load主要有四种方法：延迟初始化、虚
  • xml 验证 pengfeicao521 xmlxml解析
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
  • div设置半透明效果 spjich css半透明
    为div设置如下样式：   div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}        说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
  • 你真的了解单例模式么？ w574240966 java单例设计模式jvm
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。   一，单例模式的5中写法。（回字的四种写法，哈哈。）     1，懒汉式           （1）线程不安全的懒汉式 public cla
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他