ios - 利用afnetworking3.0通过for循环发送请求,如何保证接收到数据的顺序和发送请求的顺序一致?

Question

利用AFN3.0进行网络请求,要发送的参数在一个数组里,每次取数组中的一条数据设置参数发送请求,

我通过for循环遍历数组并设置参数发送请求,将网络请求返回的数据添加到一个新的数组中,

发现不是每次请求返回的数据的顺序是一样的,功能需求返回数据的排序必须跟发送请求的顺序是一样的,

求问有什么方法保证前一次请求返回数据之后再发送下一次请求?

非常感谢,万分感谢!!!!

/**
 *  加载订单数据,设置控件位置
 */
- (void)loadOrderData {
        NSString *userID = [[NSUserDefaults standardUserDefaults] stringForKey:@"GOId"];
        NSDictionary *dict = @{
                               @"GOId" : userID,
                               };
        // 将字典转为json
        NSDictionary *params = [ELHOCToJson ocToJson:dict];
        
        NSString *URL = [NSString stringWithFormat:@"%@RealtimeOrder_getROListCon12345.action", ELHBaseURL];
        
        
        __weak typeof(self) weakSelf = self;
        [self.manager POST:URL parameters:params progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id  _Nullable responseObject) {
            
            weakSelf.ELHOrderArray = [ELHOrderModel mj_objectArrayWithKeyValuesArray:responseObject];
            

            
            // 获取订单编号
            for (int i = 0; i < weakSelf.ELHOrderArray.count; i++) {
                ELHOrderModel *model = weakSelf.ELHOrderArray[i];
                
                [weakSelf.ELHOrderNumArray addObject:model.ROBM];
                
            }
            

            // 根据获取到的订单编号加载订单详情列表
            if (weakSelf.ELHOrderNumArray != nil) {
                dispatch_queue_t conCurrentQueue = dispatch_queue_create("order", NULL);
                for (NSString *ROBM in weakSelf.ELHOrderNumArray) {
                    dispatch_barrier_async(conCurrentQueue, ^{
                        // 加载订单详情列表
                        [self loadOrderDetailData:ROBM];
                    });
                }
            }
            
            
       
            
            // 刷新数据
            [orderVC.tableView reloadData];
            
        } failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
            NSLog(@"%@", error);
        }];
    
}



/**
 *   加载订单详情列表
 */
- (void)loadOrderDetailData:(NSString *)ROBM {
    NSDictionary *dict = @{
                           @"ROBM" : ROBM,
                           };
    
    // 字典转json
    NSDictionary *params = [ELHOCToJson ocToJson:dict];
    
    NSString *URL = [NSString stringWithFormat:@"%@OrderPrice_getOPListByROBM.action", ELHBaseURL];
    
    __weak typeof(self) weakSelf = self;
    [self.manager POST:URL parameters:params progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id  _Nullable responseObject) {       
    
        // 将获取到的订单详情数据逐个添加到数组中
        [weakSelf.ELHOrderDetailArray addObject:[ELHOrderDetailModel mj_objectArrayWithKeyValuesArray:responseObject]];
        ELHOrderTableViewController *orderVC = weakSelf.childViewControllers.firstObject;
        
        orderVC.orderDetailArray = weakSelf.ELHOrderDetailArray;
        
        // 刷新数据
        [orderVC.tableView reloadData];
    } failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
        NSLog(@"%@", error);
    }];
}

Answer 1

Bien sûr, cela peut ne pas être pareil selon votre approche. Certaines demandes peuvent être émises plus tard, mais le retour est plus rapide, elles sont donc renvoyées en premier.

Je ne sais pas si vos besoins doivent être demandés dans l'ordre . Par exemple, si nous téléchargeons 10 images à la fois et que nous insérons ensuite les URL renvoyées dans un tableau dans l'ordre, nous les demandons généralement dans plusieurs fils de discussion en même temps au lieu de les transmettre une par une. C'est beaucoup plus rapide.

Si vous souhaitez vous assurer que les demandes sont faites dans l'ordre, vous devez envoyer la demande suivante après la fin de la demande précédente. Par exemple :

- (void)requestWithArray:(NSArray*)array index:(NSInteger)index completion:(SomeBlock)completion {
    if (index >= array.count) {
        if (completion) {
            completion();
        }
        return;
    }
    
    AFHTTPRequestOperationManager* manager = [self httpsRequestManager];
    NSDictionary* params = @{"key":array[index]};
    __weak typeof(self) weakSelf = self;
    [manager GET:url parameters:params success:^(AFHTTPRequestOperation *operation, id responseObject) {
        [weakSelf requestWithArray:array index:index + 1 completion:completion];
    } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
        // handle failure
    }];

C’est probablement ce que ça veut dire, tu comprends ?

Mais pour télécharger 10 photos, tant que l'ordre des résultats est assuré et qu'il n'est pas nécessaire de demander la sérialisation une par une, [AFURLConnectionOperation batchOfRequestOperations:] doit être utilisé. Il est préférable de déterminer si cela répond à vos besoins.

Answer 2

Votre question est similaire à celle-ci https://segmentfault.com/q/1010000004632... Si vous souhaitez simplement vous assurer de l'ordre des résultats renvoyés, vous n'avez pas nécessairement besoin que toutes les requêtes soient effectuées en série.

De plus, si vous devez faire des requêtes en série, vous pouvez créer une nouvelle NSOperationQueue, définir son maxConcurrentOperationCount sur 1, puis ajouter chacune de vos requêtes à cette NSOperationQueue de manière séquentielle.

Answer 3

Vous pouvez utiliser GCD dispatch_barrier_async, mais la file d'attente doit être créée par vous-même, pas la file d'attente globale

dispatch_queue_t conCurrentQueue = dispatch_queue_create("test", NULL);
NSArray *numAry = @[@"1",@"3",@"4",@"2",];

for (NSString *str in numAry) {
    
        dispatch_barrier_async(conCurrentQueue, ^{
            
            //这里写网络请求
        });
}

Answer 4

J'ai écrit un nouveau cours auxiliaire, j'espère qu'il pourra vous aider.
https://github.com/sunbohong/SunOrderArr...