๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

๐ŸŽ iOS/RxSwift

[RxSwift] Observable

RxSwift ๊ฐœ๋… ์ •๋ฆฌ๊ธ€์—์„œ RxSwift์˜ ์ •์˜์— ๋Œ€ํ•ด ์ •๋ฆฌํ•ด๋ณด๋ฉฐ,

Observable์ด ๋ฐ˜์‘ํ˜•(Reactive) ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๊ฐ€์žฅ ํฐ ํ•ต์‹ฌ์ด๋‹ค. ๋ผ๊ณ  ์ •๋ฆฌํ–ˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ์ด ์ค‘์š”ํ•œ ๊ฐœ๋…! Observable์ด ๋ฌด์—‡์ธ์ง€, ์–ด๋–ป๊ฒŒ ๋งŒ๋“œ๋Š”์ง€, ์–ด๋–ป๊ฒŒ ์‚ฌ์šฉํ•˜๋Š”์ง€์— ๋Œ€ํ•ด์„œ ์ข€ ๋” ์ž์„ธํžˆ ์•Œ์•„๋ด…์‹œ๋‹ค!

Observable

Observable์˜ ๊ฐœ๋…๋ถ€ํ„ฐ ๋‹ค์‹œ ๊ฐ€์ ธ์™€์„œ ์„ค๋ช…ํ•ด๋ณด์ž๋ฉด,

ReactiveX์—์„œ Observable ๊ฐ์ฒด๋Š” ์‚ฌ์ „์ ์ธ ์˜๋ฏธ๋Œ€๋กœ ์–ด๋–ค '๊ฐ์ฒด'๋ฅผ ๊ด€์ฐฐํ•  ์ˆ˜ ์žˆ๋Š” ํ˜•ํƒœ๋กœ ๋งŒ๋“œ๋Š” ๊ฒƒ์„ ๋งํ•˜๋ฉฐ,

Observable ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•จ์œผ๋กœ์จ Observer๋Š” ๊ด€์ฐฐ์„ ์‹œ์ž‘(๊ตฌ๋…)ํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

์ด '๊ฐ์ฒด'์— ๋”ฐ๋ผ ์‹ค์ œ ๊ด€์ฐฐํ•˜๋Š” ๊ฐ’(== ์ŠคํŠธ๋ฆผ์— ํ˜๋ ค๋ณด๋‚ด๋Š” ๊ฐ’) ํ˜น์€ ๊ด€์ฐฐ์˜ ๋Œ€์ƒ์ธ ์‚ฌ๊ฑด(== ์ด๋ฒคํŠธ)์ด ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค.

์ฆ‰, Observable์€ ๊ด€์ฐฐ ๊ฐ€๋Šฅํ•œ ๋ฐ์ดํ„ฐ์˜ ํ๋ฆ„์ž…๋‹ˆ๋‹ค. Observer๊ฐ€ Observable์„ ๊ตฌ๋…ํ•˜๊ณ , Observable์ด ๋ฐฉ์ถœํ•˜๋Š” ์ด๋ฒคํŠธ์— ๋ฐ˜์‘ํ•˜๋Š” ๊ฒƒ์ด ๋ฐ˜์‘ํ˜•(Reactive) ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๊ฐ€์žฅ ํฐ ํ•ต์‹ฌ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

observable, observable sequence, sequence๋ผ๋Š” ํ‘œํ˜„์„ ์“ฐ๋Š”๋ฐ ์‚ฌ์‹ค ๋‹ค ๊ฐ™์€ ๋ง์ž…๋‹ˆ๋‹ค.

์ค‘์š”ํ•œ ๊ฒƒ์€ ์ด๋ฒคํŠธ๊ฐ€ ๋น„๋™๊ธฐ์ ์œผ๋กœ ์ƒ์„ฑ๋œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค!

