RxSwift 실천 (1) 약술

간단 한 소개
그것 은 관찰자 의 모델 을 넓 혔 다.여러 개의 비동기 사건 을 자 유 롭 게 조합 할 수 있 도록 스 레 드, 동기 화, 스 레 드 안전, 병발 데이터 와 I / O 차단 에 관심 을 가 질 필요 가 없습니다.
함수 응답 식 프로 그래 밍

함수 식 프로 그래 밍: 프로 그래 밍 패 러 다 임 입 니 다. 함 수 를 매개 변수 로 전달 하거나 반환 값 으로 반환 해 야 합 니 다.우 리 는 서로 다른 함 수 를 조합 해서 원 하 는 결 과 를 얻 을 수 있다.

응답 식 프로 그래 밍: a = b + c 는 표현 식 결 과 를 a 에 게 부여 한 다음 에 b 또는 c 의 값 을 바 꾸 면 a 에 영향 을 주지 않 습 니 다.그러나 응답 식 프로 그래 밍 에서 a 의 값 은 b 나 c 의 업데이트 에 따라 업 데 이 트 됩 니 다.a = b + c 는 일종 의 귀속 관 계 를 성명 한다.

RxSwift 장점

업무 차원 에서 코드 논리 분 리 를 실현 하고 후기 유지 와 확장 에 편리 하 다

프로그램 응답 속 도 를 크게 향상 시 키 고 CPU 의 능력 을 충분히 발굴

개발 자가 코드 의 추상 적 능력 을 향상 시 키 고 업무 논 리 를 충분히 이해 하도록 도와 준다

Rx 의 풍부 한 조작 부 호 는 코드 논 리 를 크게 간소화 하 는 데 도움 이 될 것 이다

핵심

Observable - 감청 가능 한 서열 생산 열

Observer - 관찰자

Operator - 연산 자

Disposable - 귀속 (구독) 의 생명주기 관리

스케줄 러 - 스케줄 러 (스 레 드 대기 열 배치)

Observable - 감청 가능 한 시퀀스
프레임 워 크 는 우리 에 게 자주 사용 하 는 서열 을 많이 만들어 주 었 다.예 를 들 어 button 의 클릭, textField 의 현재 텍스트, switch 의 스위치 상태, slider 의 현재 수치 등 입 니 다.

let numbers: Observable = Observable.create { observer -> Disposable 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()
}

Observer - 관찰자
관찰자 의 가장 직접적인 방법 은 Observable 의 subscribe 방법 뒤에 사건 이 발생 할 때 어떻게 응답 해 야 하 는 지 설명 하 는 것 이다.관찰 자 는 바로 뒤의 onNext, onError, onComplete 의 이 패키지 들 로 구 축 된 것 이다.

observer. onNext (0) 는 하나의 요소 가 생 겼 다 는 것 을 의미 하 는데 그의 값 은 0 이다.

onComplete () 종료

onError () 오류 발생

tap.subscribe(onNext: { [weak self] in
    self?.showAlert()
}, onError: { error in
    print("    ： \(error.localizedDescription)")
}, onCompleted: {
    print("    ")
})

조작 부호

filter - 필터

//   
let rxTemperature: Observable = ...

// filter    
rxTemperature.filter { temperature in temperature > 33 }
    .subscribe(onNext: { temperature in
        print("  ：\(temperature) ")
    })
    .disposed(by: disposeBag)

map - 전환

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

zip - 짝 짓 기

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

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

first.onNext("1")
second.onNext("A")
1A

Disposable - 지 울 수 있 는 자원
일반적으로 하나의 시퀀스 가 error 나 completed 사건 을 보 내 면 모든 내부 자원 이 방출 된다.이 자원 을 미리 방출 하거나 구독 을 취소 할 필요 가 있다 면 삭제 가능 한 자원 (Disposable) 을 disposable 로 호출 할 수 있 습 니 다.
일반적인 상황 에서 우 리 는 dispose 방법 을 수 동 으로 호출 할 필요 가 없다.
패키지 지우 기 (DisposeBag) 또는 takeUntil 연산 자 를 사용 하여 구독 의 수명 주 기 를 관리 합 니 다.

DisposeBag - 가방 제거

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()
}

takeUntil 은 컨트롤 러 의 dealloc 이벤트 가 발생 할 때 까지 구독 을 지속 합 니 다

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)

    _ = doSomethingOutlet.rx.tap
        .takeUntil(self.rx.deallocated)
        .subscribe(onNext: { [weak self] in self?.showAlert() })
}

