february29
february29

Getting started with RxSwift(译)

Getting Started

（RxSwift）的用法会尽量与ReactiveX.io官方文档保持一致。其他常见的跨平台文档和教程对RxSwift也应当有效。

  1. Observables aka Sequences
  2. Disposing
  3. 创建你自己的 Observable
  4. 创建一个执行工作的Observable
  5. 分享订阅和shareReplay操作符
  6. Operators（操作符）
  7. Playgrounds
  8. 错误处理
  9. 调试
  10. Variables
  11. KVO
  12. UI layer tips
  13. Making HTTP requests
  14. RxDataSources

Observables aka Sequences

Basics

你可以同观察者模式(Observable sequence) 和普通序列(Sequence)的对比来理解Rx，这也是理解Rx最重要的事情。

每一个Observable 序列都是一个序列，Observable对比Swift的Sequence最大的优势是它可以异步的接受元素。这是RxSwift的核心。这里的文档是我们展开来介绍这个理念的。

  1. Observable(ObservableType)等价于 Sequence（序列）。
  2. ObservableType.subscribe 方法等价于 Sequence.makeIterator method.
  3. Observable回掉要被传递到ObservableType.subscribe来接受元素，类似于next() 返回的 iterator。

序列是一个简单、熟悉并且容易理解概念。
人类是一个拥有强大视觉皮层的动物，当我们要理解一个概念时，可视化概念能帮我们更加容易的理解。
通过尝试模拟每一个Rx操作符内部的事件状态机，我们能够更容易理解Rx。
在一个异步模型的系统中，如果我们不用Rx，很可能意味着我们的代码充满了状态机和暂时的状态需要我们模拟。
list和序列可能是我们学习数学和程序最先了解的概念。
这是一个数字序列

--1--2--3--4--5--6--| // terminates normally

另一个字母序列

--a--b--a--a--a---d---X // terminates with error

一些序列序列时有限的一些是无限的，比如按钮的tap序列。

---tap-tap-------tap--->

上述表示法方法叫做marble diagrams。这里可以看到更多的marble diagrams rxmarbles.com.
如果我们指定序列语法作为一个有规律的表达，可以写成这样：
next (error | completed)?*
这个表达了下面的意思：

  • 一个序列可以有0个或或者多个元素
  • 序列一旦接受到error或者completed事件，那么这个序列将不会产生新的元素。

序列（Observable）定义如下。

enum Event  {
    case next(Element)      // next element of a sequence
    case error(Swift.Error) // sequence failed with error
    case completed          // sequence terminated successfully
}

class Observable {
    func subscribe(_ observer: Observer) -> Disposable
}

protocol ObserverType {
    func on(_ event: Event)
}

序列发送completed或者error方法后这个序列内的所有元素将会被释放。
调用返回的subscription中的dispose方法将会取消产生新的元素，并且立即释放元素。

如果一个序列在有限的时间内中断，没有调用dispose或者disposed(by: disposeBag)方法并不会导致资源泄漏。并且，这些资源能够被使用直到这个序列完成（不在产生新的元素，或者调用error）。
如果一个序列自身并没有中断，比如按钮的tap事件，资源就会被永久地分配，除非使用takeUntil操作符或者其他方式来手工调用调用dispose，或者disposeBag内部自动调用。

Disposing

当我们正在序列上做某些操作时想要释放所有已经分配或者即将被分配的资源。有一种额外的方法可以中断序列。调用dispose方法。

例如

let scheduler = SerialDispatchQueueScheduler(qos: .default)
let subscription = Observable.interval(0.3, scheduler: scheduler)
    .subscribe { event in
        print(event)
    }

Thread.sleep(forTimeInterval: 2.0)

subscription.dispose()

打印

next(0)
next(1)
next(2)
next(3)
next(4)
next(5)

注意：手动调用dispose方法并不是一个好的编码习惯，有更好的方式来dispose subscription 比如使用DisposeBag，takeUntil操作符或者其他方式。

那么上述代码在调用dispose()方法后还会输出东西么，答案是，不一定。
如果这个scheduler是一个 serial scheduler(例如 MainScheduler) 并且dispose是在同一个serial scheduler当中调用，答案是。不会再输出。否则，答案是，会在输出。

你有两个平行进程

  1. 一个正在产生元素。
  2. 另一个正在dispose（清除）

上述关于调用是否会打印的问题仍然会存在，如果两个进程并不再同一个进程。
下面代码会调用dispose后不会在输出。

let subscription = Observable.interval(0.3, scheduler: scheduler)
            .observeOn(MainScheduler.instance)
            .subscribe { event in
                print(event)
            }

// ....

subscription.dispose() // called from main thread


let subscription = Observable.interval(0.3, scheduler: scheduler)
            .observeOn(serialScheduler)
            .subscribe { event in
                print(event)
            }

// ...

subscription.dispose() // executing on same `serialScheduler`

Dispose Bags

Dispose Bags在RX中如同ARC。
当申明一个DisposeBag后，每次添加disposables 时dispose会被调用。DisposeBag没有dispose方法，所以不能够明确的dispose方法。如果需要立即cleanup 只需要重新生成一个新的。

self.disposeBag = DisposeBag()

如果仍然有手动的需要，使用CompositeDisposable，他能满足这个需求，但是一旦调用dispose方法，他就会立即清理新加入的disposable。

Take until

另外的自动清理subscription的方法是takeUntil操作符。

sequence
    .takeUntil(self.rx.deallocated)
    .subscribe {
        print($0)
    }

