Android flatMap中的NetworkOnMainThreadException

我是

rxjava

或rxandroid的新手，我想将我的

AsyncTask

更改为

observable

和

subscriber

。但我有一个问题。我需要对我的数据库执行两个请求

我对第一个请求的响应将是第二个请求的结果。我试图用

flatMap

解决这个问题。第一个请求返回值，一切正常，但下一个请求给我

NetworkOnMainThreadException

我知道请求是在

主线程上执行的，但是为什么呢？我尝试在
flatMap
之前添加
subscribeOn（Schedulers.io（））
，但结果是一样的。你能帮我解释一下我做错了什么吗？提前谢谢。我的代码

private void getFavouriteList(){
    Observable.create((Observable.OnSubscribe<PaginatedScanList<UserDO>>) subscriber -> {
        final Map<String, AttributeValue> filterExpressionAttributeValues = new HashMap<>();
        filterExpressionAttributeValues
                .put(":val1", new AttributeValue().withS(sharedPreferences.getString("socialId", "")));
        final DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
                .withFilterExpression("socialId = :val1")
                .withExpressionAttributeValues(filterExpressionAttributeValues);
        PaginatedScanList<UserDO> result = dynamoDBMapper.scan(UserDO.class, scanExpression);
        Log.d(TAG, "first result size " + result.size());
        subscriber.onNext(result);
        subscriber.onCompleted();
    })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .filter(result -> {
                if(result.isEmpty()) {
                    Toast.makeText(context, "Can not find user", Toast.LENGTH_SHORT).show();
                    return false;
                }
                return true;
            })
            .flatMap(user -> Observable.from(user.get(0).getFavourites()))
            .subscribeOn(Schedulers.io())
            .flatMap(result -> {
                final Map<String, AttributeValue> filterExpressionAttributeValues = new HashMap<>();
                filterExpressionAttributeValues
                        .put(":val1", new AttributeValue().withS(result));
                filterExpressionAttributeValues
                        .put(":val2", new AttributeValue().withN("1"));
                final DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
                        .withFilterExpression("productId = :val1 and selling = :val2")
                        .withExpressionAttributeValues(filterExpressionAttributeValues);
                PaginatedScanList<ProductDO> res = dynamoDBMapper.scan(ProductDO.class, scanExpression);
                Log.d(TAG, "second result size " + res.size());
                return Observable.from(res);
            })
            .subscribe(new Subscriber<ProductDO>() {
                @Override
                public void onCompleted() {
                    favouriteProgressBar.setVisibility(View.INVISIBLE);
                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    favouriteProgressBar.setVisibility(View.INVISIBLE);
                }

                @Override
                public void onNext(ProductDO productDO) {
                    Log.d(TAG, "productId " + productDO.getProductId());
                    product.add(productDO);
                    adapter.notifyDataSetChanged();
                }
            });
}

private void getFavoriteList（）{
创建（（Observable.OnSubscribe）订户->{
final Map filterExpressionAttributeValues=new HashMap（）；
FilterExpressionAttribute值
.put（“：val1”，新的AttributeValue（）.with（sharedPreferences.getString（“socialId”），和“）；
最终DynamoDBScanExpression scanExpression=新的DynamoDBScanExpression（）
.withFilterExpression（“socialId=：val1”）
.带有表达式属性值（过滤器表达式属性值）；
PaginatedScanList结果=dynamoDBMapper.scan（UserDO.class，scanExpression）；
Log.d（标记，“第一个结果大小”+result.size（））；
subscriber.onNext（结果）；
subscriber.onCompleted（）；
})
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.filter（结果->{
if（result.isEmpty（））{
Toast.makeText（上下文“找不到用户”，Toast.LENGTH_SHORT.show（）；
返回false；
}
返回true；
})
.flatMap（用户->可观察的.from（用户.get（0.getFavorities（）））
.subscribeOn（Schedulers.io（））
.flatMap（结果->{
final Map filterExpressionAttributeValues=new HashMap（）；
FilterExpressionAttribute值
.put（“：val1”，新的AttributeValue（）.with（result））；
FilterExpressionAttribute值
.put（“：val2”，新的AttributeValue（）。带n（“1”）；
最终DynamoDBScanExpression scanExpression=新的DynamoDBScanExpression（）
.withFilterExpression（“productId=：val1和selling=：val2”）
.带有表达式属性值（过滤器表达式属性值）；
PaginatedScanList res=dynamoDBMapper.scan（ProductDO.class，scanExpression）；
Log.d（标记“第二个结果大小”+res.size（））；
可观察的回报率（res）；
})
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
FavoriteProgressBar.setVisibility（视图不可见）；
}
@凌驾
公共无效申报人（可丢弃的e）{
e、 printStackTrace（）；
FavoriteProgressBar.setVisibility（视图不可见）；
}
@凌驾
public void onNext（ProductDO-ProductDO）{
Log.d（标记“productId”+productDO.getProductId（））；
product.add（productDO）；
adapter.notifyDataSetChanged（）；
}
});
}
将您的
.observeOn（AndroidSchedulers.mainThread（））
移动到订阅之前