스케줄 러 - 스케줄 러
Schedulers 는 Rx 가 다 중 스 레 드 를 실현 하 는 핵심 모듈 로 작업 이 어느 스 레 드 나 대기 열 에서 실행 되 는 지 제어 하 는 데 사 용 됩 니 다.GCD：

//       ，       
DispatchQueue.global(qos: .userInitiated).async {
    let data = try? Data(contentsOf: url)
    DispatchQueue.main.async {
        self.data = data
    }
}

RxSwift:

let rxData: Observable = ...

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

subscribeOn 은 데이터 시퀀스 의 구축 함수 가 어느 Scheduler 에서 실행 되 는 지 결정 합 니 다.상기 예 에서 데 이 터 를 가 져 오 는 데 시간 이 오래 걸 리 기 때문에 subscribeOn 을 배경 Scheduler 로 전환 하여 데 이 터 를 가 져 옵 니 다.이렇게 하면 메 인 스 레 드 가 막 히 는 것 을 피 할 수 있다.

observeon 은 어느 Scheduler 에서 이 데이터 순 서 를 감청 할 지 결정 합 니 다.상기 예 에서 observeon 방법 을 사용 하여 메 인 라인 으로 전환 하여 결 과 를 감청 하고 처리 합 니 다.

MainScheduler 메 인 스 레 드

SerialDispatchQueue Scheduler 는 직렬 DispatchQueue 를 추상 화 했다.직렬 작업 이 필요 하 다 면 이 Scheduler 로 전환 해서 실행 할 수 있 습 니 다.

ConcurrentDispatchQueue Scheduler 는 병렬 DispatchQueue 를 추상 화 했다.병행 작업 이 필요 하 다 면 이 Scheduler 로 전환 해서 실행 할 수 있 습 니 다.

Operation Queue Scheduler 는 NSOperation Queue 를 추상 화 했다.이 는 NSOperationQueue 의 일부 특징 을 가지 고 있 습 니 다. 예 를 들 어 max Concurrent OperationCount 를 설정 하여 동시 다발 작업 의 최대 수량 을 제어 할 수 있 습 니 다.

오류 처리 - 오류 처리
Rx Swift 는 주로 두 가지 오류 처리 메커니즘 이 있 습 니 다.

retry - 재 시도

catch - 회복

retry - 다시 시도

retry

let rxJson: Observable = ...

rxJson
    .retry(3)
    .subscribe(onNext: { json in
        print("   JSON   : \(json)")
    }, onError: { error in
        print("   JSON   : \(error)")
    })
    .disposed(by: disposeBag)

실패 후 다시 세 번 시도

retry When 연산 자 입 니 다. 이 연산 자 는 언제 다시 시도 해 야 하 는 지 를 설명 하고 패키지 에서 돌아 오 는 Observable 을 통 해 재 시도 시 기 를 제어 합 니 다.

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)

catchError - 복구

catchError 는 오류 가 발생 했 을 때 예비 요소 나 예비 요소 로 오 류 를 교체 할 수 있 습 니 다.

let rxData: Observable = ...      //        
let cahcedData: Observable = ...  //          

rxData
    .catchError { _ in cahcedData }
    .subscribe(onNext: { date in
        print("      : \(date.count)")
    })
    .disposed(by: disposeBag)

catch ErrorJustReturn 오류 가 발생 했 을 때 빈 배열 로 돌아 가면 빈 목록 페이지 가 표 시 됩 니 다.

Result
오류 결과 보 여주 기

updateUserInfoButton.rx.tap
    .withLatestFrom(rxUserInfo)
    .flatMapLatest { userInfo -> Observable> in
        return update(userInfo)
            .map(Result.success)  //     Result
            .catchError { error in Observable.just(Result.failure(error)) }
    }
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { result in
        switch result {           //    Result
        case .success:
            print("        ")
        case .failure(let error):
            print("        ： \(error.localizedDescription)")
        }
    })
    .disposed(by: disposeBag)

기타
그 다음 에 구체 적 인 실천 - UI 의 사용, 그리고 더 많은 이론 적 인 것 은 문 서 를 보면 OK 이 고 조작 부 호 를 만 나 서 다시 찾 아 보 겠 습 니 다.기본 상용 컨트롤 UITablView 와 UICollectionview 는 다른 상용 하지 않 는 컨트롤 을 사용 합 니 다. 모든 예 demo
참고 문헌
swift 개발 RxSwift 중국어 문서