[Android] RxJava의 초기 장

RxJava 정보

RxJava는 Java VM 환경에서 사용하기 위해 ReactiveX에서 출시한 비동기 작업 라이브러리입니다. ReactiveX는 Java 환경 외에도 Py, Js, Go 등과 같은 다른 프로그래밍 언어를 위한 Rx 라이브러리도 실행합니다. 인터넷에는 RxJava에 대한 소개와 활용이 많이 있고, 안드로이드 개발에도 RxJava를 활용한 프로젝트가 많이 있습니다. 그렇다면 RxJava를 사용하는 이유는 무엇일까요? Android 개발에서는 개발자가 사용할 수 있는 비동기 작업 방법도 제공합니다. RxJava는 Handle 및 AsyncTask보다 더 간단하고 우아하다고 생각합니다.

1 RxJava는 프로그램 로직이 명확하고 간결한 체인 호출을 사용합니다

2 확장된 관찰자 디자인 패턴을 사용합니다

관찰자 패턴 및 기타 RxJava에 대한 소개입니다. 반복하지 않고 다음 내용은 주로 RxJava 및 RxAndroid의 사용에 중점을 둡니다. RxJava 공식 문서에 자세히 소개되어 있습니다. 주로 학습과 토론을 위한 부분이므로, 오류가 있으면 지적해 주시기 바랍니다.

Observable Observable

RxJava를 사용하려면 데이터를 내보내는 데 사용되는 Observable을 만들어야 합니다. 다음 Observable의 생성 메소드는 Action1>에서 상속되는 OnSubscribe를 전달해야 합니다.

public static <T> Observable<T> create(OnSubscribe<T> f) { 
    return new Observable<T>(RxJavaHooks.onCreate(f)); 
}

또한 create 메소드는 인터페이스 호출을 구현하고 구독자 객체를 반환해야 합니다. call 메소드는 Observable이 구독된 후 실행될 이벤트 스트림을 구현합니다. subscriber.onNext는 데이터를 내보내고 subscriber.onCompleted는 내보내기 이벤트의 끝을 나타낼 수 있습니다. 그런 다음 Observable의 구독 메서드를 호출하여 구독 후 실행되는 이벤트 스트림을 구현합니다.

Observable<String> observable = Observable 
                .create(new Observable.OnSubscribe<String>() { 
 
            @Override 
            public void call(Subscriber<? super String> subscriber) { 
                subscriber.onNext("1"); 
                subscriber.onNext("2"); 
                subscriber.onNext("3"); 
                subscriber.onNext("4"); 
                subscriber.onNext("5"); 
            } 
}); 
Subscriber<String> subscriber = new  Subscriber<String>() { 
            @Override 
            public void onCompleted() { 
 
            } 
 
            @Override 
            public void onError(Throwable e) { 
 
            } 
 
            @Override 
            public void onNext(String s) { 
                System.out.print(s + &#39;\n&#39;); 
            } 
}; 
observable.subscribe(subscriber); 
//输出结果 print： 
//1 
//2 
//3 
//4 
//5

Observable을 생성하기 위해 create 메소드를 사용하는 것 외에도 from 또는 just를 사용하여 방출된 이벤트 스트림을 빠르게 설정하여 생성 단계를 단순화할 수도 있습니다.

Observable<String> o = Observable.from("a", "b", "c");

Observable<String> o = Observable.just("one object");

동의된 비동기 작업

RxJava의 스레드는 스케줄러 스케줄러에 의해 제어됩니다. . 특정 작업이 수행되는 스레드를 제어하는 ​​데 사용합니다.

Schedulers.immediate() 현재 스레드에서 실행

Schedulers.newThread() 실행할 작업별로 스레드를 생성

Schedulers.computation() 스레드 계산 작업이 실행되는

Schedulers.io() IO 작업이 실행되는 스레드....

AndroidSchedulers.mainThread() Android 메인 스레드가 실행되는 스레드

스레드 제어는 주로 done by subscribeOn() 및observOn()은 두 가지 메서드로 제어됩니다.

subscribeOn은 Observable.OnSubscribe가 있는 스레드를 제어합니다. 이는 Observable create, just 및 from이 있는 스레드와 동일합니다. .

observeOn은 제어 이벤트가 실행되는 스레드라고도 할 수 있는 구독자의 스레드를 제어합니다.

Observable 
        .just(1,2,3) 
        .subscribeOn(Schedulers.io()) 
        .observeOn(AndroidSchedulers.mainThread()) 
        .subscribe(new Subscriber<Integer>() { 
            @Override 
            public void onCompleted() { 
 
            } 
 
            @Override 
            public void onError(Throwable e) { 
 
            } 
 
            @Override 
            public void onNext(Integer integer) { 
                 System.out.print(integer + &#39;\n&#39;);                        
            } 
}); 
//输出结果 print： 
//1 
//2 
//3

위의 RxJava 체인 호출 코드를 적어보세요. 이전에 사용했던 비동기 호출보다 훨씬 신선하다고 생각하시나요? Virgos도 이것이 매우 힐링된다고 말합니다!

운영자

ReactiveX는 많은 연산자를 제공하며 각 연산자는 서로 다른 기능을 가지고 있지만 목적은 Observable과 Subscribe 사이에서 발생된 이벤트 스트림을 변환하고 수정하는 것입니다. 이 섹션에서는 몇 가지 일반적이고 간단한 연산자를 소개합니다. 나중에 기회가 되면 연산자에 대한 다른 섹션을 작성하여 각 연산자의 역할을 자세히 설명하겠습니다. 공식 운영자 문서에 첨부되어 있으면 얼마나 많은지 알 수 있습니다.

Map()

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) { 
        return create(new OnSubscribeMap<T, R>(this, func)); 
    }

먼저 map은 T형 데이터를 R형 데이터로 변환하고 R을 반환하는 Func1 인터페이스를 구현합니다. 데이터를 입력합니다. 예를 들어, Integer 유형의 이벤트 큐가 전달되어 맵 처리 후 String 유형으로 반환됩니다.

Observable 
                .just(1,2,3) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                    ...... 
                    @Override 
                    public void onNext(String str) { 
                        System.out.print(str + &#39;\n&#39;); 
                    } 
                }); 