Implicit Observable guarantees（Observable默许的保证）

有一对额外的保证，所有的序列必须遵守。

  1. 无论Observable在哪一个进程产生了元素，如果Observable创建一个元素并且发送到observer（观察者）的observer.on(.next(nextElement))，那么直到observer.on 执行完毕，不能再发送下一个元素。
  2. 也不能发送中断.completed 或者 .error。

考虑下面代码

someObservable
  .subscribe { (e: Event) in
      print("Event processing started")
      // processing
      print("Event processing ended")
  }

他会输出

Event processing started
Event processing ended
Event processing started
Event processing ended
Event processing started
Event processing ended

不会输出

Event processing started
Event processing started
Event processing ended
Event processing ended

创建你自己的 Observable

理解Observable至关重要的一点：
当一个Observable被创建以后，他不会做任何事。

Observable有很多种方式创建元素。一些是因为边界影响，一些是因为点击正在运行的进程例如点击鼠标等等。

然而，如果你只是调用一个方法返回一个Observable，序列不会执行生产，并且没有边界影响。Observable只是声明序列怎样生产，元素用什么参数生产。subscribe方法调用的时候开始生产元素。

例如你有一个类似下面的方法：

func searchWikipedia(searchTerm: String) -> Observable {}

let searchForMe = searchWikipedia("me")

// no requests are performed, no work is being done, no URL requests were fired

let cancel = searchForMe
  // sequence generation starts now, URL requests are fired
  .subscribe(onNext: { results in
      print(results)
  })

有很多方法能够创建Observable，最简单的方法可能是使用create方法。

让我们写一个方法创建一个返回一个元素序列的方法,这个方法叫做'just'这是其实现

func myJust(_ element: E) -> Observable {
    return Observable.create { observer in
        observer.on(.next(element))
        observer.on(.completed)
        return Disposables.create()
    }
}

myJust(0)
    .subscribe(onNext: { n in
      print(n)
    })

结果

0

那么到底什么是create方法呢？

他只是一个方便的方法，能够让你用swift闭包轻松的实现subscribe。subscribe方法携带一个参数observer，返回一个disposable。
这样实现的序列是同步的，他会在subscribe调用返回 disposable之前产生元素或者中断。因为他实际上根returns的什么无关，所以生产元素的过程不能被打断。

当产生同步序列时，通常返回的disposable是NopDisposable的单例

func myFrom(_ sequence: [E]) -> Observable {
    return Observable.create { observer in
        for element in sequence {
            observer.on(.next(element))
        }

        observer.on(.completed)
        return Disposables.create()
    }
}

let stringCounter = myFrom(["first", "second"])

print("Started ----")

// first time
stringCounter
    .subscribe(onNext: { n in
        print(n)
    })

print("----")

// again
stringCounter
    .subscribe(onNext: { n in
        print(n)
    })

print("Ended ----")

输出

Started ----
first
second
----
first
second
Ended ----

创建一个执行工作的Observable

事情变的越来约有趣了，现在让我们创建一个之前我们用到的interval操作符。
下面是

func myInterval(_ interval: TimeInterval) -> Observable {
    return Observable.create { observer in
        print("Subscribed")
        let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global())
        timer.scheduleRepeating(deadline: DispatchTime.now() + interval, interval: interval)

        let cancel = Disposables.create {
            print("Disposed")
            timer.cancel()
        }

        var next = 0
        timer.setEventHandler {
            if cancel.isDisposed {
                return
            }
            observer.on(.next(next))
            next += 1
        }
        timer.resume()

        return cancel
    }
}
let counter = myInterval(0.1)

print("Started ----")

let subscription = counter
    .subscribe(onNext: { n in
        print(n)
    })


Thread.sleep(forTimeInterval: 0.5)

subscription.dispose()

print("Ended ----")

输出

Started ----
Subscribed
0
1
2
3
4
Disposed
Ended ----

如果你这样写

let counter = myInterval(0.1)

print("Started ----")

let subscription1 = counter
    .subscribe(onNext: { n in
        print("First \(n)")
    })
let subscription2 = counter
    .subscribe(onNext: { n in
        print("Second \(n)")
    })

Thread.sleep(forTimeInterval: 0.5)

subscription1.dispose()

Thread.sleep(forTimeInterval: 0.5)

subscription2.dispose()

print("Ended ----")

将会输出

Started ----
Subscribed
Subscribed
First 0
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
Disposed
Second 5
Second 6
Second 7
Second 8
Second 9
Disposed
Ended ----

订阅的每一个订阅者产生他自己的分离的元素序列，操作符默认是没有状态的。极大部分操作符都是没有状态的。

分享订阅和shareReplay操作符

如果你想几个observers分享同一个订阅的事件（元素）怎么做呢？
有两点需要声明

  1. 新订阅者开始观察之前怎样处理过去已经受到的元素。（重放最近一个，重放全部，重放最后n个）。
  2. 怎样决定何时开始共享的订阅。（重新计数，手动或者其他算法）

通常的选择是一个混合体replay(1).refCount()又称作shareReplay()。

let counter = myInterval(0.1)
    .shareReplay(1)

print("Started ----")

let subscription1 = counter
    .subscribe(onNext: { n in
        print("First \(n)")
    })
let subscription2 = counter
    .subscribe(onNext: { n in
        print("Second \(n)")
    })

Thread.sleep(forTimeInterval: 0.5)

subscription1.dispose()

Thread.sleep(forTimeInterval: 0.5)

subscription2.dispose()

