如何在Javascript中像Promise这样的改造中完成所有异步操作？

我有一个应用程序，它通过改造来发出动态请求，我想检测是否所有的应用程序都完成了最佳实践，就像我知道如何在javascript中使用Promise一样

在今天的改型中，我这样做，我从对象接收一个数组，并根据数组的大小发出x请求

因此，当我启动函数时，我从数组中选择大小，每次我的改型进行调用时，我都会输入变量successCounter++和errorCounter++，当这两个变量的和等于我的数组大小时，这就是异步函数的结束

但我不知道这是否是一个好的实践，比如我的代码和平：

 String filePath = system.getMp_user_name() + "/categorias/" + mpCategory.getImg();
                            downloadImage("category", filePath, mpCategory.getImg(),
                                    new SynService.ApiImageCallback() {
                                        public void onResponse(Boolean success, Integer requestCounter, Integer errorRequestCounter){
                                            if(success){
                                                categoryImgSuccessCounter++;
                                                Log.d(TAG, "Imagem baixada e armazenada com sucesso");
                                                if(categoryImgSuccessCounter.equals(arrayCategorySize)) {
                                                    HashMap<String, String> responseObj = new HashMap<>();
                                                    responseObj.put("success", "1");
                                                    responseObj.put("message", "Sincronização Completada com Sucesso");
                                                    callback.onResponse(responseObj);
                                                }
                                            } else {
                                                categoryImgErrorCounter++;
                                                Log.d(TAG, "Não foi possível fazer o download da imagem");
                                                HashMap<String, String> responseObj = new HashMap<>();
                                                responseObj.put("success", "0");
                                                responseObj.put("message", "Houve um erro no download das imagens e o processo parou");
                                                callback.onResponse(responseObj);
                                            }
                                            Integer total = categoryImgSuccessCounter + categoryImgErrorCounter;
                                            if(total.equals(arrayCategorySize)) {
                                                categoryImgFinished = true;
                                            }
                                        }
                                    });

---

使用改型的

拦截器

拦截每个请求，并执行计数器递增/递减，并在此基础上共享回调

拦截器是一种强大的机制，可以监视、重写和重试调用

---

如果可以添加一个依赖项，那么添加

RxJava

，它有大量的运算符，这些运算符对于多线程和回调非常有用

要等待所有请求完成，请将

2

与

RxJava2

及其zip功能结合使用

Zip通过指定函数将多个观测值的发射组合在一起，并根据该函数的结果为每个组合发射单个项目

在构建您的

改装

实例时，添加

RxJava2CallAdapterFactory

作为调用适配器：

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build();

您的服务方法现在可以使用上述任何类型作为其返回类型

interface MyService {
  @GET("/user")
  Observable<User> getUser();
}


MyService retrofitApi = retrofit.create(MyService.class);

接口MyService{
@获取（“/user”）
可观察的getUser（）；
}
MyService-reformationapi=reformation.create（MyService.class）；

使用该服务创建请求集合并压缩这些请求

// You need to use `Observable` type for the response.
List<Observable<?>> requests = new ArrayList<>();

// Make a collection of all requests
requests.add(retrofitApi.getUser());
requests.add(retrofitApi.getUser());
requests.add(retrofitApi.getUser());

// Zip all requests with the Function, which will receive the results.
Observable.zip(
        requests,
        new Function<Object[], Object>() {
            @Override
            public Object apply(Object[] objects) throws Exception {
                // Objects[] is an array of combined results of completed requests

                // do something with those results and emit new event
                return new Object();
            }
        })
        // After all requests had been performed the next observer will receive the Object, returned from Function
        .subscribe(
                // Will be triggered if all requests will end successfully (4xx and 5xx also are successful requests too)
                new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        //Do something on successful completion of all requests
                    }
                },

                // Will be triggered if any error during requests will happen
                new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable e) throws Exception {
                        //Do something on error completion of requests
                    }
                }
        );

//响应需要使用'Observable'类型。
列表使用改装的
拦截器
拦截每个请求，并执行计数器递增/递减，并在此基础上共享回调

拦截器是一种强大的机制，可以监视、重写和重试调用



如果可以添加一个依赖项，那么添加
RxJava
，它有大量的运算符，这些运算符对于多线程和回调非常有用

要等待所有请求完成，请将
2
与
RxJava2
及其zip功能结合使用

Zip通过指定函数将多个观测值的发射组合在一起，并根据该函数的结果为每个组合发射单个项目

在构建您的
改装
实例时，添加
RxJava2CallAdapterFactory
作为调用适配器：

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build();

您的服务方法现在可以使用上述任何类型作为其返回类型

interface MyService {
  @GET("/user")
  Observable<User> getUser();
}


MyService retrofitApi = retrofit.create(MyService.class);

接口MyService{
@获取（“/user”）
可观察的getUser（）；
}
MyService-reformationapi=reformation.create（MyService.class）；

使用该服务创建请求集合并压缩这些请求

// You need to use `Observable` type for the response.
List<Observable<?>> requests = new ArrayList<>();

// Make a collection of all requests
requests.add(retrofitApi.getUser());
requests.add(retrofitApi.getUser());
requests.add(retrofitApi.getUser());

// Zip all requests with the Function, which will receive the results.
Observable.zip(
        requests,
        new Function<Object[], Object>() {
            @Override
            public Object apply(Object[] objects) throws Exception {
                // Objects[] is an array of combined results of completed requests

                // do something with those results and emit new event
                return new Object();
            }
        })
        // After all requests had been performed the next observer will receive the Object, returned from Function
        .subscribe(
                // Will be triggered if all requests will end successfully (4xx and 5xx also are successful requests too)
                new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        //Do something on successful completion of all requests
                    }
                },

                // Will be triggered if any error during requests will happen
                new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable e) throws Exception {
                        //Do something on error completion of requests
                    }
                }
        );

//响应需要使用'Observable'类型。
ListOMG，真的很感谢我不知道存在一个RxJava，但是你可以用一些示例代码来处理我的代码吗？OMG，真的感谢我不知道存在一个RxJava，但是你可以用一些示例代码来处理我的代码吗？