为什么使用并发组请求？
在实际开发中我们通常会遇到这样一种需求：某个页面加载时通过网络请求获得相应的数据，再做某些操作，有时候加载的内容需要通过好几个请求的数据组合而成，比如有两个请求A和B，我们通常为了省事，会将B请求放在A请求成功的回调中发起，在B的成功回调中将数据组合起来，这样做有明显的问题：
- 请求如果多了，需要写许多嵌套的请求
- 如果在除了最后一个请求前的某个请求失败了，就不会执行后面的请求，数据无法加载
- 请求变成同步的，这是最大的问题，在网络差的情况下，如果有n个请求，意味着用户要等待n倍于并发请求的时间才能看到内容
dispatch_group并发组
熟悉dispatch_group的同学可以直接跳过这一节。
同步请求这么low的方式当然是不可接受的，所以我们要并发这些请求，在所有请求都执行完成功回调后，再做加载内容或其他操作，考虑再三，选择用GCD的dispatch_group最方便。
A dispatch group is a mechanism for monitoring a set of blocks. Your application can monitor the blocks in the group synchronously or asynchronously depending on your needs. By extension, a group can be useful for synchronizing for code that depends on the completion of other tasks.
可以看出，dispatch_group专为监控block而生，并且苹果也建议当你的某个操作依赖于其他几个任务的完成时，可以使用dispatch_group。
dispatch_group通常有两种用法:
dispatch_group_async(<#dispatch_group_t group#>, <#dispatch_queue_t queue#>, <#^(void)block#>)
创建一个dispatch_group_t， 将并发的操作放在block中，在dispatch_group_notify(<#dispatch_group_t group#>, <#dispatch_queue_t queue#>, <#^(void)block#>)的block中执行多组block执行完毕后的操作，对于网络请求来说，在请求发出时他就算执行完毕了，也就是block中还有个block的情况下，并不会等待网络请求的回调，所以不满足我们的需求。
所以采用另一种用法：dispatch_group_enter(<#dispatch_group_t group#>)
dispatch_group_leave(<#dispatch_group_t group#>)
以下是dispatch_group_enter的官方文档解释：
Calling this function increments the current count of outstanding tasks in the group. Using this function (with dispatch_group_leave) allows your application to properly manage the task reference count if it explicitly adds and removes tasks from the group by a means other than using the dispatch_group_async function. A call to this function must be balanced with a call to dispatch_group_leave. You can use this function to associate a block with more than one group at the same time.
dispatch_group实际上有一个task reference count（任务计数器），enter时reference count +1，leave时reference count -1，enter和leave必须配合使用，有几次enter就要有几次leave，否则group会一直存在，dispatch_group_notify也不会触发。
当所有enter的block都leave后，会执行dispatch_group_notify的block，这种方式显然更加灵活。
我们当然可以在网络请求前enter，在执行完每个请求的成功或失败回调后leave，再在notify中执行内容加载。至此，并发网络组请求的问题就解决了，但还是有点小小不爽，每次发起组请求我都得创建group，写一堆的enter和leave，既麻烦也不利于请求的复用，很自然我们想到把他封装一下，最好能做到将一个网络请求加到组里，而不用修改原先的网络请求代码，就像这样：
[[NetworkTool sharedInstance] postForGroup:^{
[request1 success:^(id responseObject) {
} failure:^(NSError *error) {
}];
[request2 success:^(id responseObject) {
} failure:^(NSError *error) {
}];
} success:^{
// group success
} failure:^(NSArray *errorArray) {
// group failure
}];
组请求的封装
如果我想做到这种效果，肯定要到网络单例层去对底层请求做些修改，但我又不想改变现有的底层请求方法，所以我采用了method_exchangeImplementations(<#Method m1#>, <#Method m2#>)这个函数，基于现有的底层请求方法，实现一套组的请求方法。在发组请求时，替换掉原先的方法，在组请求都发送完毕后，再换回原先的方法。
但这里有一些可怕的坑要处理，因为使用方法替换是很危险的。
- 我做了替换后，正常的非组网络请求也会走替换后的方法，但我不需要他走替换后的方法。
- 假如我同时发起了多个组请求，组和组之间要如何区分，不同的组是不应该相互影响的。
一开始我考虑给请求一个mark，标记他是属于哪个group的，但这需要你已经把请求封装成了一个对象，如果你的项目和我的一样，发请求时只是执行一个方法，是不好给他加标记的。
在一阵头脑风暴后，我决定用队列来区分每个gorup。
具体做法就是创建group时，开启一个队列，给队列动态添加group属性，一个队列对应一个group。在队列中替换方法，发起组里的请求，再替换回原先的方法。这样在替换的方法里只需要拿到当前的队列，就可以拿到group，如果group是nil，说明是正常的非组请求，执行original method；如果group不是nil，根据group来enter和leave，这样每个group也能区分开。
创建group时，给group动态添加一个errorArray属性，用来记录组里请求的error，只要errorArray不为空，就会走组失败的block。
附上完整代码:
typedef void(^BlockAction)();
typedef void(^GroupResponseFailure)(NSArray * errorArray);
static char groupErrorKey;
static char queueGroupKey;
单例中用来替换底层网络请求的组请求方法
- (void)sendPOSTRequestInGroup:(NSString *)strURL withData:(NSDictionary *)data paramForm:(ParamForm)paramForm withTimeout:(NSTimeInterval)timeout showAlert:(BOOL)show success:(BlockResponse)success failure:(BlockResponseFailure)failure {
dispatch_group_t group = objc_getAssociatedObject([NSOperationQueue currentQueue], &queueGroupKey);
// 如果是非组请求
if (group == nil) {
// 执行original method
[self sendPOSTRequestInGroup:strURL withData:data paramForm:paramForm withTimeout:timeout showAlert:show success:success failure:failure];
return;
}
dispatch_group_enter(group);
// 执行original method
[self sendPOSTRequestInGroup:strURL withData:data paramForm:paramForm withTimeout:timeout showAlert:show success:^(id responseObject) {
if (success) {
success(responseObject);
}
dispatch_group_leave(group);
} failure:^(NSError *error) {
NSMutableArray *arrayM = objc_getAssociatedObject(group, &groupErrorKey);
[arrayM addObject:error];
if (failure) {
failure(error);
}
dispatch_group_leave(group);
}];
}
提供给外界的组请求方法
- (void)sendGroupPostRequest:(BlockAction)requests success:(BlockAction)success failure:(GroupResponseFailure)failure {
if (requests == nil) {
return;
}
dispatch_group_t group = dispatch_group_create();
objc_setAssociatedObject(group, &groupErrorKey, [NSMutableArray array], OBJC_ASSOCIATION_RETAIN_NONATOMIC);
Method originalPost = class_getInstanceMethod(self.class, @selector(sendPOSTRequest:withData:paramForm:withTimeout:showAlert:success:failure:));
Method groupPost = class_getInstanceMethod(self.class, @selector(sendPOSTRequestInGroup:withData:paramForm:withTimeout:showAlert:success:failure:));
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
objc_setAssociatedObject(queue, &queueGroupKey, group, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
queue.qualityOfService = NSQualityOfServiceUserInitiated;
queue.maxConcurrentOperationCount = 3;
[queue addOperationWithBlock:^{
method_exchangeImplementations(originalPost, groupPost);
// 现在发起请求会调用上面的组请求方法
requests();
// 发出请求后就可以替换回original method，不必等待回调，尽量减小替换的时间窗口
method_exchangeImplementations(originalPost, groupPost);
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSMutableArray *arrayM = objc_getAssociatedObject(group, &groupErrorKey);
// 只要组里的一个请求失败，就走组失败的回调
if (arrayM.count > 0) {
if (failure) {
failure(arrayM.copy);
}
} else if(success) {
success();
}
});
}];
}
经过这一番封装，我在使用时，只需要在- (void)sendGroupPostRequest:(BlockAction)requests success:(BlockAction)success failure:(GroupResponseFailure)failure 这个方法的requests block中，把网络请求扔进去，原先写好的请求不用做任何修改，请求本身的success和failure也都能执行，success block中写组成功后要做的事情，比如内容加载，failure block中可以拿到每个请求的error，作相应处理。
