Question

我今天在开发Android应用程序时遇到了这种情况，我需要根据2个不同API的响应来渲染图形。我正在使用Volley，而我所做的是我进行了顺序网络呼叫，即我发出了第一个请求，并且在该请求的onResponse方法中我发出了第二个请求。然后我在第二次请求的onResponse方法中渲染视图（图表）。

现在我想优化这种情况。我想知道一种方法，我可以异步地进行这两个网络调用，我只在收到来自两个API的响应后呈现视图。所以，假设我有3种模块化方法 -

getDataFromServer1（从一个服务器获取数据的网络调用）
getDataFromServer2（从另一台服务器获取数据的网络调用）
loadView（根据从2个网络电话收到的数据呈现图表）

我该如何解决？有人可以对它有所了解吗？

Answer 1

版本1 - 使用外部库

这是一个完美的例子，其中RxAndroid很方便（或者更通用 - 任何支持事件驱动编程的框架）。

我们假设我们有以下域类，允许我们从Web服务中获取一些数据：

存储库类：

public class Repository {
    protected String name;

    public Repository(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

服务界面：

public interface GitService {
    List<Repository> fetchRepositories();
}

首次服务实施：

public class BitbucketService implements GitService {
    @Override
    public List<Repository> fetchRepositories() {
        // Time consuming / IO consuming task.
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // Swallow exception.
        }

        List<Repository> result = new ArrayList<>();
        result.add(new Repository("http://some-fancy-repository.com/"));
        return result;
    }
}

第二次服务实施：

public class GithubService implements GitService {
    @Override
    public List<Repository> fetchRepositories() {
        // Time consuming / IO consuming task.
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // Swallow exception.
        }

        List<Repository> result = new ArrayList<>();
        result.add(new Repository("http://some-fancier-repository.com/"));
        return result;
    }
}

有了上述内容，我们可以轻松创建一个observable（一个查看是否发生过某事的对象）来检查我们是否已成功从两个服务下载数据。这项责任有以下方法：

public Observable<List<Repository>> fetchRepositories() {
    // This is not the best place to instantiate services.
    GitService github = new GithubService();
    GitService bitbucket = new BitbucketService();

    return Observable.zip(
        Observable.create(subscriber -> {
            subscriber.onNext(github.fetchRepositories());
        }),
        Observable.create(subscriber -> {
            subscriber.onNext(bitbucket.fetchRepositories());
        }),
        (List<Repository> response1, List<Repository> response2) -> {
            List<Repository> result = new ArrayList<>();
            result.addAll(response1);
            result.addAll(response2);
            return result;
        }
    );
}

唯一要做的就是在某处执行任务（例如onCreate方法）：

@Override
protected void onCreate(Bundle savedInstanceState) {
    (...)

    AndroidObservable
        .bindActivity(this, fetchRepositories())
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(repos -> showRepositories(repos), error -> showErrors());
}

上面的代码是魔术发生的地方。这是：

定义了任务的上下文，
定义了创建异步线程的必要性，
定义了当硬作业结束时，应该在UI线程中处理结果，
定义了调用哪些方法来处理结果和错误。

上面，我在subscribe传递lambda调用以向用户显示结果/错误：

private void showRepositories(List<Repository> repositories) {
    // Show repositories in your fragment.
}

private void showErrors() {
    // Pops up some contextual information / help.
}

由于Android目前使用SDK 1.7，因此需要使用允许我们在符合1.7的代码中使用lambdas的库。就个人而言，我在这种情况下使用retrolambda。

如果你不喜欢lambdas，你总是有可能在必要时实施匿名课程。

这样我们就可以避免编写很多Android的样板代码。

版本2 - 没有外部库

如果您不想使用外部库，则可以使用AsyncTasks与Executor相同的方式实现类似。

我们将重复使用上述域类：Repository，GitService，GithubService和BitbucketService。

由于我们想要查看完成了多少任务，让我们在我们的活动中介绍一些计数器：

private AtomicInteger counter = new AtomicInteger(2);

我们将在异步任务中共享此对象。

接下来，我们必须自己实现一个任务，例如：

public class FetchRepositories extends AsyncTask<Void, Void, List<Repository>> {
    private AtomicInteger counter;
    private GitService service;

    public FetchRepositories(AtomicInteger counter, GitService service) {
        this.counter = counter;
        this.service = service;
    }

    @Override
    protected List<Repository> doInBackground(Void... params) {
        return service.fetchRepositories();
    }

    @Override
    protected void onPostExecute(List<Repository> repositories) {
        super.onPostExecute(repositories);

        int tasksLeft = this.counter.decrementAndGet();
        if(tasksLeft <= 0) {
            Intent intent = new Intent();
            intent.setAction(TASKS_FINISHED_ACTION);
            sendBroadcast(intent);
        }
    }
}

