RxJava- Когда не использовать наблюдение?

Question

Я столкнулся с сценарием в использовании RxJava, и я не совсем уверен, следует ли использовать Observable<T> или окончательный ImmutableList<T>.

В принципе, если я импортирую окончательный и неизменный набор данных один раз и никогда больше, должен ли я действительно разоблачить это как холодный Observable<T>?

public final class StrategyManager { 

    private static final StrategyManager instance = new StrategyManager(); 

    private final ImmutableList<Strategy> strategies; 

    private StrategyManager() { 
     strategies = //import from db 
    } 
    public Observable<Strategy> getStrategies() { 
     return Observable.from(strategies); 
    } 
    public static StrategyManager get() { 
     return instance; 
    } 
} 

Или я должен просто разоблачить его как ImmutableList<T>?

public final class StrategyManager { 

    private static final StrategyManager instance = new StrategyManager(); 

    private final ImmutableList<Strategy> strategies; 

    private StrategyManager() { 
     strategies = //import from db 
    } 
    public ImmutableList<Strategy> getStrategies() { 
     return strategies; 
    } 
    public static StrategyManager get() { 
     return instance; 
    } 
} 

Если я разоблачить его как ImmutableList<T>, клиенты имеют один меньше монаду, чтобы иметь дело с за то, что всегда будет постоянным.

Однако, возможно, я теряю гибкость и должен использовать Observable<T>. Например, я могу решить использовать RxJava-JDBC для запроса данных непосредственно при каждом вызове без кэширования. Или я могу cache() или даже replay(), поэтому данные могут истекать и освобождать память.

public final class StrategyManager { 

    private static final StrategyManager instance = new StrategyManager(); 

    private final Observable<Strategy> strategies; 

    private Database db = null; 

    private StrategyManager() { 
     strategies = db.select("SELECT * FROM STRATEGY") 
       .autoMap(Strategy.class) 
       .replay(1, TimeUnit.MINUTES) 
       .autoConnect(); 
    } 
    public Observable<Strategy> getStrategies() { 
     return strategies; 
    } 
    public static StrategyManager get() { 
     return instance; 
    } 
} 

Так что мой вопрос, есть ситуации, не использующие Observable? Или в реактивном приложении, должен ли я всегда использовать Observable даже для постоянных наборов данных, которые не будут меняться? Правильно ли, что я должен использовать последний для гибкости и легко меняющегося поведения?

Answer 1

Мне нравится вопрос. Я полагаю, что существует множество факторов, влияющих на принятие решения об использовании реактивного API и отсутствие ясного ответа «Да» или «Нет», а также просто решение о том, что может задержать будущее.

Должен ли я всегда использовать Наблюдаемый даже для постоянных наборов данных, которые не изменятся?

Если вы хотите максимальную гибкость, не возражает обременяя клиент с помощью RxJava, не против отладки трудности (вы уже видели давно RxJava stacktraces), а затем использовать наблюдаемый. Обратите внимание, что даже для «постоянного набора данных, который не изменится» ваши ограничения памяти могут измениться, и большой набор данных может оказаться непригодным для хранения в памяти.

Еще одна вещь, о которой следует помнить, состоит в том, что у Observables есть некоторые накладные расходы на обработку (волатильное считывание на каждую эмиссию для потенциально каждого оператора в цепочке), поэтому по соображениям производительности иногда не рекомендуется использовать.

Ваши прецеденты, ваши данные и ваши контрольные точки будут действительно определять, в какую сторону вы идете.

Было бы интересно услышать от разработчиков API в Netflix (и в другом месте) об их опыте.