print("Ended ----")

输出

Started ----
Subscribed
First 0
Second 0
First 1
Second 1
First 2
Second 2
First 3
Second 3
First 4
Second 4
First 5
Second 5
Second 6
Second 7
Second 8
Second 9
Disposed
Ended ----

注意以上代码只有一个Subscribed和Disposed被调用。

观察URL也一样。下面是怎样用rx包装HTTP请求，同interval操作符有很多类似的地方。

extension Reactive where Base: URLSession {
    public func response(_ request: URLRequest) -> Observable<(Data, HTTPURLResponse)> {
        return Observable.create { observer in
            let task = self.dataTaskWithRequest(request) { (data, response, error) in
                guard let response = response, let data = data else {
                    observer.on(.error(error ?? RxCocoaURLError.Unknown))
                    return
                }

                guard let httpResponse = response as? HTTPURLResponse else {
                    observer.on(.error(RxCocoaURLError.nonHTTPResponse(response: response)))
                    return
                }

                observer.on(.next(data, httpResponse))
                observer.on(.completed)
            }

            task.resume()

            return Disposables.create {
                task.cancel()
            }
        }
    }
}

Operators（操作符）

RxSwift中实现了很多操作符。
操作符示意图可以在ReactiveX.io中查看
几乎所有的操作符示范可以在Playgrounds查看
使用这个Playgrounds请打开Rx.xcworkspace，编译RxSwift-macOS，然后在Rx.xcworkspace 树形图中打开Playgrounds。
如果你需要一个操作符，并且你不知道怎样找到他可以通过这里decision tree of operators

自定义操作符

有两种方式 可以自定义操作符

简单方式

所有的内部代码都是使用操作符高度优化的版本。所以他们不是最好的工具，这就是他为什么鼓励使用标准的操作符。
幸运的，有一种简单的方式来创建操作符。创建新的操作符的确是创建observables的一切。前面已经介绍过怎样创建操作符。
让我们看看map操作符是怎样实现的

extension ObservableType {
    func myMap(transform: @escaping (E) -> R) -> Observable {
        return Observable.create { observer in
            let subscription = self.subscribe { e in
                    switch e {
                    case .next(let value):
                        let result = transform(value)
                        observer.on(.next(result))
                    case .error(let error):
                        observer.on(.error(error))
                    case .completed:
                        observer.on(.completed)
                    }
                }

            return subscription
        }
    }
}

你可以这样使用它

let subscription = myInterval(0.1)
    .myMap { e in
        return "This is simply \(e)"
    }
    .subscribe(onNext: { n in
        print(n)
    })

输出

Subscribed
This is simply 0
This is simply 1
This is simply 2
This is simply 3
This is simply 4
This is simply 5
This is simply 6
This is simply 7
This is simply 8
...

Life happens 实际发生的

如果遇到使用自定义操作符也很难解决的情况怎么办呢？你可以先推出Rx，执行行动，然后再将结果传递给Rx用Subject s。

这种情况通常不应该被实践，这也不是一个好的编码习惯，但是你可以这样做。

let magicBeings: Observable = summonFromMiddleEarth()

  magicBeings
    .subscribe(onNext: { being in     // exit the Rx monad
        self.doSomeStateMagic(being)
    })
    .disposed(by: disposeBag)

  //
  //  Mess
  //
  let kitten = globalParty(   // calculate something in messy world
    being,
    UIApplication.delegate.dataSomething.attendees
  )
  kittens.on(.next(kitten))   // send result back to rx
  //
  // Another mess
  //

  let kittens = Variable(firstKitten) // again back in Rx monad

  kittens.asObservable()
    .map { kitten in
      return kitten.purr()
    }
    // ....

每次这样做，一些人会这样写

 kittens
    .subscribe(onNext: { kitten in
      // do something with kitten
    })
    .disposed(by: disposeBag)

所以尽量不要这样做。

Playgrounds

如果你不确定一个操作符的确切使用方法。playgrounds几乎包含了所有的用法。并且有实例有插图。
使用这个Playgrounds请打开Rx.xcworkspace，编译RxSwift-macOS，然后在Rx.xcworkspace 树形图中打开Playgrounds。
如果要在Playgrounds中查看例子的视图。打开Assistant Editor，你可以点击View > Assistant Editor > Show Assistant Editor打开Assistant Editor。

错误处理

有两种错误机制。

observables异步错误处理机制

错误处理比较简单。如果一个序列因为错误中断。那么所有相关的序列就会中断。断路逻辑。
你可以通过catch操作符修复错误的observables。有很多重载能让你在细节上具体修复。

调试编译错误

当写优雅的RxSwift/RxCocoa代码时。你将很依赖编译器来推断observables类型，这也是为什么swift让人惊叹。但是有时候这也会成为阻挠。

images = word
    .filter { $0.containsString("important") }
    .flatMap { word in
        return self.api.loadFlickrFeed("karate")
            .catchError { error in
                return just(JSON(1))
            }
      }

如果编译器报错，首先建议声明返回类型

images = word
    .filter { s -> Bool in s.containsString("important") }
    .flatMap { word -> Observable in
        return self.api.loadFlickrFeed("karate")
            .catchError { error -> Observable in
                return just(JSON(1))
            }
      }

如果还不能通过。你可以添加更多的声明

images = word
    .filter { (s: String) -> Bool in s.containsString("important") }
    .flatMap { (word: String) -> Observable in
        return self.api.loadFlickrFeed("karate")
            .catchError { (error: Error) -> Observable in
                return just(JSON(1))
            }
      }

