这段代码是线程安全的吗?
Observable<String> observable = ... // some observable that calls
// onNext from a background thread
observable
.scan(new ArrayList<String>(), (List<String> acc, String next) -> {
acc.add(next);
return acc;
})
.subscribe( list -> {
// do somethind with sequence of lists
...
});
Run Code Online (Sandbox Code Playgroud)
我很好奇,因为ArrayList不是一个线程安全的数据结构.
来自C#,当我使用RX并且有背压时,项目将不断添加到内部队列,直到应用程序内存不足(据我所知).
在ReactiveX(RXJava)中,看起来他们采取了不同的立场,在背压开始建立时抛出异常.
这意味着我必须onBackpressureBuffer()在调用中使用类似的东西来subscribe()传递一个Subscriber<? super T>在流中发出请求以释放压力的东西.
也许是因为我使用了RX.NET方法,但这对我来说似乎很精神.
首先,我是否正确理解了这一点?
其次,无论如何我可以"禁用"这个功能,因此它的行为方式与RX.NET相同,因为我不想subscribe()通过检查是否已实现其中一个背压运算符来使我的调用复杂化我是否需要打电话request().
我几乎卖给了RxJava,它是Retrofit的完美伴侣,但我在迁移代码时遇到了一个共同的模式:为了节省带宽,我想懒得从我的webservice中获取(分页)对象,而我的listview(或recyclerview)使用反应式编程滚动.
我以前的代码完美地完成了这项工作,但是反应式编程似乎值得尝试.
听listview/recyclerview滚动(和其他无聊的东西)不是问题,使用Retrofit很容易获得Observable:
@GET("/api/messages")
Observable<List<Message>> getMessages(@Path("offset") int offset, @Path("limit") int limit);
Run Code Online (Sandbox Code Playgroud)
我只是无法弄清楚在反应式编程中使用的模式.
该Concat操作似乎是一个很好的起点,随着ConnectableObservable在某个时刻推迟发射,也许flatMap,但如何?
编辑:
这是我目前的(幼稚)解决方案:
public interface Paged<T> {
boolean isLoading();
void cancel();
void next(int count);
void next(int count, Scheduler scheduler);
Observable<List<T>> asObservable();
boolean hasCompleted();
int position();
}
Run Code Online (Sandbox Code Playgroud)
我使用一个主题实现:
public abstract class SimplePaged<T> implements Paged<T> {
final PublishSubject<List<T>> subject = PublishSubject.create();
private volatile boolean loading;
private volatile int offset;
private Subscription subscription;
@Override
public boolean isLoading() {
return loading;
}
@Override
public …Run Code Online (Sandbox Code Playgroud) 我正在使用Retrofit与rx-java结合使用,并提出以下问题:
有没有办法在设备脱机时将API调用排队到服务器,以便在设备重新联机时可以触发它们.
我最近开始尝试使用RxJava,并且遇到了Netflix工程师的演示文稿,该工程师建议将我们的业务API移动到Observable API,例如:
public interface VideoService {
Observable<VideoBasicInfo> createVideoBasicInfo(VideoBasicInfo videoBasic);
Observable<VideoBasicInfo> getVideoBasicInfo(Integer videoId);
Observable<VideoRating> getVideoRating(Integer videoId);
}
Run Code Online (Sandbox Code Playgroud)
但是,我没有找到任何解释如何在此服务中管理事务性的地方.起初我只是注释了我的服务实现@Transactional
@Service
@Transactional
public class VideoServiceImpl implements VideoService{
@Autowired
private VideoBasicInfoRepository basicInfoRepo;
@Autowired
private VideoRatingRepository ratingRepo;
public Observable<VideoBasicInfo> createVideoBasicInfo(VideoBasicInfo videoBasic){
return Observable.create( s -> {
s.onNext(basicInfoRepo.save(videBasic));
});
}
Run Code Online (Sandbox Code Playgroud)
我们想要的是Object.createlambda(s -> { // This code })中所有代码的执行都发生在事务中.但是,实际发生的是:
createVideoBasicInfo()事务方式执行,返回冷可观察对象.save()执行就象一个原子事务.显然它是有道理的,因为Spring代理适用于serviceImpl方法.我已经想到了如何做我真正期望的事情,例如启动程序化事务:
return Observable.create( s -> {
VideoBasicInfo savedBasic = transactionTemplate.execute( status -> {
VideoBasicInfo basicInfo = …Run Code Online (Sandbox Code Playgroud) 我看到ReactiveX(RxJava)有一个运算符timeout,它将应用于订阅流中的每个项目.但我只想检查超时的第一个响应,而不关心以下响应的超时.如何使用RxJava的运算符优雅地实现此要求?
大家!我有一些问题.我是RxJava/RxKotlin/RxAndroid的初学者,并且不了解一些功能.例如:
import rus.pifpaf.client.data.catalog.models.Category
import rus.pifpaf.client.data.main.MainRepository
import rus.pifpaf.client.data.main.models.FrontDataModel
import rus.pifpaf.client.data.product.models.Product
import rx.Observable
import rx.Single
import rx.lang.kotlin.observable
import java.util.*
class MainInteractor {
private var repository: MainRepository = MainRepository()
fun getFrontData() {
val cats = getCategories()
val day = getDayProduct()
val top = getTopProducts()
return Observable.zip(cats, day, top, MainInteractor::convert)
}
private fun getTopProducts(): Observable<List<Product>> {
return repository.getTop()
.toObservable()
.onErrorReturn{throwable -> ArrayList() }
}
private fun getDayProduct(): Observable<Product> {
return repository.getSingleProduct()
.toObservable()
.onErrorReturn{throwable -> Product()}
}
private fun getCategories(): Observable<List<Category>> {
return repository.getCategories()
.toObservable() …Run Code Online (Sandbox Code Playgroud) 我想用android中的RxJava替换我的AsyncTask.我目前的AsyncTask是这样的:
public class ProgressBarAsyncTask extends AsyncTask<Void,Void,Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
ringProgressDialog = ProgressDialog.show(context,"MyProgressBarTitle","Working please wait",true, false);
}
@Override
protected Void doInBackground(Void... void) {
//do work
myTask();
return null;
}
@Override
protected void onPostExecute(Void void) {
super.onPostExecute();
ringProgressDialog.dismiss();
}
}
Run Code Online (Sandbox Code Playgroud)
这是我的RxJava替代品:
public static Observable<Void> getObservable(final Context context,final String... params) {
return Observable.defer(new Func0<Observable<Void>>() {
@Override
public Observable<Void> call() {
return Observable.just(myTask());
}
});
}
public static Subscriber<Void> getSubscriber() {
Subscriber<Void> subscriber = new Subscriber<Void>() {
@Override
public void …Run Code Online (Sandbox Code Playgroud) 我是使用RxAndroid和RxJava的新手.我正在使用RxJava + Retrofit2来发出GET请求.我使用以下代码执行大约1500 GET请求并获得内存不足错误.不过相同的代码这次只有改装,没有RxAndroid,它的工作原理.所以我的结论是我在RxAndroid中做错了什么.你能帮我解决一下我失踪的事吗?
代码示例:
Subject<Story> mStoryEmitter = PublishSubject.create();
private void getStory(int storyID) {
HNApi.Factory.getInstance().getStory(storyID).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(getStoryObserver());
}
mStoryListEmitter.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable d) {}
@Override
public void onNext(List<Integer> value) {
if(mRecyclerView != null) {
mRecyclerView.setAdapter(null);
if(mAdapter != null) {
mAdapter.clear();
mAdapter = null;
}
}
mAdapter = new SimpleRecyclerViewAdapter();
mRecyclerView.setAdapter(mAdapter);
for(Integer storyID : value) {
getStory(storyID);
}
}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
private DisposableObserver<Story> getStoryObserver() {
DisposableObserver<Story> observer = …Run Code Online (Sandbox Code Playgroud) Maybe switchIfEmpty如果源Maybe为空,我使用方法提供替代结果.但是,我希望仅在源为空时执行备用源,而在源不为空时不执行备用源.
在下面的例子中,我想避免执行costlyFallback如果源返回非空Maybe.当前实现总是调用它,因为它需要传递给switchIfEmpty方法.Maybe.fromCallable看起来很有希望,但它只适用于不包括返回a的callables Maybe.empty.任何提示都表示赞赏.如果switchIfEmpty愿意接受一些懒惰的评估Maybe提供者会很好.
public class StartRxMaybe {
public static void main(String... args) {
System.out.println(new StartRxMaybe().start().blockingGet());
}
private Maybe<Integer> start() {
return func()
.switchIfEmpty(costlyFallback());
}
private Maybe<Integer> func() {
System.out.println("Non-empty maybe returned");
return Maybe.just(1);
}
private Maybe<Integer> costlyFallback() {
System.out.println("Fallback executed anyway");
return LocalDate.now().getMonth() == Month.JULY
? Maybe.just(2)
: Maybe.empty();
}
}
Run Code Online (Sandbox Code Playgroud)