observable์€ ์ผ์ •๊ธฐ๊ฐ„ ๋™์•ˆ ๊ณ„์†ํ•ด์„œ ์ด๋ฒคํŠธ๋ฅผ ์ƒ์„ฑํ•ด ์ŠคํŠธ๋ฆผ์— ํ˜๋ ค๋ณด๋‚ด๋Š”๋ฐ, ์ด๋Ÿฌํ•œ ๊ณผ์ •์„ ๋ฐฉ์ถœ(emit)์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ ๊ฐ๊ฐ์˜ ์ด๋ฒคํŠธ๋“ค์€ ์ˆซ์ž๋‚˜ ์ปค์Šคํ…€ํ•œ ์ธ์Šคํ„ด์Šค๋“ฑ๊ณผ ๊ฐ™์€ ๊ฐ’์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ๊ณ , ๋˜๋Š” ํƒญ๊ณผ ๊ฐ™์€ ์ œ์Šค์ฒ˜์ผ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

 

์ด๋ฒคํŠธ๋ฅผ ์–ด๋–ป๊ฒŒ ์ƒ์„ฑํ•ด์„œ ์–ด๋–ป๊ฒŒ ํ˜๋ ค๋ณด๋‚ด๋Š” ๊ฑฐ์ง€?? ๊ธ€๋กœ๋งŒ ๋ด์„œ๋Š” ์ดํ•ด๊ฐ€ ์ž˜ ๊ฐ€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.๐Ÿฅบ๐Ÿ˜ญ

์ด๋Ÿฌํ•œ ๊ฐœ๋…๋“ค์„ ๊ฐ€์žฅ ์ž˜ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์€ marble diagrams๋ฅผ ์ด์šฉํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. (๊ทธ๋ฆผ์œผ๋กœ ์‰ฝ๊ฒŒ ๋ด…์‹œ๋‹ค!)

  • marble diagram: ์‹œ๊ฐ„์˜ ํ๋ฆ„์— ๋”ฐ๋ผ์„œ ๊ฐ’์„ ํ‘œ์‹œํ•˜๋Š” ๋ฐฉ์‹
  • ์‹œ๊ฐ„์€ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ๋ฅธ๋‹ค๋Š” ๊ฐ€์ •
  • ์ฐธ๊ณ ํ•˜๋ฉด ์ข‹์„ ์‚ฌ์ดํŠธ: RxMarbles

Observable์˜ ์ƒ๋ช…์ฃผ๊ธฐ

observable์˜ ์ƒ๋ช…์ฃผ๊ธฐ๋ฅผ marble diagram์„ ํ†ตํ•ด ์•Œ์•„๋ด…์‹œ๋‹ค!

์˜ต์ €๋ฒ„๋ธ”์—๋Š” next, completed, error ์ด๋ ‡๊ฒŒ ์„ธ๊ฐ€์ง€ ๊ตฌ์„ฑ์š”์†Œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜๋‚˜์”ฉ ์‚ดํŽด๋ณผ๊ฒŒ์š”!

 

1. next

next ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด ๊ฐ๊ฐ์˜ ์š”์†Œ๋“ค์„ ๋ฐฉ์ถœํ•ฉ๋‹ˆ๋‹ค.

 

2. completed

์„ธ ๋ฒˆ์˜ tap ์ด๋ฒคํŠธ๋ฅผ ๋ฐฉ์ถœํ•œ ๋’ค ์ด๋ฒคํŠธ๋“ค์ด ๋‹ค ๋ฐฉ์ถœ๋˜๋ฉด ์™„์ „ ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” completed ์ด๋ฒคํŠธ๊ฐ€ ๋ฐœ์ƒ๋œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

 

3. error

error ์ด๋ฒคํŠธ๋„ ๋ฐฉ์ถœ ํ›„, ์™„์ „ ์ข…๋ฃŒ๋˜๋Š” ์ด๋ฒคํŠธ์ž…๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒ๋˜์—ˆ์„ ๋•Œ๋Š” error ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.

 

Observable ๋งŒ๋“ค๊ธฐ

observable ์ƒ์„ฑ ์—ฐ์‚ฐ์ž๋ฅผ ์ด์šฉํ•ด observable์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