建议首先声明闭包的返回类型和参数。
通常情况下如果解决了这个问题，你可以重新去掉声明来让你的代码清洁。

调试

单独使用debugger很有用，但是通常使用debug操作符更高效。debug操作符将会输出所有的事件，你也可以为这些事件添加标签。

debug就像一个调查，下面是一个示例

let subscription = myInterval(0.1)
    .debug("my probe")
    .map { e in
        return "This is simply \(e)"
    }
    .subscribe(onNext: { n in
        print(n)
    })

Thread.sleepForTimeInterval(0.5)

subscription.dispose()

输出

[my probe] subscribed
Subscribed
[my probe] -> Event next(Box(0))
This is simply 0
[my probe] -> Event next(Box(1))
This is simply 1
[my probe] -> Event next(Box(2))
This is simply 2
[my probe] -> Event next(Box(3))
This is simply 3
[my probe] -> Event next(Box(4))
This is simply 4
[my probe] dispose
Disposed

你也可以轻松的创建你自己版本的debug擦作符

extension ObservableType {
    public func myDebug(identifier: String) -> Observable {
        return Observable.create { observer in
            print("subscribed \(identifier)")
            let subscription = self.subscribe { e in
                print("event \(identifier)  \(e)")
                switch e {
                case .next(let value):
                    observer.on(.next(value))

                case .error(let error):
                    observer.on(.error(error))

                case .completed:
                    observer.on(.completed)
                }
            }
            return Disposables.create {
                   print("disposing \(identifier)")
                   subscription.dispose()
            }
        }
    }
 }

Enabling Debug Mode

为了用RxSwift.Resources调试内存泄漏，或者自动log所有的HTTP请求。你必须Enabling Debug Mode。
为了Enabling Debug Mode， 一个TRACE_RESOURCES标志必须被添加到RxSwift的编译设置里面。在其他swift标记的下面。
深入的描述和介绍怎样为Cocoapods & Carthage添加TRACE_RESOURCES可以参见这里
378

调试内存泄漏

在debug mode中Rx在全局变量Resources.total中记录所有的资源分配足迹。

如果你想要一个倒置资源泄漏的逻辑，最简单的方法就是printing RxSwift.Resources.total

/* add somewhere in
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil)
    */
    _ = Observable.interval(1, scheduler: MainScheduler.instance)
        .subscribe(onNext: { _ in
            print("Resource count \(RxSwift.Resources.total)")
        })

最高效的测试内存管理泄漏

  • 导航到你要测试屏幕并且使用它
  • 返回
  • 观察初始化的资源数
  • 第二次进入你要测试的屏幕并且使用它
  • 返回
  • 查看最后的资源数

如果初始化的资源数和最后的资源数不同，那么就可能存在内存泄漏。
两次导航的是因为第一次导航时强制加载了懒加载的资源。

Variables

Variables 呈现了一些observable的状态。没有包含值的Variable是不存在的，因为Variable初始化时需要一个值。
Variable包装了一个 Subject
. 跟确切地说是一个BehaviorSubject。跟BehaviorSubject不同的是，它只暴露value的接口，所以Variables不能用error中断。

他也会在subscription是广播它现在的值。

在variable 被 deallocated之后,他会通过.asObservable()来返回observable序列。

let variable = Variable(0)

print("Before first subscription ---")

_ = variable.asObservable()
    .subscribe(onNext: { n in
        print("First \(n)")
    }, onCompleted: {
        print("Completed 1")
    })

print("Before send 1")

variable.value = 1

print("Before second subscription ---")

_ = variable.asObservable()
    .subscribe(onNext: { n in
        print("Second \(n)")
    }, onCompleted: {
        print("Completed 2")
    })

print("Before send 2")

variable.value = 2

print("End ---")

输出

Before first subscription ---
First 0
Before send 1
First 1
Before second subscription ---
Second 1
Before send 2
First 2
Second 2
End ---
Completed 1
Completed 2

KVO

KVO是一个Objective-C的机制。这就意味值它并不是类型安全的。这个工程尝试去解决这个问题。
有两种方式支持KVO。

// KVO
extension Reactive where Base: NSObject {
    public func observe(type: E.Type, _ keyPath: String, options: KeyValueObservingOptions, retainSelf: Bool = true) -> Observable {}
}

#if !DISABLE_SWIZZLING
// KVO
extension Reactive where Base: NSObject {
    public func observeWeakly(type: E.Type, _ keyPath: String, options: KeyValueObservingOptions) -> Observable {}
}
#endif

怎么监听 UIView的frame
WARNING: UIKit isn't KVO compliant, but this will work.

view
  .rx.observe(CGRect.self, "frame")
  .subscribe(onNext: { frame in
    ...
  })

or

view
  .rx.observeWeakly(CGRect.self, "frame")
  .subscribe(onNext: { frame in
    ...
  })

rx.observe

rx.observe 是KVO机制的一个简单包装，但是它有更多的使用场景。

  • 它能够用来观察以self开头的路径，或者在继承图中以祖先开头的路径(retainSelf = false)
  • 它能够用来观察在继承图中以后代开头的路径(retainSelf = true)
  • 路径必须是strong的，另外如果没有注销KVO监听，会有crashing的风险。

例如：

self.rx.observe(CGRect.self, "view.frame", retainSelf: false)

rx.observeWeakly

