3. RxJava is ...
RxJava → Reactive Extension for Java
Rx → Reactive Extension
→ An API for asynchronous programming with observable streams
“ReactiveX is a combination of the best ideas from the Observer pattern,
Iterator pattern, and functional programming”
4. Observer Pattern
● 데이터 발행에 필요한 비지니스 로직을 제 3자에게 위임
● Push-based : 데이터가 발행될 때 CallBack 으로 업데이트
● 데이터의 발생을 이벤트로 가정하면, 이벤트의 스트림에 의해 옵저버가 Push 당하는 구조
Observer Observable
FileSystem
Network
DB
CallBack
5. Observer Pattern
● 모든 데이터를 Push 기반 스트림으로 해석
● 스트림은 데이터가 발생 되었을 때 이름 옵저버까지 Push
● 옵저버는 Push 될 때마다 콜백 실행
Merge
Button1
Button2
merge(Button1, Button2)
클릭 이벤트 스트림
Observer
executeCallback
6. Functional Programming
● 함수형 프로그래밍이란, 코드 작성의 기준을 함수로 두는 코딩 패러다임
○ 함수는 외부로부터 독립적인 순수 함수
○ 불변 데이터를 사용
○ 함수와 함수를 결합하여 다른 함수를 구현 ( ex : h(x) = f•g(x) )
● 함수형 프로그래밍이 주목 받는 이유
○ 멀티 코어의 출현으로 병렬 처리의 중요성이 점점 커짐
○ 순수한 함수형 프로그래밍에서는 병렬 처리에서 함수 간의 간섭이 일어나지 않음
(Thread Safe)
Functional Programming is …
In computer science, functional programming is a programming paradigm that treats
computation as the evaluation of mathematical functions and avoids changing-state and
mutable data
from Wikipedia
7. Functional Programming
f(x) = x+2
● 순수 함수 : 외부와의 의존성을 단절시켜 Side-Effect가 나타나지
않음
● 함수 내부에서 멤버 변수 혹은 전역 변수 등의 참조가
일어나면 안 됨
● 인자 또한 불변 객체로서 내부에서 변화를 주면 안 됨
Function<Integer, Integer> f = new Function<Integer, Integer>() {
@Override
public Integer apply(Integer x) {
return x + 2;
}
};
8. Functional Programming
f(x) = x+2
g(x) = x*2
h(x) = x-2
i(x) = ((x+2)*2)-2 = 2x+2
Function<Integer, Integer> f = x -> x + 2;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = x -> x - 2;
Function<Integer, Integer> i = f.andThen(g).andThen(h);
● 순수 함수간의 결합으로 새로운 순수 함수를
생성
● 순수한 스트림의 결합은 순수한 스트림을
생성
● 함수 결합
9. Functional Programming
● 순수 함수는 외부 상태와 독립적으로 실행
● 다중 스레드에서 동시 호출 되어도, 서로가 영향을 미치지 않음 → 동기화 신경 쓸 필요 없음
● 스트림의 순수성이 보장된다면, 스트림은 다중 스레드에 안전함
public void test(){
for (int v = 0; v < 100; v++) {
final int x = v;
new Thread(() -> System.out.println(i.apply(x))).start();
}
}
Function<Integer, Integer> f = x -> x + 2;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = x -> x - 2;
Function<Integer, Integer> i = f.andThen(g).andThen(h);
● 스레드 안전
10. Rx is
“ReactiveX = Observer pattern + Iterator pattern + Functional programming”
- Observer pattern
- 데이터 생성의 비지니스 로직을 제 3자에게 위임
- 작업이 완료되면 콜백으로 데이터 받음
- 데이터의 스트림에서 비동기적으로 콜백을 Push 받는 구조
- Functional Programming
- 데이터 처리를 함수형 프로그래밍 기법을 활용하여 코딩
- 데이터 처리 로직 간의 동기화 이슈 제거. 스레드 세이프 코딩 가능
- 순수한 스트림의 조합으로 스레드에 안전한 비동기 코드 작성 가능
11. 실행결과
James
Jack
Observable.just(
new User("Mike", 20),
new User("James", 25),
new User("Jack", 30))
.filter(user -> user.getAge() > 24)
.map(user -> user.getName())
.subscribe(System.out::println);
RxJava 기본 구성
Observer
Pattern
Functional
Programming
데이터 생성
데이터 처리
데이터 실행(옵저버
등록)
12. RxJava 장점
● 비동기 처리
○ 높은 생산성
○ 효율적인 다중 스레드 처리
○ 쉬운 에러 처리
○ 좋은 가독성
● 결합을 통한 뛰어난 재사용성
● 스트림 방식을 통한 라이프 사이클 제어
13. RxJava 장점 - 비동기 처리 - 높은 생산성
Observable.just(1,2,3,4)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println(integer);
}
});
● 각 코드를 수행할 스레드를 손쉽게 지정해서 빠르게 코딩 가능
○ subscribeOn(scheduler) : 최초 데이터 생성되는 곳부터의 스레드를 지정. 중복해도 하나만 적용.
○ observeOn(scheduler) : 본 코드를 기준으로 다운스트림(이후 코드)의 스레드를 지정. 중복 가능.
Schedulers.io()
AndroidSchedulers
.mainThread()
14. RxJava 장점 - 비동기 처리 - 효율적인 다중 스레드 처리
● 비동기 요청들을 서로 결합하여 손쉽게 다중 스레드를 연결 가능
getTokenAsync()
.flatMap(token -> Observable.zip(
getBigDataAsync(token),
getSmallDataAsync(token),
(bigData, smallData) -> bigData.toString() + " | " + smallData.toString()))
.observeOn(AndroidSchedulers.mainThread())
.subscribe(System.out::println);
getTokenAsync
getBigDataAsync
getSmallDataAsync System.out.println
15. RxJava 장점 - 비동기 처리 - 쉬운 에러 처리
● 비동기 처리 중간 에러 핸들링을 위한 다양한 기능을 제공
○ onError : 기본적으로 에러가 발생하면 최종 옵저버의 onError 콜백 호출
○ onErrorReturn : 에러가 발생했을 때 대체할 값을 지정
○ retry : 에러가 발생했을 때 재시도 여부를 설정
○ doOnError : 에러가 발생했을 때 코드 삽입 가능
16. RxJava 장점 - 비동기 처리 - 쉬운 에러 처리
Observable.just(1, 3, 5, 7).filter(i -> i > 3).map(i -> i / 0)
.doOnError(t -> System.out.println("doOnError : " + t.getMessage()))
.retry(1).onErrorReturn(throwable -> 2)
.subscribe(new Observer<Integer>() {
public void onSubscribe(Disposable d) { … }
public void onNext(Integer integer) { … }
public void onError(Throwable e) { … }
public void onComplete() { … }
});
doOnError
retry(1)
onErrorReturn(2)
filter map
17. RxJava 장점 - 비동기 처리 - 쉬운 에러 처리
getTokenAsync()
.doOnError(th -> handleErrorInProcessing(th))
.flatMap(token -> Observable.zip(
getBigDataAsync(token), getSmallDataAsync(token),
(bigData, smallData) -> bigData.toString() + " | " + smallData.toString()))
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
public void onSubscribe(Disposable d) { }
public void onNext(String s) { System.out.println(s); }
public void onError(Throwable t) { handleError(t); }
public void onComplete() { }
});
getTokenAsync
getBigDataAsync
getSmallDataAsync
Observer{
onNext(println())
onError()
}
doOnError
18. RxJava 장점 - 비동기 처리 - 좋은 가독성
● 코드의 구성을 operator 와 scheduler 지정으로 표현 → 전체 코드 흐름이 한 눈에 들어옴
getTokenAsync()
.flatMap(token -> Observable.zip(
getBigDataAsync(token),
getSmallDataAsync(token),
(bigData, smallData) -> bigData.toString() + " | " + smallData.toString()))
.observeOn(AndroidSchedulers.mainThread())
.subscribe(System.out::println);
getTokenAsync
getBigDataAsync
getSmallDataAsync System.out.println
19. RxJava 장점 - 결합을 통한 뛰어난 재사용성
● Observable 형태로 모든 데이터 발행이 이루어짐
● 기존에 작성해 놓은 코드를 조합해서 새로운 Observable 생성 가능
Observable<Object> clicks1 = RxView.clicks(button1);
Observable<Object> clicks2 = RxView.clicks(button2);
Observable.merge(clicks1, clicks2)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
showToast("btn1 or btn2 clicked!");
}
});
Merge
Button1
Button2
merge(Button1, Button2)
20. RxJava 장점 - 스트림 방식을 통한 라이프 사이클 제어
● 시점을 고려하지 않고 스트림 생성
● 원하는 시점에 스트림을 구독을 해지
public class RxViewActivity extends AppCompatActivity {
Disposable disposable;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rx_view);
Button button = findViewById(R.id.rx_view_btn);
Observable<Object> clicks = RxView.clicks(button);
disposable = clicks.flatMap(obj -> doHeavyProcess(obj))
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
}
protected void onDestroy() {
super.onDestroy();
disposable.dispose();
}
Dispose
실행 실행
21. RxJava 단점
● 높은 교육 비용
○ 이해도 부족으로 인한 잘못된 코딩 가능성
○ 추후 멤버 영입 시 똑같은 교육 비용을 지불해야 함
● 람다식 사용 불가시 불필요 코드가 많음
22. RxJava 단점 - 높은 교육 비용
RxJava
Observer Stream
Functional
Programming
Operators
Observable
Lambda
Expression
Stateless
Monard
Pure Function
Flowable
Subject
High Order
Function
Category
Theory
Immutable
Flatmap
Defer
Lazy
Evaluation
Backpressure
Retrofit Kotlin Scheduler
Executor
25. 결론
● RxJava는 복잡한 비동기 처리 및 콜백 지옥을 해결하는데 중요한 키
● Learning Curve가 높기 때문에, 도입 전 충분한 스터디가 필요
● 모든 코드에 적용하는 것이 아니라, 필요한 곳에 적용하는 것이 올바른 접근
● RxJava 도입 시 Kotlin, Retrofit 등의 궁합이 좋은 언어 및 라이브러리 사용을
고려
26. Github
● 스터디 중 지속적으로 Sample 추가 할 예정
○ RxJavaSample
○ RxAndroidSample