just, of, from, empty, never, range, repeatElement, interval, create ๋“ฑ ๋‹ค์–‘ํ•œ ์ƒ์„ฑ ์—ฐ์‚ฐ์ž๋“ค์ด ์žˆ๋Š”๋ฐ์š”,

์ด ๊ฒŒ์‹œ๋ฌผ์—์„œ๋Š” ๊ฐ€์žฅ ๋Œ€ํ‘œ์ ์ธ just, of, from์— ๋Œ€ํ•ด์„œ๋งŒ ์ž์„ธํžˆ ๋ณด๋„๋ก ํ• ๊ฒŒ์š”!

์˜ˆ์‹œ ์ฝ”๋“œ์—์„œ๋Š” ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•œ ์ดํ•ด๋ฅผ ๋•๊ธฐ ์œ„ํ•ด subscribe๊นŒ์ง€ ํ•ด์„œ ์ถœ๋ ฅ๊นŒ์ง€ ํ•ด๋ณด๊ณ , ๋’ค์—์„œ subscribe์— ๋Œ€ํ•ด

์ž์„ธํžˆ ์ •๋ฆฌํ•˜๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค!

just

์˜ค์ง ํ•˜๋‚˜์˜ Element๋ฅผ ํฌํ•จํ•˜๋Š” Observable Sequence๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

let observable1 = Observable.just([1, 2, 3])
observable1.subscribe {
  print($0)
}

// ์ถœ๋ ฅ ๊ฒฐ๊ณผ
// next([1, 2, 3])
// completed
  • just๋Š” Observable์˜ ํƒ€์ž… ๋ฉ”์†Œ๋“œ์ž…๋‹ˆ๋‹ค.
  • ์ด๋ฆ„์—์„œ ์ถ”์ธกํ•  ์ˆ˜ ์žˆ๋“ฏ, ์˜ค์ง ํ•˜๋‚˜์˜ ์š”์†Œ๋ฅผ ํฌํ•จํ•˜๋Š” Observable sequence๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

of

๊ฐ€๋ณ€์ ์ธ element๋ฅผ ํฌํ•จํ•˜๋Š” Observable Sequence๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

let observable2 = Observable.of(1, 2, 3)
observable2.subscribe { event in
  print(event)
}

// ์ถœ๋ ฅ ๊ฒฐ๊ณผ
// next(1)
// next(2)
// next(3)
// completed
  • element๊ฐ€ ๋งŽ์ง€๋งŒ  observable2์˜ ํƒ€์ž…์€ ๋ฐฐ์—ด์ด ์•„๋‹Œ Observable<Int> ํƒ€์ž…์ž…๋‹ˆ๋‹ค.
  • .of ์—ฐ์‚ฐ์ž๋Š” ์ฃผ์–ด์ง„ ๊ฐ’๋“ค์˜ ํƒ€์ž…์ถ”๋ก ์„ ํ†ตํ•ด Observable sequence๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.
  • ๋”ฐ๋ผ์„œ, ์–ด๋–ค array๋ฅผ observable array๋กœ ๋งŒ๋“ค๊ณ  ์‹ถ๋‹ค๋ฉด, array๋ฅผ .of ์—ฐ์‚ฐ์ž์— ์ง‘์–ด ๋„ฃ์œผ๋ฉด ๋ฉ๋‹ˆ๋‹ค.
let observable3 = Observable.of([1, 2, 3])
observable3.subscribe {
  print($0)
}

// ์ถœ๋ ฅ ๊ฒฐ๊ณผ
// next([1, 2, 3])
// completed
  • observable3์˜ ํƒ€์ž…์€ Observable<[Int]>
  • ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด just ์—ฐ์‚ฐ์ž๋ฅผ ์“ด ๊ฒƒ๊ณผ ๊ฐ™์ด [1,2,3]๋ฅผ ๋‹จ์ผ์š”์†Œ๋กœ ๊ฐ€์ง€๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

from

array์˜ ์š”์†Œ๋“ค๋กœ Observable Sequence ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