rx.observeWeakly相对rx.observe要更加耗时一些，因为它会在弱引用时处理对象的存储单元分配。
rx.observe能够使用的场景rx.observeWeakly都能够使用。

  • 因为它不会retain被观察的目标，所以它能够观察继承图不明确的对象。
  • 它能够观察weak属性
    例如：
someSuspiciousViewController.rx.observeWeakly(Bool.self, "behavingOk")

Observing structs

KVO是Objective-C 的机制，所以它严重依赖NSValue。
RxCocoa 能够实现对CGRect, CGSize and CGPoint structs 的KVO监听。
当需要对其他struct进行监听的时候，需要手动的从NSValue提取structure。
这里 是一个通过实现KVORepresentable协议为其他structs拓展KVO机制和rx.observe*方法的示范，

UI layer tips

当绑定到UIKit controls时，在UI层中，有明确的几点你的Observables需要满足。

Threading

Observables要在MainScheduler（UIThread）中发送值。这也是UIKit/Cocoa中要求的。
你的APIs在MainScheduler中返回结果是一个很好的方式，如果你在后台线程中绑定控件，Debug编译RxCocoa时会抛出一个异常提示你。
为了解决这个问题你要添加 observeOn(MainScheduler.instance).
URLSession extensions 默认不是在MainScheduler返回结果

Errors

你不能为UIKit controls绑定失败，因为那是没有定义的行为。
如果你不知道是否Observable会失败，你可以使用catchErrorJustReturn(valueThatIsReturnedWhenErrorHappens)来确保它不会失败，但是如果一个错误发生之后的序列仍然完整。
如果你想要后续序列的行为继续产生元素，需要使用一些retry的版本。

Sharing subscription

有时候你需要在你的UI层分享订阅，但是你不想让分离的HTTP请求来为成倍的UI元素绑定同样的数据。
你可以这样做

let searchResults = searchText
    .throttle(0.3, $.mainScheduler)
    .distinctUntilChanged
    .flatMapLatest { query in
        API.getSearchResults(query)
            .retry(3)
            .startWith([]) // clears results on new search term
            .catchErrorJustReturn([])
    }
    .shareReplay(1)          // <- notice the `shareReplay` operator

你通常想要的是一旦有结果就分享搜索的结果。这也是shareReplay意义所在。
UI层中在变化链末尾添加shareReplay是一个shareReplay是一个很好的经验法则，因为你真的想要分享计算结果。而不想在为成倍的界面元素绑定searchResults时开启分离的请求链接。
你也可以看看Driver单元，他是为包装这种shareReply请求，确保元素在主线程被观察并且没有错误倍绑定到UI而专门设计的。

Making HTTP requests

网络请求是首先要做的事情之一。
首先要绑定URLRequest对象，这个对象体现了你要做的工作。
Request决定了它是一个get或者post请求，请求body是什么，参数是什么。
这是一个怎样创建get请求的代码：

let req = URLRequest(url: URL(string: "http://en.wikipedia.org/w/api.php?action=parse&page=Pizza&format=json"))

如果只是想在其他observables之外执行这个请求：

let responseJSON = URLSession.shared.rx.json(request: req)

// no requests will be performed up to this point
// `responseJSON` is just a description how to fetch the response


let cancelRequest = responseJSON
    // this will fire the request
    .subscribe(onNext: { json in
        print(json)
    })

Thread.sleep(forTimeInterval: 3.0)

// if you want to cancel request after 3 seconds have passed just call
cancelRequest.dispose()

默认情况下URLSession extensions不在主线程返回结果。
如果你想要看更低层一些的响应入口：

URLSession.shared.rx.response(myURLRequest)
    .debug("my request") // this will print out information to console
    .flatMap { (data: NSData, response: URLResponse) -> Observable in
        if let response = response as? HTTPURLResponse {
            if 200 ..< 300 ~= response.statusCode {
                return just(transform(data))
            }
            else {
                return Observable.error(yourNSError)
            }
        }
        else {
            rxFatalError("response = nil")
            return Observable.error(yourNSError)
        }
    }
    .subscribe { event in
        print(event) // if error happened, this will also print out error to console
    }

Logging HTTP traffic

debug模式RxCocoa默认会打印所有的网络请求，如果不想这样，请设置Logging.URLRequests过滤器。

// read your own configuration
public struct Logging {
    public typealias LogURLRequest = (URLRequest) -> Bool

    public static var URLRequests: LogURLRequest =  { _ in
    #if DEBUG
        return true
    #else
        return false
    #endif
    }
}

RxDataSources

RxDataSources 是一个类的集合，完全的实现了UITableViews 和UICollectionView 的data sources方法。
RxDataSources 在 这里.
RxExample 包含了方法示例和怎样使用它

原文链接
the basics, getting started with RxSwift