//输出结果 print： 
//1 
//2 
//3

Filter()

public final Observable<T> filter(Func1<? super T, Boolean> predicate) { 
       return create(new OnSubscribeFilter<T>(this, predicate)); 
   }

filter는 map과 같은 Func1 인터페이스를 구현하지만 변환된 유형은 부울이므로 생성된 이벤트 스트림 변환된 부울 값이 true이면 구독자는 필터링을 통과한 이벤트를 수신할 수 있습니다. 그렇지 않으면 이벤트가 소비되지 않습니다. 예를 들어 이벤트 스트림 필터링에서는 int 값을 2로 나눌 수 있어야 계속해서 전달될 수 있으므로 구독자가 사용할 수 있는 최종 이벤트는 2, 4, 6, 8 및 10입니다.

Observable 
                .just(1,2,3,4,5,6,7,8,9,10) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .filter(new Func1<Integer, Boolean>() { 
                    @Override 
                    public Boolean call(Integer integer) { 
                        return integer % 2 == 0; 
                    } 
                }) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                   ...... 
                    @Override 
                    public void onNext(String str) { 
                        System.out.print(str + &#39;\n&#39;); 
                        Log.i("subscribe", str); 
                    } 
                }); 
//输出结果 print： 
//2 
//3 
//4 
//6 
//8 
//10

Skip()

public final Observable<T> skip(int count) { 
        return lift(new OperatorSkip<T>(count)); 
    }

건너뛰기 연산자는 처음 몇 개의 이벤트를 건너뛰고 특정 이벤트에서 이벤트 방출을 시작한다는 의미입니다. 0부터 시작하세요.

Observable 
                .just(1,2,3,4,5,6,7,8,9,10) 
                .subscribeOn(Schedulers.io()) 
                .observeOn(AndroidSchedulers.mainThread()) 
                .skip(3) 
                .map(new Func1<Integer, String>() { 
                    @Override 
                    public String call(Integer integer) { 
                        return integer + ""; 
                    } 
                }) 
                .subscribe(new Subscriber<String>() { 
                    ...... 
                    @Override 
                    public void onNext(String s) { 
                        System.out.print(s + &#39;\n&#39;); 
                        Log.i("subscribe", s); 
                    } 
                }); 
//输出结果 print： 
//4 
//5 
//6 
//7 
//8 
//9 
//10

Range()

public static Observable<Integer> range(int start, int count) { 
        if (count < 0) { 
            throw new IllegalArgumentException("Count can not be negative"); 
        } 
        if (count == 0) { 
            return Observable.empty(); 
        } 
        if (start > Integer.MAX_VALUE - count + 1) { 
            throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE"); 
        } 
        if(count == 1) { 
            return Observable.just(start); 
        } 
        return Observable.create(new OnSubscribeRange(start, start + (count - 1))); 
    }

범위 연산자는 연속 int 유형 배열을 전달하여 방출되는 것으로 이해될 수 있습니다. n은 시작 int 값이고, m은 Count입니다. 예를 들어 n = 1, m = 5 int 배열은 {1, 2, 3, 4, 5}

End

입니다.

RxJava에 대한 사전 이해와 학습으로 간주되는 이 섹션에서 이것을 먼저 배웠습니다. 실제로 RxJava를 사용하는 것은 주로 연산자의 사용에 의존합니다. 앞에서 소개한 연산자는 가장 간단하고 가장 기본적이며 아직 소개되지 않은 특히 유용한 연산자가 많이 있습니다. 나중에 일부 연산자를 계속 소개하겠습니다. RxJava는 그 강력함으로 인해 Android 개발에서 매우 인기가 높습니다. 동시에 RxJava를 Retrofit과 함께 사용하여 네트워크 요청 반환 값을 보다 효율적으로 처리할 수 있습니다. 또한 GitHub GoogleSample의 android-architecture에는 RxJava 프레임워크를 사용하는 TODO 프로젝트도 있습니다. 프로젝트에서 RxJava를 실제로 적용하는 방법을 살펴보고 이해할 수 있습니다.