let observable4 = Observable.from([1,2,3])
observable4.subscribe { event in
  print(event)
}

// ์ถœ๋ ฅ ๊ฒฐ๊ณผ
// next(1)
// next(2)
// next(3)
// completed
  • observable4์˜ ํƒ€์ž…์€ Observable<Int>
  • from ์—ฐ์‚ฐ์ž๋Š” ์ผ๋ฐ˜์ ์ธ array ๊ฐ๊ฐ ์š”์†Œ๋“ค์„ ํ•˜๋‚˜์”ฉ ๋ฐฉ์ถœํ•ฉ๋‹ˆ๋‹ค.
  • from ์—ฐ์‚ฐ์ž๋Š” ์˜ค์ง array ๋งŒ ์ทจํ•ฉ๋‹ˆ๋‹ค.

Observable ๊ตฌ๋…ํ•˜๊ธฐ

์œ„ ์ฝ”๋“œ๋“ค์—์„œ ์ƒ์„ฑํ•œ Observable์€ subscribe ๋ฉ”์†Œ๋“œ๋ฅผ ํ†ตํ•ด ๊ตฌ๋…์„ ํ•ด์•ผ๋งŒ ์ด๋ฒคํŠธ๊ฐ€ ์ถœ๋ ฅ๋˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

Observable์€ ์‹ค์ œ๋กœ sequence์˜ ์ •์˜์ผ ๋ฟ, Observer๊ฐ€ subscribeํ•˜์ง€ ์•Š๋Š”๋‹ค๋ฉด ์•„๋ฌด๋Ÿฐ ์ด๋ฒคํŠธ๋„ ๋‚ด๋ณด๋‚ด์ง€ ์•Š์Šต๋‹ˆ๋‹ค. Subscribe๋Š” observable์˜ stream(๋ฐ์ดํ„ฐ ํ๋ฆ„)์„ ๊ด€์ฐฐํ•˜๊ณ  ๊ตฌ๋…ํ•˜๋Š” ์—ญํ• ์„ ํ•ฉ๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ ๊ตฌ๋…์„ ํ•˜๋Š” ์ฃผ์ฒด๋Š” observer, ๊ตฌ๋… ๋Œ€์ƒ์€ observable ์ž…๋‹ˆ๋‹ค!

๊ตฌ๋…ํ•˜๋Š” ๋ฐฉ๋ฒ•

Observable์„ ๊ตฌ๋…ํ•˜๊ณ  ์‹ถ์„ ๋•Œ subscribe()๋ฅผ ์ด์šฉํ•ด ๊ตฌ๋…์„ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.

 

์ด๋•Œ, Observable์ด ๋ฐฉ์ถœํ•˜๋Š” ๊ฐ๊ฐ์˜ ์ด๋ฒคํŠธ ํƒ€์ž…์— ๋Œ€ํ•ด์„œ handler(์–ด๋–ค ์ผ์ด ๋๋‚ฌ์„ ๋•Œ ์ง„ํ–‰ํ•  ์ผ์„ ๋‹ด๋‹นํ•˜๋Š” ์นœ๊ตฌ)๋ฅผ

์ถ”๊ฐ€ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ตฌ๋…์„ ํ•˜๊ฒŒ ๋˜๋ฉด, ์œ„์—์„œ ๋ณธ ๊ฒƒ ์ฒ˜๋Ÿผ Observable์€ .next, .error, .completed ์ด๋ฒคํŠธ๋“ค์„ ๋ฐฉ์ถœํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

  • .next๋Š” handler๋ฅผ ํ†ตํ•ด ๋ฐฉ์ถœ๋œ ์š”์†Œ๋ฅผ ํŒจ์Šคํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.
  • .error๋Š” error ์ธ์Šคํ„ด์Šค๋ฅผ ๊ฐ€์งˆ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

.subscribe()