你可能感兴趣的:(Getting started with RxSwift(译))

  • 2021-01-09 哥伦比亚 《梦中的欢快葬礼和十二个异乡故事》 加西亚·马尔克斯 著 罗秀 译 juneyale
    《梦中的欢快葬礼和十二个异乡故事》哥伦比亚加西亚·马尔克斯著罗秀译序《总统先生，一路走好！》“再给我一杯咖啡。”他用纯正的法语说。随即补充道：“要意式咖啡，能让人起死回生的那种。”并没有意识到话里的双关含义。当火车开始加速，荷马突然发现总统的手杖还在自己手中，于是跑到站台尽头，把手杖用力扔过去，希望总统能在半空中接住。但是手杖掉在了铁轨上，随即被碾得粉碎。那真是恐怖的一瞬。拉萨拉看到的最后一幕是那
  • 懒人油泼面，治愈一切 惠顾星辰
    图片发自App说起油泼面，自然会想到电视剧《白鹿原》里的一个场景，一个和主线剧情关系不大的小细节，这个细节的主角就是一碗热气腾腾的油泼面。剧情中，秦海璐下厨为张嘉译做油泼面，做面的过程应该是正宗的陕西古法，面宽油香，热油泼在面上的一刹那，随着“刺啦”的一声，香气仿佛冲破屏幕，萦绕在观众身旁，让观众们纷纷在弹幕中留下：“油泼面来了，流口水啊”、“看饿了想吃”等留言。一部《白鹿原》，连带着火了陕西油泼
  • 当前最流行的架构设计模式 turingbooks
    《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
  • 故事||致 爱上一个人 译垚
    有时候，一首不出名，也不算很好听的歌曲，歌词和对白，与身边的一些故事，是那么的相似，人生有多少的故事，疼痛溶在一首音乐里......原创文/译垚网图致谢原创者侵删故事||致爱上一个人痛苦不需要预演爱时，撕心裂肺有多傲娇和狠心把真心爱你的人，伤得彻底为爱一个人，思念决堤浪潮无情的淹没真心抓住最后一根稻草，为等待硬撑泪水是睡前那声晚安哭泣一直不肯入眠幻影，均在梦中迈出脚步才知远方没有终点爱被拒千里之外
  • 『读书•觉察•冥想‖第二百九十天』《生命之书—365天的静心冥想》作者：[印度]克里希那穆提著 胡因梦译 景熙惟
    《生命之书-365天的静心冥想》十月十七日心智的更新我认为不断地努力想变成什么，便是脑子受损和退化的主因。你看我们老化的速度有多快，不但是那些六十岁以上的人，连年轻人都开始老化了。这里指的是心智上的退化。很少有人能够让心保持年轻，我指的年轻并不是有玩乐的兴致，而是一个不受染着的心——不被生活中的意外和事件所扭曲，不因为生活中的奋斗与挣扎而变得疲惫不堪。显然我们必须拥有一颗年轻的心，因为老旧的心已经
  • 【呓 语】约翰·穆勒：我们活一场，值得一点更高级的快乐 诗人琉璃姬
    选自约翰·穆勒《功利主义》第二章徐大建译上海人民出版社如果以为，那些赞成用功利来判别行为对错的人，是在一种狭隘的仅仅存在于口语中的意义上使用功利一词，将功利看作快乐的对立面，那真是太无知了。对于这种错误，只需提一下即可。要是误认为功利主义的哲学对手竟然也会产生如此荒唐的误解，哪怕是一时，也应该向他们表示道歉；这种误解之所以显得更不寻常，是因为对功利主义的另一种常见的批评恰好相反，指责功利主义把一切
  • 冈田武彦与《王阳明大传》 ea41e0427fde
    《王阳明大传》单单是序就有三个版，本书原作者是日本冈田武彦先生，由中国学生钱明译过来。王阳明是中国人，但他的著作却被日本人深为研究，在日本盛行后传回中国，正如序二里说的：阳明学失于吾国而求诸异邦。冈田武彦先生是阳明精神的虔诚践行者，写王阳明大传这套书，历时25年。而看完他对阳明学的贡献，不得不敬佩！1989年3月，由冈田先生发起在日本全国筹集300万日元资助的绍兴县王阳明墓修复工程训练竣工，同年4
  • 中华上下5000年之刘秀重建汉王朝 随言随语_4989
    好词：信任，坚忍，智慧，成熟，收腹，小恩小惠，心慌神乱，当机立断，新贵之家，聪明才智好段：冯译发现这一情况后马上报告给刘秀，刘秀当机立断，派两路大军阻拦赤眉军，赤眉军溃败如泥，刘秀把刘盆子他们接到洛阳，奉为上宾。感悟：刘秀是一个机智勇敢，但又有点心狠手辣的人。
  • 甲虫部落（七）穿越地狱4 金之心
    自译，原作者维克多·卢梭(1879-1960)。然后命运再次介入。因为，六只螳螂从它们躲藏的地方跃出空中，向它们的甲虫猎物扑去。长腿怪物可怕的边界，昆虫世界的祸害，把它们从一个河岸带到另一个河岸——幸运的是，对甲壳的居住者来说。甲虫云很快就溶解了。这一切都发生在几秒钟内。多德或汤米还没完全适应这种情况，螳螂就像甲虫一样消失了，每只螳螂的凹槽腿上都有一个猎物。没有布拉姆的迹象。这三个人独自一人站在小
  • CRACO 快速使用 小秀_heo React及其周边生态前端javascript
    GettingStarted|CRACOcraco是专门由于cra配置的重写，扩展配置cra（webpack）。安装依赖npmi-D@craco/craco根目录下创建craco.config.js和配置configure:my-app├──node_modules+├──craco.config.js└──package.jsoncraco.config.jsmodule.exports={de
  • 赛季初真是八仙过海各显神通 A楠铂
    赛季初真是八仙过海各显神通班里乱不乱他俩说了听说能认识这个字的都是高手我要的闪电不是2！小孩对发型不满意，在理发店崩溃痛哭33届金鸡奖颁奖礼现场张译给任素汐把脉楼主天生眼睛小，这是背景。割一下昨天下午片警来我们家下面是我们的对话片警:你这个照片得重新拍一下，来靠墙站我:好的，（站好了等拍照）片警:你眼睛睁开，别闭上我一个是行家，一个是专家，专家也怕行家狗咬电池爆炸起火，留宠物独自在家切记收好电池猫
  • 文言文翻译的方法一般有如下几点！ 教学手札
    翻译文言句子要掌握翻译的原则、步骤和方法。翻译的基本原则是直译为主，意译为辅，译文要符合现代汉语习惯，做到明白、流畅、简洁。翻译时既要字句对应，又要根据需要进行必要的调整，使译文完整，准确，得体。文言文翻译的方法一般有如下几点：（1）留：把文言文中的专有名词（朝代、年号、人名、地名、物名、器具、官职、职称等）与现代汉语意思相同的保留不译。如：“庖丁为文惠君解牛”中的“文惠君”。（2）补：指将文言文
  • 推开一扇门并不难 暖霞心理
    相约读书打卡第154天,我是来自山西太原的史文霞，今天的读书内容是【美】威廉·贝纳德著，张玉译的《哈佛家训》第八部分《勇气——正直无畏的面对》5.《推开一扇门并不难》6.《趟过生命之河的小泥人》《推开一扇门并不难》有一位国王，出题考他的大臣，以便从中选拔出智慧勇敢的人担任国中要职。他让臣子们打开一扇其大无比的门。这扇门从来没打开过，所以臣子们认为这门肯定是打不开的。一些大臣望着门不住的摇头；另一些
  • 【译】Swift算法俱乐部-布隆过滤器 Andy_Ron
    Swift算法俱乐部本文是对SwiftAlgorithmClub翻译的一篇文章。SwiftAlgorithmClub是raywenderlich.com网站出品的用Swift实现算法和数据结构的开源项目，目前在GitHub上有18000+⭐️，我初略统计了一下，大概有一百左右个的算法和数据结构，基本上常见的都包含了，是iOSer学习算法和数据结构不错的资源。andyRon/swift-algori
  • 绘本讲师阅读训练营【30期】11/21阅读原创《好大好大的鸡宝宝》 可乐妍妍
    30025-邓艾华文/图：基思.格雷夫斯（美）译：孙莉莉，李佳舜封面在一个小小的农场里，有一个小的不能再小的鸡舍。鸡舍里有一只小小小小的母鸡却生了一枚巨大无比的蛋。这只蛋摇啊摇，晃啊晃，一支巨大的鸡宝宝破壳而出......这只鸡宝宝那么大那么大，所以他要交到一个朋友实在太难了，可是他居然凭着自己的聪明，友善，温暖，勇敢——改变了这一切。构图技巧特别有意思，像漫画一样，几只鸡的讨论起来，真的很有风格
  • 『读书•练习•思考‖第一百三十一天』《奇迹课程一学员练习手册》作者：[美]海伦•舒曼编著若水译 景熙惟
    【奇迹课程·练习手册】第一百三十一课寻求真理的人，绝不会徒劳无功第一百三十一课1第一百三十一课2练习：我愿看到一个异于如今的世界，我所寻求的世界，也决非我个人营造出来的。
  • 【CSS in Depth 2 精译_027】4.4 Flexbox 元素对齐、间距等细节处理（下）+ 4.5 本章小结 安冬的码畜日常 CSSinDepth2css前端css3html5flexboxcss布局
    当前内容所在位置（可进入专栏查看其他译好的章节内容）第一章层叠、优先级与继承（已完结）1.1层叠1.2继承1.3特殊值1.4简写属性1.5CSS渐进式增强技术1.6本章小结第二章相对单位（已完结）2.1相对单位的威力2.2em与rem2.3告别像素思维2.4视口的相对单位2.5无单位的数值与行高2.6自定义属性2.7本章小结第三章文档流与盒模型（已完结）3.1常规文档流3.2盒模型3.3元素的高度
  • 大语文16 浚浚儿
    输入小朋友语录锦瑟唐代/李商隐锦瑟无端五十弦，一弦一柱思华年。译锦瑟无缘无故地有五十根弦，每弦每节，都令人怀思黄金华年。庄生晓梦迷蝴蝶，望帝春心托杜鹃。译我心像庄子，为蝴蝶晓梦而迷惘;又像望帝化杜鹃，寄托春心哀怨,沧海月明珠有泪，蓝田日暖玉生烟。译沧海明月高照，鲛人泣泪皆成珠，蓝田红日和暖，可看到良玉生烟。此情可待成追忆，只是当时已惘然。译悲欢离合之情，岂待今日来追忆，只是当年却漫不经心，早已惘然
  • 名诗我译（伊丽莎白·布朗宁篇）——Sonnets From The Portuguese（34） 葡萄牙的十四行诗 第34首 臻念
    译文：真念一思作者：伊丽莎白·布朗宁Withthesameheart,Isaid,I'llanswertheeAsthose,whenthoushaltcallmebymyname--Lo,thevainpromise!Isthesame,thesame,Perplexedandruffledbylife'sstrategy?Whencalledbefore,ItoldhowhastilyIdro
  • 「RIA学习力」《学习心理学》No.1，未闻 Nathan_2
    「RIA学习力授权导师」便签输出第6期第1天《学习心理学》拆页一来自《第一章学习理论与教学导论》P9(一)学习的定义虽然本书讨论的学习理论之间存在差异，但这些理论在学习上确实有一些基本的确定性的假设。首先，它们都指出学习是人类行为表现performance，又译表现)或行为表现潜能的持久改变。这意味着学习者能够执行一些在学习发生之前不能执行的行动而且不管它们实际上是否有展示新习得行为表现的机会，这
  • C语言要点归纳 ChenK21_idea C/C++c语言
    摘自：《C语言入门经典（第4版）》（美）lvorHorton.著杨浩.译北京.清华大学出版社【1】知识要点1C程序创建4个基本步骤：编辑，编译，链接，执行。编辑过程就是创建和修改C程序的源代码，我们编写的程序指令称为源代码。C编译器带一个编辑器，提供编写、管理、开发与测试程序的环境，有时也称为“集成开发环境（IDE）”。在UNIX或Linux上，最常用的的文本编辑器是vi，也可以使用emacs编辑
  • 读书《写小说最重要的十件事》004 一叶枫红
    第六章动词的人称和时态动词的人称和时态，在英语写作中特别重要，我这里就不讲了。本文的作者是厄休拉·勒古恩厄修拉·勒古恩（UrsulaK.LeGuin，1929年10月21日[4]-2018年1月22日）美国重要科幻、奇幻与女性主义与青少年儿童文学作家。著有小说20余部，以及诗集、散文集、游记、文学评论与多本童书。并与人合译老子《道德经》。所获文学奖与荣誉不计其数。她深受老子与人类学影响，作品常蕴含
  • 【drools】文档2：起步 drools和dmn 等风来不如迎风去 网络服务入门与实战springdrools
    GettingStartedDroolsUserGuide8.44.0.FinalGettingStartedFirstRuleProjectThisguidewalksyouthroughtheprocessofcreatingasimpleDroolsapplicationproject.PrerequisitesJDK11+withJAVA_HOMEconfiguredappropriate
  • BUUCTF 2021-10-4 Pwn Ch1lkat BUUCTFPwnlinuxpwn
    文章目录保持手感echo分析EXPPwnme1分析EXPwdb_2018_1st_babyheap分析EXPFSOPhouseoforange_hitcon_2016分析前置知识House_of_orangeFSOPEXPzctf_2016_note3分析EXPgyctf_2020_document分析EXP动态调试复现护网杯_gettingstart分析EXPpicoctf_2018_buffe
  • 名诗我译（艾米莉·狄金森篇25）——through bramble（穿过荆棘） 臻念
    译文：真念一思作者：艾米莉·狄金森Throughlaneitlay--throughbramble--Throughclearingandthroughwood--BandittioftenpassedusUponthelonelyroad.穿过遍布的巷陌，穿过荆棘--穿过林间空地，穿过树林--经常有匪徒在那偏僻孤寂的路上与我们擦肩而过Thewolfcamepeeringcurious--Theo
  • 《道德经》51-60章经典自译 远光的树洞
    第五十一章尊道贵德道生之，德畜之，物形之，势成之。是以万物莫不尊道，而贵德。道之尊，德之贵，夫莫之命而常自然。故道生之，德畜之。长之育之。亭之毒之。养之覆之。生而不有，为而不恃，长而不宰。是谓玄德。道生成万物，德养育万物，万物都有独特的形态，顺应时势而成长。因此，万物没有不尊敬道、重视德的。道之所以受尊敬，德之所以受重视，就在于道德从不对万物进行干涉，而是顺其自然。所以，道生成了万物，德养育了万物
  • 20.试译艾米莉·狄金森诗选 第一部分 生活 他不在这里
    20.Itastealiquorneverbrewed,Fromtankardsscoopedinpearl;NotallthevatsupontheRhineYieldsuchanalcohol!InebriateofairamI,Anddebaucheeofdew,Reeling,throughendlesssummerdays,Frominnsofmoltenblue.Whenlandlor
  • 资治通鉴|战国秦汉【82】渑池之会，蔺相如差点溅了秦昭襄王一脸血 KTBreal
    小心溅你一脸血（网图侵删）导读我们接着看赵国名人蔺相如的第二个故事，这篇故事也是选入小学课本（至少我那时候是）。这也是蔺相如和秦王第二次见面，第二次的见面，更是气氛紧张，相互碰撞，火花四起，充满冲突。自译部分秦王派使者出使赵国，见赵王（赵何），说：“之前的事不好意思啦（完璧归赵与秦伐赵），秦王邀请您去渑池一聚，共结盟好。”赵王不知道秦昭襄王葫芦里卖的什么药，表示不想去，廉颇、蔺相如一起反对，说：“
  • [译] Plaid 应用迁移到 AndroidX 的实践经历 weixin_34029680 移动开发javaruntime
    原文地址：Cross-stitchingPlaidandAndroidX原文作者：TiemSong译文出自：掘金翻译计划本文永久链接：github.com/xitu/gold-m…译者：Mirosalva校对者：PhxNirvana一份AndroidX的迁移指南由VirginiaPoltrack提供图片。Plaid是一款呈现MaterialDesign风格和丰富交互界面的有趣应用。最近这款应用通过
  • 『读书•觉察•冥想‖第二百四十五天』《生命之书—365天的静心冥想》作者：[印度]克里希那穆提著胡因梦译 景熙惟
    《生命之书-365天的静心冥想》九月二日所有的思想都会分心总是在竞争、想要变得更好的心，是没有能力揭露真相的。只有全神贯注的心才能不断地自我揭露——因为能不断地揭露自己的真相，所以是富有创造性和解放能力的。这样的自我揭露可以使我们从贪得无厌之中解脱出来，进而摆脱掉复杂的智力活动。造成我们上瘾的便是这些复杂的智力活动，其中充满着好奇、揣测、肤浅的知识和闲言闲语，这些障碍会使我们的生命变得过度复杂。心
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他