PS：除非没有其他选择，否则不应该使用
Observable.create（）

编辑以修复筛选器问题中的Toast

private void getFavouriteList(){
    Observable.create((Observable.OnSubscribe<PaginatedScanList<UserDO>>) subscriber -> {
        final Map<String, AttributeValue> filterExpressionAttributeValues = new HashMap<>();
        filterExpressionAttributeValues
                .put(":val1", new AttributeValue().withS(sharedPreferences.getString("socialId", "")));
        final DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
                .withFilterExpression("socialId = :val1")
                .withExpressionAttributeValues(filterExpressionAttributeValues);
        PaginatedScanList<UserDO> result = dynamoDBMapper.scan(UserDO.class, scanExpression);
        Log.d(TAG, "first result size " + result.size());
        subscriber.onNext(result);
        subscriber.onCompleted();
    })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .filter(result -> {
                if(result.isEmpty()) {
                    Toast.makeText(context, "Can not find user", Toast.LENGTH_SHORT).show();
                    return false;
                }
                return true;
            })
            .observeOn(Schedulers.io())
            .flatMap(user -> Observable.from(user.get(0).getFavourites()))
            .flatMap(result -> {
                final Map<String, AttributeValue> filterExpressionAttributeValues = new HashMap<>();
                filterExpressionAttributeValues
                        .put(":val1", new AttributeValue().withS(result));
                filterExpressionAttributeValues
                        .put(":val2", new AttributeValue().withN("1"));
                final DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
                        .withFilterExpression("productId = :val1 and selling = :val2")
                        .withExpressionAttributeValues(filterExpressionAttributeValues);
                PaginatedScanList<ProductDO> res = dynamoDBMapper.scan(ProductDO.class, scanExpression);
                Log.d(TAG, "second result size " + res.size());
                return Observable.from(res);
            })
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<ProductDO>() {
                @Override
                public void onCompleted() {
                    favouriteProgressBar.setVisibility(View.INVISIBLE);
                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    favouriteProgressBar.setVisibility(View.INVISIBLE);
                }

                @Override
                public void onNext(ProductDO productDO) {
                    Log.d(TAG, "productId " + productDO.getProductId());
                    product.add(productDO);
                    adapter.notifyDataSetChanged();
                }
            });
}

private void getFavoriteList（）{
创建（（Observable.OnSubscribe）订户->{
final Map filterExpressionAttributeValues=new HashMap（）；
FilterExpressionAttribute值
.put（“：val1”，新的AttributeValue（）.with（sharedPreferences.getString（“socialId”），和“）；
最终DynamoDBScanExpression scanExpression=新的DynamoDBScanExpression（）
.withFilterExpression（“socialId=：val1”）
.带有表达式属性值（过滤器表达式属性值）；
PaginatedScanList结果=dynamoDBMapper.scan（UserDO.class，scanExpression）；
Log.d（标记，“第一个结果大小”+result.size（））；
subscriber.onNext（结果）；
subscriber.onCompleted（）；
})
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.filter（结果->{
if（result.isEmpty（））{
Toast.makeText（上下文“找不到用户”，Toast.LENGTH_SHORT.show（）；
返回false；
}
返回true；
})
.observeOn（Schedulers.io（））
.flatMap（用户->可观察的.from（用户.get（0.getFavorities（）））
.flatMap（结果->{
final Map filterExpressionAttributeValues=new HashMap（）；
FilterExpressionAttribute值
.put（“：val1”，新的AttributeValue（）.with（result））；
FilterExpressionAttribute值
.put（“：val2”，新的AttributeValue（）。带n（“1”）；
最终DynamoDBScanExpression scanExpression=新的DynamoDBScanExpression（）
.withFilterExpression（“productId=：val1和selling=：val2”）
.带有表达式属性值（过滤器表达式属性值）；
PaginatedScanList res=dynamoDBMapper.scan（ProductDO.class，scanExpression）；
Log.d（标记“第二个结果大小”+res.size（））；
可观察的回报率（res）；
})
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新订阅）