.subscribe๋Š” escaping ํด๋กœ์ €๋กœ, Intํƒ€์ž…์˜ ๊ฐ’์ด event๋กœ ์ „๋‹ฌ๋ฉ๋‹ˆ๋‹ค. (์ด ์˜ˆ์ œ์—์„œ๋Š” Observable<Int>๋กœ ๋ณด๊ณ  ์žˆ์œผ๋‹ˆ! )

escaping์— ๋Œ€ํ•œ ๋ฆฌํ„ด๊ฐ’์€ ์—†์œผ๋ฉฐ(Void), .subscribe์€ Disposable์„ ๋ฆฌํ„ดํ•ฉ๋‹ˆ๋‹ค.

์œ„์—์„œ ์˜ˆ์‹œ ์ฝ”๋“œ ํ•˜๋‚˜๋งŒ ๋‹ค์‹œ ๊ฐ€์ ธ์™€์„œ ์‚ดํŽด๋ด…์‹œ๋‹ค!

let observable4 = Observable.from([1,2,3])
observable4.subscribe { event in
  print(event)
}

// ์ถœ๋ ฅ ๊ฒฐ๊ณผ
// next(1)
// next(2)
// next(3)
// completed

ํ”„๋ฆฐํŠธ๋œ ๊ฐ’์„ ๋ณด๋ฉด, Observable์€ ๊ฐ๊ฐ์˜ ์š”์†Œ๋“ค์— ๋Œ€ํ•ด์„œ .next ์ด๋ฒคํŠธ๋ฅผ ๋ฐฉ์ถœํ•˜๋ฉฐ, ์ตœ์ข…์ ์œผ๋กœ .completed๋ฅผ ๋ฐฉ์ถœํ•ฉ๋‹ˆ๋‹ค.

 

Observable์„ ์ด์šฉํ•˜๋‹ค๋ณด๋ฉด, ๋ฐฉ์ถœ๋œ ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์›ํ•˜๋Š” ์ฒ˜๋ฆฌ๋ฅผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๊ธฐ ๋•Œ๋ฌธ์— ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ Observable์ด .next ์ด๋ฒคํŠธ๋ฅผ ํ†ตํ•ด ๋ฐฉ์ถœํ•˜๋Š” ์š”์†Œ์— ๊ฐ€์žฅ ๊ด€์‹ฌ๊ฐ€์ง€๊ฒŒ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

observable.subscribe { event in
  if let element = event.element {
    print(element)
  }
 }
 
 /* Prints:
  1
  2
  3
 */

 

์œ„์™€ ๊ฐ™์ด ๊ฐ’์„ ๋ฐ›์„ ์ˆ˜๋„ ์žˆ๊ฒ ์ง€๋งŒ,

์•„์ฃผ ์ž์ฃผ ์“ฐ์ด๋Š” ํŒจํ„ด์ด๊ธฐ ๋•Œ๋ฌธ์— RxSwift์—๋Š” ์ด ๋ถ€๋ถ„์— ๋Œ€ํ•œ ์ถ•์•ฝํ˜•๋“ค์ด ์žˆ์Šต๋‹ˆ๋‹ค.

Observable์ด ๋ฐฉ์ถœํ•˜๋Š” .next ์ด๋ฒคํŠธ๋ฅผ ์‰ฝ๊ฒŒ ๋ฐ›์•„์„œ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉํ•˜๋Š” .onNext subscribe์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด ์‚ดํŽด๋ด…์‹œ๋‹ค.

.subscribe(onNext: )

.onNext ํด๋กœ์ €๋ฅผ ์ด์šฉํ•ด ์œ„์˜ ์ฝ”๋“œ๋ฅผ ์•„๋ž˜์™€ ๊ฐ™์ด ๋ฐ”๊ฟ€ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

observable.subscribe(onNext: { (element) in
  print(element)
 })
 
 /* Prints:
  1
  2
  3
 */

.onNext ํด๋กœ์ €๋Š” .next ์ด๋ฒคํŠธ๋งŒ์„ ์ „๋‹ฌ์ธ์ž๋กœ ๋ฐ›์•„ ํ•ธ๋“ค๋งํ•˜๊ณ , ๋‹ค๋ฅธ ๊ฒƒ๋“ค์€ ๋ชจ๋‘ ๋ฌด์‹œํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