以下是发生的事情：

在构造函数中，我们注入了用于获取数据的共享计数器和服务，
在doInBackground方法中，我们已将控制委托给我们的专用服务
在onPostExecute方法中，我们已经测试了所有预期任务是否已完成，
经过艰苦的工作后 - 已经发送了一个广播活动。

接下来，我们必须接收潜在的广播，告知我们已完成的工作。在这种情况下，我们实施了广播接收器：

public class FetchBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d("onReceive", "All tasks has been finished.");
        // No need to test 
        // if intent.getAction().equals(TASKS_FINISHED_ACTION) {}
        // as we used filter.
    }
}

您必须更新视图，而不是记录消息。

提到常量TASKS_FINISHED_ACTION命名您的过滤器：

 private static final String TASKS_FINISHED_ACTION = "some.intent.filter.TASKS_FINISHED";

请记住初始化并注册接收器和过滤器 - 您的活动和清单。

的活动：

private BroadcastReceiver receiver = new FetchBroadcastReceiver();

@Override
protected void onResume() {
    super.onResume();

    IntentFilter filter = new IntentFilter();
    filter.addAction(TASKS_FINISHED_ACTION);

    registerReceiver(receiver, filter);
}

清单（应用程序内部标记）：

<receiver android:name=".TestActivity$FetchBroadcastReceiver"/>

我将接收器类作为public放在TestActivity中，所以看起来很奇怪。

在清单中，您还必须注册您的操作（内部活动意图过滤器）：

<action android:name="some.intent.filter.TASKS_FINISHED"/>

请务必使用onPause()方法取消注册您的接收器。

准备好活动后，您可以在某处执行任务（例如，在第一个示例中的onCreate方法中）：

if(Build.VERSION.SDK_INT > Build.VERSION_CODES.HONEYCOMB) {
    new FetchRepositories(counter, new GithubService())
        .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    new FetchRepositories(counter, new BitbucketService())
        .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} else {
    // Below Honeycomb there was no parallel tasks.
    new FetchRepositories(counter, new GithubService()).execute();
    new FetchRepositories(counter, new BitbucketService()).execute();
}

您可以注意到，并行任务仅在Honeycomb及更高版本上运行。在此版本的Android线程池之前最多可以容纳1个任务。

至少我们使用了一些依赖注入和策略模式。：）

Answer 2

@tommus解决方案是最好的方法。

如果你想使用简单或更少的代码方法，你可以使用布尔标志来确保两者都被执行并根据条件向前移动。

声明一个将用作标志的volatile布尔变量。

private volatile boolean flag = false;

标志在开始时将为false。现在，调用两个webservices。任何执行的服务都会将此标志设置为TRUE。

getDataFromServer1();
function void onCompleteServer1() {
    if(flag) {
       loadViews();
    } else {
       flag = true;
    }
}


getDataFromServer2();
onCompleteServer2Request() {
    if(flag) {
       loadViews();
    } else {
       flag = true;
    }
}

Answer 3

不完美但我希望这个逻辑适合你

 onDatafromServer1Fetched{
    flag1 = true;
    }
    onDataFromServer2Fetched{
    flag2=true;
    }

main(){
        boolean flag1  = false;
        boolean flag2 =false;

    getDataFromSerVer1();
    getDataFromServer2();
    while(!flag1 && !flag2){/**no code required here*/}
    loadView();
 }

Answer 4

如果两个请求具有相同的数据格式，并由同一容器保持。为什么不简单地检查容器的大小。

public class MainActivity extends AppCompatActivity {

private List<Data> myList = new ArrayList<>();
private boolean error; // if one request got error, another one need to konw,
//use to handle response size 0 or other error

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    GsonRequest request1 = new GsonRequest(params... , this.mClazz, null, new Response.Listener() {
        @Override
        public void onResponse(Object response) {
            boolean updateUI = false;
            if(myList.size()>0){ //or > the init size
                updateUI = true;
            }

            myList.addAll(response);

            if(updateUI){
                notifydatasetchange();
            }
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {

        }
    });
    GsonRequest request2 = new GsonRequest(params... , this.mClazz, null, new Response.Listener() {
        @Override
        public void onResponse(Object response) {
            boolean updateUI = false;
            if(myList.size()>0){ //or > the init size
                updateUI = true;
            }

            myList.addAll(response);

            if(updateUI){
                notifydatasetchange();
            }
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {

        }
    });
}

}

Android - 异步网络呼叫 - 响应相互依赖

4 个答案:

版本1 - 使用外部库

版本2 - 没有外部库