RxSwift์ ํฌ์คํ ์ ์ด๊ฒ ์ฒ์์ธ๋ฏํ๋ค.
์ฌ์ฉ์ ๋ง์ด ํ์ง๋ง ์ฌ๋์๊ฒ ์๊ณ ์ถ์ผ๋๊น ์ด์ ๊ธ๋ก๋ ์จ๋ณด๊ธฐ!
์ฃผ์ ๋ Single
! ์์๊ฐ ์ด์ํ๊ธด ํ๋ฐ,,,
์๋ฌดํผ ๋ด๊ฐ ์๊ฐํ RxSwift
๋ ๋จ์ํ๋ค.
๋ฐฉ์ถํ๊ณ ๊ตฌ๋ ํ๋ค
๊ฐ์ธ์ ์ผ๋ก ์๊ฐํ๋ Rx์ ์ด์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ๋ฐฉ์ถํ๋ ์ ์ฅ์์ ๋๊ฐ ๊ตฌ๋ ์ ํ๋ ๋ฐฉ์ถ๋ง ํ๋ฉด ๋๋ค. (์์กด์ฑ ๋ฎ์ถ๊ธฐ)
- ๊ตฌ๋ ํ๋ ์ ์ฅ์์ ๋ฐฉ์ถ๋ ๊ฐ์ ์ค์๊ฐ์ผ๋ก ๋ฐ์ ์ ์๋ค.
- ํ ๋ฐฉ์ถ์์ ๋ํด ์ฌ๋ฌ ๊ตฌ๋ ์๊ฐ ์๊ธธ ์ ์๋ค.
ํ์ง๋ง, ๊ฐ๋ฐ์๋ผ๋ฉด ์์ฌ์ด ์๊ธฐ๊ธฐ ๋ง๋ จ์ธ๋ฏ ์ถ๋ค.
OOP๋ ๋์์ธ ํจํด์ด๋ผ๋๊ฐ ์ํคํ ์ณ๋ผ๋๊ฐ
์ด๋ ํ ๋ชฉ์ ์ ๋ํด ์กฐ๊ธ ๋ ํธํ๊ณ ,
์ข๊ฒ ๋ฐ์ ์ํค๊ณ ์ ํ๋ ์์ฌ๋ค์ ์๋ ๋ฏ ํ๋ค.
Rx
๋ํ ๋น์ทํ๋ค ์๊ฐํ๋ค. ๋ฐฉ์ถ์ ํ๊ณ ๊ตฌ๋
ํ๋ฉด ๋์ด์ง๋ง
์ด๋ป๊ฒ ์กฐ๊ธ ๋ ๋ฐฉ์ถ์ ์ฝ๊ณ ํธํ๊ฒ ํ ๊น?
์ด๋ป๊ฒ ์กฐ๊ธ ๋ ๊ตฌ๋ ์ ์ฝ๊ณ ํธํ๊ฒ ํ ๊น?
๋ผ๋ ์๊ฐ์์ Rx
์์ Operator
๋ค๊ณผ Single
๋ฑ๋ฑ ๋ง์ ๊ฒ์ด ์๊ฒจ๋ ๊ฒ์ผ๋ก ์๊ฐํ๋ค.
์ง๊ทนํ ๊ฐ์ธ์ ์ธ ๊ฒฌํด์ ๋๋ค.
์ด๋ฌํ ์๊ฐ์ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ Rx์ ๋ํด ๊ธ์ ์ด๋ค๋ฉด
โ์ ์ด Operator๊ฐ ๋์์๊น?, Single์ ์ ๋์์๊น?โ
๋ผ๋ ์์ ์ ๊ทผ์ ํ ์์ ์ด๋ค.
๊ธฐ์กด Observable
์ ๋ถํธํ ์ .
๊ฐ์ธ์ ์ผ๋ก Swift 5
๋ถํฐ ์ง์๋๋ ๋ฌธ๋ฒ์ธ Result
๋ฅผ ์ ๋ง ์ข์ํ๋ค.
์ด๋ฆ๋ ๊ฒฐ๊ณผ ๋ผ๋ ์ง์ค์ ์ธ ์ด๋ฆ์ด๊ณ , Result
๋ ์ด๊ฑฐํ
์ด๋ค
ํด๋น๋๋ case
๋ ๋ค์๊ณผ ๊ฐ๋ค.
success
failure
์ด์ฒ๋ผ, ๋จ์ํ ์ํค๊ณ ๋ช ํํ๊ฒ ๋ง๋ค ์ ์๋ค๋ฉด ์ข๊ฒ ์ง๋ง
Observable
์ด ๋ฐฉ์ถํ๋ ์ด๋ฒคํธ์ ์ข
๋ฅ๋ ์กฐ๊ธ ๋ค์ํ๋ค
- onNext
- onError
- onCompleted
- onDisposed
๊ทธ๋ฐ๋ฐ, ๋ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ณดํต ๋ฐ์ดํฐ ๋ฐ์ธ๋ฉ ๋ชฉ์ ์ ์ํด์ ์จ์ ๊ทธ๋ฐ๊ฑธ๊น?
onNext
๋ง ์์ฒญ๋๊ฒ ์ฌ์ฉ ๋น์ค์ด ๋์๋ค.
๋๋ง ๊ทธ๋ฐ๊ฐ..
์๋ฌดํผ ๋๋ ๋ค๋ฅธ ๊ฒ์ ๋ง์ด ์ฌ์ฉ ์ํ๊ธฐ ๋๋ฌธ์
๋จ์ํ๊ณ ๋ช
ํํ๊ฒ ๋ฐฉ์ถ์ ๋ํด์ ์ฑ๊ณต
๊ณผ ์คํจ
๋๊ฐ์ง๋ง ๋ฐ๊ณ ์ถ์๊ณ ,
๋๊ฐ์ ์ฌ๋๋ค์ด ๋ง์๋์ง?
์ด๋ฅผ ํด์ ํ ์ ์๋ ๊ฒ์ด ์ญ์๋ ์กด์ฌ ํ์๊ณ ,
๊ทธ๊ฒ Single
์ด์๋ค.
Single
์ด๋ฒ ๊ธ์ ๋ชฉ์ ์ ๋ถํธํจ์ ํด์ํ๋ ๊ฒ์ ์ด์ ์ ๋ง์ท๊ธฐ ๋๋ฌธ์
๋จ์ํ๊ฒ ์์๋ณด๊ณ ๋ค์ํธ์์ ์กฐ๊ธ๋ ์ฌ๋์๊ฒ ๊ธ์ ์ฐ๋ คํ๋ค.
๊ทธ๋ฆฌ๊ณ Single
์ ์ค์ํ ์ ์ ์ฑ๊ณต
, ์คํจ
์ ๋ํด์
๋ฐฉ์ถํ๋ค๋ ์ ์ด ํฌ์ธํธ๋ค.
์ฑ๊ณต ๋ฐฉ์ถ
let singleString = Single<String>.just("hi")
let singleArray = Single<[Int]>.just([1,2,3])
let singleInt = Single<Int>.just(5)
just
๋ฅผ ์ด์ฉํด ๋จ์ํ ๋ฐฉ์ถ ํ ์ ์์์ ๋ณด์๊ณ ,
์ด๋ ํ์ ์ถ๋ก ์ ํตํด ์กฐ๊ธ๋ ์ถ์ฝ์ ํ์๋ฉด ์ด๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
let singleString = Single.just("hi")
let singleArray = Single.just([1,2,3])
let singleInt = Single.just(5)
์คํจ ๋ฐฉ์ถ
let error = NSError(domain: "test", code: 0, userInfo: nil)
let singleError = Single<String>.error(error)
error
๋ฅผ ์ฌ์ฉํด์ ๊ฐ๋จํ๊ฒ ๊ฐ๋ฅํ๋ค.
๊ตฌ๋
// 1. Single & DisposeBag ์์ฑ
let singleString = Single.just("hi")
let bag = DisposeBag()
// 2. Single ๊ตฌ๋
singleString
.subscribe { event in
// 3. event switch ์ฒ๋ฆฌ
switch event {
case .success(let text):
// 4. ์ฑ๊ณต์ text ์ถ๋ ฅ
print(text)
case .failure(let error):
// 5. ์คํจ์ ์๋ฌ ์ถ๋ ฅ
print(error.localizedDescription)
}
}.disposed(by: bag)
--- Console Result ---
"hi"
์ฌ๊ธฐ์ ์ค์ํ ๊ฒ์ Single
์ ๊ตฌ๋
ํ ๋,
event
๋ฅผ ๋ฐ๊ณ ์ด๊ฒ์ ํ์
์ Result<String, Error>
์ด๋ค.
Result
!! ์์ ๋์๋ ๋ด๊ฐ ์ข์ํ๋ ๊ทธ๊ฒ.
์ด๋ฅผ ํตํด ๊ตฌ๋
์ ์ฑ๊ณต
, ์คํจ
๋ง์ผ๋ก ๊ตฌ๋ฌธ๋๊ธฐ ๋๋ฌธ์
Observable
๋ณด๋จ ๋จ์ํด์ง๊ธฐ ๋๋ฌธ์ ๊ต์ฅํ ๋ง์์ ๋ ๋ค.
์ฌ์ค ์ด๋ ๊ฒ๋ง ์ธ ์ผ์ ๊ฑฐ์ ์์ ๋ฏํ์ง๋ง,
์ด๊ฒ์ ์์๋๋ฉด create
๋ฅผ ์ฌ์ฉํ ๋, ์ด๋ป๊ฒ ์ฌ์ฉํ์ง?๋ ํจ์ค ํด๋ ๋๋ฏ๋ก,
์ด๋ฐ๊ฒ ์๋ค ์ ๋ ์์๋์.
๊ทธ๋ฆฌ๊ณ ํฅ๋ฏธ๋ก์ด๊ฑด create
์ ์๊ทธ๋์ฒ๋ค
์๊ทธ๋์ฒ: ๊ฐ๋จํ๊ฒ ๋งํด์ (๋ฉ์๋ ์ด๋ฆ, ํ๋ผ๋ฏธํฐ์ ์ด๋ฆ&์๋ฃํ, ๋ฆฌํด ๊ฐ์ ์๋ฃํ)์ ๋ํ๋ด๋ ๊ฒ
closer
์ escaping
์ด ๋ง์ด ๋์์ ์ดํดํ๋๋ฐ ์๊ฐ์ด ์กฐ๊ธ ๊ฑธ๋ ธ์ง๋ง,
์ดํดํ๊ณ ๋๋ ์ฌ๋ฐ๋ ์ ์ด ๋ง์๋ค.
์ด๊ฑฐ์จ 2ํธ์ ๊ณ์.
๋!