Observable ๊ตฌ๋… ์ทจ์†Œํ•˜๊ธฐ

์ง€๊ธˆ๊นŒ์ง€ observable์ด ๋ฐฉ์ถœํ•˜๋Š” ์ด๋ฒคํŠธ๋ฅผ ๊ตฌ๋…ํ•ด์„œ ์ด๋ฒคํŠธ๋ฅผ ๋ฐ›์•„์˜ค๋Š” ์ž‘์—…์„ ํ–ˆ์Šต๋‹ˆ๋‹ค.

์ด๋ฒคํŠธ๋ฅผ ๋ฐ›์•„์„œ ์›ํ•˜๋Š” ์ฒ˜๋ฆฌ๋„ ํ•˜๊ณ , ๊ฐ€์ ธ๋‹ค๊ฐ€ ํ•˜๊ณ ์‹ถ์€๊ฑฐ ๋‹คํ–ˆ๋‹ค๋ฉด??

์ด์ œ ๊ทธ๋งŒ..๊ตฌ๋… ์ทจ์†Œ๋ฅผ ํ•ด์•ผ๊ฒ ์ฃ ? ์ด์ œ ๋†”์ค์‹œ๋‹ค..์™œ๋ƒ๋ฉด..๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜๊ฐ€ ์ผ์–ด๋‚˜๋‹ˆ๊นŒ์š”..

์˜ต์ €๋ฒ„๋ธ”...๋†”์ฃผ๋Š”๊ฑฐ..๊ทธ๊ฑฐ ์–ด์ผ€ ํ•˜๋Š”๊ฑด๋ฐ..

 

Observable์€ subscription์„ ๋ฐ›๊ธฐ ์ „๊นŒ์ง„ ์•„๋ฌด ์ง“๋„ ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. (๊ตฌ๋…์„ ๋‹นํ•ด์•ผ ์ด๋ฒคํŠธ ๋ฐฉ์ถœ)

๋”ฐ๋ผ์„œ ๋ฐ˜๋Œ€๋กœ ์ƒ๊ฐํ•ด๋ณด๋ฉด Observable์— ๋Œ€ํ•œ ๊ตฌ๋…์„ ์ทจ์†Œํ•จ์œผ๋กœ์จ Observable์„ ์ˆ˜๋™์ ์œผ๋กœ ์ข…๋ฃŒ์‹œํ‚ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. (๋น„๋™๊ธฐ ์ž‘์—…์„ ์ค‘๊ฐ„์— ๋ฉˆ์ถ”๊ณ  ์ทจ์†Œํ•˜๊ณ  ์‹ถ์„ ๋•Œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ฒ ์ฃ ?)

์œ„์—์„œ .subscribe๊ฐ€ disposable์„ ๋ฆฌํ„ดํ•œ๋‹ค๊ณ  ํ–ˆ์Šต๋‹ˆ๋‹ค. (==๋ฆฌํ„ด ๊ฐ’์œผ๋กœ disposableํ•œ ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค์–ด์ฃผ๋Š” ๊ฒƒ) ๊ตฌ๋… ์ทจ์†Œ ์‹œ, ์š” disposable์„ ์ด์šฉํ•ฉ๋‹ˆ๋‹ค.

1) .dispose()

์–ด๋–ค ์ž‘์—…์„ ์ค‘๋‹จํ•˜๊ณ  ์ทจ์†Œํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด ๊ฐ„๋‹จํ•˜๊ฒŒ dispose()๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

