[RxJava2] Observable의 팩토리함수들 : fromArray(), fromIterable(), fromCallable(), fromFuture(), fromPublisher()

공감 및 댓글은 포스팅 하는데  아주아주 큰 힘이 됩니다!! 포스팅 내용이 찾아주신 분들께  도움이 되길 바라며 더 깔끔하고 좋은 포스팅을  만들어 나가겠습니다^^

지난 포스팅에서 just(), create() 에 대해 공부했는데요.

위 두 함수는 단일 데이터를 다뤘습니다.

그럼 단일 데이터가 아닌 경우에는 어떻게 해야할까요.

fromArray(), fromIterable(), fromCallable(), fromFuture(), fromPublisher()

위 친구들처럼 fromXXX() 함수들을 이용하면 됩니다.

fromArray()

이름처럼 배열 데이터를 처리할 때 사용합니다.

예제.

import java.util.stream.IntStream;
 
import io.reactivex.Observable;
 
public class FromArray {
 
    public static void main(String[] args) {
        FromArray fa = new FromArray();
        fa.correct();
        System.out.println("-----------");
        fa.incorrect();
        System.out.println("-----------");
        fa.fromIncorrectToCorrect();
    }
    
    public void correct() {
        Integer[] arr = {1, 2, 3};
        
        Observable.fromArray(arr)
        .subscribe(System.out::println);
    }
    
    public void incorrect() {
        int[] arr = {1, 2, 3};
        
        Observable.fromArray(arr)
        .subscribe(System.out::println);
    }
    
    public void fromIncorrectToCorrect() {
 
        int[] arr = {1, 2, 3};
        
        Observable.fromArray(fromIntToInteger(arr))
        .subscribe(System.out::println);
    }
    
    public Integer[] fromIntToInteger(int[] arr) {
        return IntStream.of(arr).boxed().toArray(Integer[]::new);
    }
 
}
 

fromArray() 에 들어갈 배열들 중에 정수 배열을 예로 들었는데요.

fromArray에 인자로 정수 배열이 들어갈 경우 

int[] 가 아니라 Integer[]로 선언해줘야

결과를 정상적으로 받을 수 있습니다.

incorrect() 함수를 호출한 결과를 보면 배열의 이름이 나오고 있죠?

그럴 경우 fromIncorrectToCorrect() 함수처럼 하면 됩니다.

int[] 배열을 Integer[] 배열로 박싱하는거죠.

fromIterable()

예제를 보시면 쉽게 이해가 가실거에요.

Iterable 인터페이스를 구현하는 

ArrayList, HashSet 등이 인자로 사용됩니다.

import java.util.ArrayList;
 
import io.reactivex.Observable;
 
public class FromIterable {
 
    public static void main(String[] args) {
        FromIterable fi = new FromIterable();
        fi.fromIterable();
    }
    
    public void fromIterable() {
        ArrayList<String> list = new ArrayList<>();
        list.add("April");
        list.add("Babie");
        list.add("Chris");
        
        Observable.fromIterable(list)
        .subscribe(System.out::println);
        
    }
 
}
 

fromCallable()

Callable 인터페이스를 구현한 클래스가 인자로 들어갑니다.

import java.util.concurrent.Callable;
 
import io.reactivex.Observable;
 
public class FromCallable {
 
    public static void main(String[] args) {
        FromCallable fc = new FromCallable();
        CCallable c = fc.new CCallable();
    
        fc.call(c);
        System.out.println("--------");
        fc.lambdaCall();
    }
    
    public void lambdaCall() {
        Callable<String> call = () -> {
            Thread.sleep(500);
            return "Helloworld";
        };
        Observable.fromCallable(call)
        .subscribe(System.out::println);
        
    }
 
    public void call(Callable<String> callable) {
        Observable.fromCallable(callable)
        .subscribe(System.out::println);
    }
    
    class CCallable implements Callable<String> {
 
        @Override
        public String call() throws Exception {
            Thread.sleep(1000);
            return "hello world";
        }
        
    }
    
}
 

fromFuture() 

import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
import io.reactivex.Observable;
 
public class FromFuture {
 
    public static void main(String[] args) {
        FromFuture ff = new FromFuture();
        ff.future();
    }
    
    public void future() {
        Future<?> future = Executors.newSingleThreadExecutor().submit(() -> {
            Thread.sleep(1000);
            return "Hello world";
        });
        
        Observable.fromFuture(future)
        .subscribe(System.out::println);
    }
 
}
 

fromPublisher()

Publisher 는 Java9 의 표준인 Flow API의 일부입니다.

import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
 
import io.reactivex.Observable;
 
public class FromPublisher {
 
    public static void main(String[] args) {
        FromPublisher fp = new FromPublisher();
        fp.publishing();
    }
    
    public void publishing() {
        Publisher<String> pub = (Subscriber<? super String> s) -> {
            s.onNext("Hello Pub");
            s.onComplete();
        };
        
        Observable<String> pubs = Observable.fromPublisher(pub);
        pubs.subscribe(System.out::println);
        
    }
 
}
 

여기까지 Observable의 fromXXX() 팩토리 함수 5가지에 대해 간단히 예제를 통해

사용 방법에 대해서 알아보았습니다.

다음 포스팅에서는 Single 클래스에 대해 공부합니다.