๊ตฌ๋…์„ ์ทจ์†Œ(dispose)ํ•œ ๋’ค์—๋Š” ์ด๋ฒคํŠธ ๋ฐฉ์ถœ์ด ์ •์ง€๋ฉ๋‹ˆ๋‹ค.

    let observable = Observable.of("A", "B", "C")  // ์˜ต์ €๋ฒ„๋ธ” ์ƒ์„ฑ
     
    let subscription = observable.subscribe({ (event) in  // ์˜ต์ €๋ฒ„๋ธ” ๊ตฌ๋…
         
        print(event)  // ๋ฐฉ์ถœ๋˜๋Š” ์ด๋ฒคํŠธ ํ”„๋ฆฐํŠธ
    })
     
    subscription.dispose()   // dispose()ํ˜ธ์ถœ๋กœ ๊ตฌ๋… ์ทจ์†Œ!

์—ฌ๊ธฐ์„œ ๋“œ๋Š” ์˜๋ฌธ..๐Ÿค”

์ด๋ฒคํŠธ๋“ค์ด ๋‹ค ๋ฐฉ์ถœ๋œ ํ›„ completed ๋œ๋‹ค๊ณ  ์•ž์—์„œ ๋งํ–ˆ๋Š”๋ฐ ์™œ ๊ตฌ๋…์„ ์ˆ˜๋™์ ์œผ๋กœ ์ทจ์†Œํ•ด์•ผํ•˜๋Š”๊ฑฐ์ฃ ..??

์œ„์˜ ์ฝ”๋“œ์˜ ๊ฒฝ์šฐ, observable ์•ˆ์—๋Š” 3๊ฐœ์˜ ์š”์†Œ๋งŒ ์žˆ์œผ๋ฏ€๋กœ dispose() ๋ฅผ ํ˜ธ์ถœํ•˜์ง€ ์•Š์•„๋„ completed๊ฐ€ ํ”„๋ฆฐํŠธ ๋˜์ง€๋งŒ

์š”์†Œ๊ฐ€ ๋ฌดํ•œํžˆ ์žˆ๋‹ค๋ฉด dispose() ๋ฅผ ํ˜ธ์ถœํ•ด์•ผ completed ๊ฐ€ ํ”„๋ฆฐํŠธ ๋ฉ๋‹ˆ๋‹ค!

2) DisposeBag()

๊ฐ๊ฐ์˜ ๊ตฌ๋…์— ๋Œ€ํ•ด์„œ ์ผ์ผํžˆ ๊ด€๋ฆฌํ•˜๋Š” ๊ฒƒ(์ƒ์„ฑํ•˜๋Š” subscription ๋งˆ๋‹ค disposeํ•ด์ฃผ๋Š” ๊ฒƒ)์€ ํšจ์œจ์ ์ด์ง€ ๋ชปํ•˜๊ธฐ ๋•Œ๋ฌธ์—, 

RxSwift์—์„œ ์ œ๊ณตํ•˜๋Š” DisposeBag ํƒ€์ž…์„ ์ด์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ง ๊ทธ๋Œ€๋กœ, Disposableํƒ€์ž…์„ ๋‹ด์„ ์ˆ˜ ์žˆ๋Š” ํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค.

 

์‚ฌ์šฉ๋ฐฉ๋ฒ•์€??

subscribe()์˜ ๋ฆฌํ„ดํƒ€์ž…์ธ Disposable์—์„œ disposed(by:)๋ฉ”์†Œ๋“œ๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. (์•„์ฃผ ์ž์ฃผ ์‚ฌ์šฉํ•˜๊ฒŒ ๋  ํ˜•ํƒœ์ž…๋‹ˆ๋‹ค)

๋ฐฉ์ถœ๋œ ๋ฆฌํ„ด๊ฐ’๋“ค์„ disposeBag์— ๋‹ค ๊ฐ–๋‹ค ๋„ฃ์–ด๋†“์œผ๋ฉด, disposeBag์ด ๋ฉ”๋ชจ๋ฆฌ์—์„œ ํ•ด์ œ๋  ๋•Œ ๋ชจ๋“  ๊ตฌ๋…์ด ์ทจ์†Œ๋ฉ๋‹ˆ๋‹ค!

disposeBag ์„ ์–ธ → ์—ฌ๋Ÿฌ ์˜ต์ €๋ฒ„๋ธ”์— ๋Œ€ํ•œ disposable์„ disposebag์— ๋ชจ๋‘ ๋„ฃ๊ธฐ → ๋ฉ”๋ชจ๋ฆฌ์—์„œ ํ•ด์ œ๋  ๋•Œ ๊ตฌ๋…์ทจ์†Œ

  let disposeBag = DisposeBag()  // ์ผ๋‹จ disposeBag์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.
     
  Observable.of("A", "B", "C")   // ์˜ต์ €๋ฒ„๋ธ”์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.
      .subscribe{ 
          print($0)   // ๋ฐฉ์ถœ๋˜๋Š” ์ด๋ฒคํŠธ ํ”„๋ฆฐํŠธ
      }
      .disposed(by: disposeBag)  // subscribe๋กœ๋ถ€ํ„ฐ ๋ฐฉ์ถœ๋œ ๋ฆฌํ„ด๊ฐ’์„ disposeBag์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

[์ฐธ๊ณ ์ž๋ฃŒ]

 

GitHub - fimuxd/RxSwift: RxSwift๋ฅผ ์Šคํ„ฐ๋””ํ•˜๋Š” ๊ณต๊ฐ„

RxSwift๋ฅผ ์Šคํ„ฐ๋””ํ•˜๋Š” ๊ณต๊ฐ„. Contribute to fimuxd/RxSwift development by creating an account on GitHub.

github.com

 

 

[RxSwift] Observable์ด๋ž€ - (2) - jinShine

Observable์ด๋ž€ observable, observable sequence, sequence๋ผ๋Š” ํ‘œํ˜„์„ ์“ฐ๋Š”๋ฐ ์‚ฌ์‹ค ๋‹ค ๊ฐ™์€ ๋ง์ž…๋‹ˆ๋‹ค. ์ค‘์š”ํ•œ๊ฒƒ์€ ์ด๋ฒคํŠธ๊ฐ€ ๋น„๋™๊ธฐ์ ์œผ๋กœ ์ƒ์„ฑํ•˜๋Š” ๊ธฐ๋Šฅ ์ด๋ผ๋Š”๊ฒƒ์ด๊ณ , ๊ณ„์†ํ•ด์„œ ์ด๋ฒคํŠธ๋ฅผ ์ƒ์„ฑํ•˜๋Š”๋ฐ ์ด๋Ÿฌํ•œ

jinshine.github.io

 

 

[RxSwift] Observable (2)

Observable ์ƒ์„ฑํ•ด๋ณด๊ธฐ ์ด์ „ ๊ธ€์—์„œ Observable์ด ๋ฌด์—‡์ธ์ง€ ์•Œ์•˜์œผ๋‹ˆ, ์‹ค์ œ๋กœ ๋ช‡๊ฐ€์ง€ Observable์„ ๋งŒ๋“ค์–ด ์–ด๋–ป๊ฒŒ ๋™์ž‘ํ•˜๋Š”์ง€ ์•Œ์•„๋ณด์ž. 1) .just() ์˜ค์ง ํ•˜๋‚˜์˜ ์š”์†Œ๋ฅผ ํฌํ•จํ•˜๋Š” Observable sequence ์ƒ์„ฑ 2) .of..

jiyeonlab.tistory.com

 

 

RxSwift - Dispose & DisposeBag

Observable์€ subscribe ์ดํ›„ complete ๋˜๋Š” error ์ด๋ฒคํŠธ๊ฐ€ ๋ฐœ์ƒํ•˜๊ธฐ ์ „๊นŒ์ง€ ๊ณ„์† next ์ด๋ฒคํŠธ๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค. "๊ณ„์†" ์ด๋ผ๋Š” ๋‹จ์–ด๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ ์ž…์žฅ์—์„œ ์ฃผ์˜๋ฅผ ๊ธฐ์šธ์—ฌ์•ผ ํ•˜๋Š” ๋‹จ์–ด์ž…๋‹ˆ๋‹ค. ๊ณ„์† ๋™์ž‘ํ•œ

jinsangjin.tistory.com