#AFNetworking源码阅读系列

图解各个模块

一 前言：

AFNetWorking一款轻量级网络请求开源框架，基于iOS和mac os 网络进行扩展的高性能框架，大大降低了iOS开发工程师处理网络请求的难度，让iOS开发变成一件愉快的事情。

   GitHub地址：https://github.com/AFNetworking/AFNetworking

二 模块 ：

AFNetWorking分为六大模块

1 ：AFURLSessionManager 首先浏览完这个类从API，发现其主要提供了数据的请求、上传和下载功能

在属性方面：tasks， dataTasks，uploadTasks，downloadTasks

通过这四个属性，我们分别可以拿到总的任务集合、数据任务集合、上传任务集合和下载任务集合

attemptsToRecreateUploadTasksForBackgroundSessions 在创建失败的时候，会重新尝试创建，次数默认为3次

实现文件：

网络请求是delegate返回结果

-(NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request

                               uploadProgress:(nullable void(^)(NSProgress *uploadProgress))uploadProgressBlock

                             downloadProgress:(nullable void(^)(NSProgress *downloadProgress))downloadProgressBlock

                            completionHandler:(nullable void(^)(NSURLResponse *response,id _Nullable responseObject,  NSError * _Nullable error))completionHandler {

__block NSURLSessionDataTask *dataTask = nil;

    url_session_manager_create_task_safely(^{

        dataTask =[self.session dataTaskWithRequest:request];

    });

//每个task里面都会调用addDelegate方法

    [self addDelegateForDataTask:dataTask uploadProgress:uploadProgressBlock downloadProgress:downloadProgressBlock completionHandler:completionHandler];

    return dataTask;

}

-(void)addDelegateForDataTask:(NSURLSessionDataTask *)dataTask

                uploadProgress:(nullable void(^)(NSProgress *uploadProgress))uploadProgressBlock

              downloadProgress:(nullable void(^)(NSProgress *downloadProgress))downloadProgressBlock

             completionHandler:(void(^)(NSURLResponse *response,id responseObject,NSError *error))completionHandler

{

    //初始化delegate对象

    AFURLSessionManagerTaskDelegate *delegate =[[AFURLSessionManagerTaskDelegate alloc]init];

    delegate.manager = self;

    //将task的completionHandler赋给delegate，系统网络请求delegate调用该block，返回结果

    delegate.completionHandler = completionHandler;

    dataTask.taskDescription = self.taskDescriptionForSessionTasks;

    //对task进行delegate

    [self setDelegate:delegate forTask:dataTask];

//设置上传和下载进度回调

    delegate.uploadProgressBlock = uploadProgressBlock;

    delegate.downloadProgressBlock = downloadProgressBlock;

}

delegate对象利用kvo将task对一些方法进行监听

// task使用kvo对一些方法监听，返回上传或者下载的进度

    [delegate setupProgressForTask:task];

    // sessionManager对暂停task和恢复task进行注册通知

    [self addNotificationObserverForTask:task];

// task对接收到的字节数、期望接收到的字节数、发送的字节数、期望发送的字节数设置监听

    [task addObserver:self

           forKeyPath:NSStringFromSelector(@selector(countOfBytesReceived))

              options:NSKeyValueObservingOptionNew

              context:NULL];

-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {

    if([object isKindOfClass:[NSURLSessionTask class]]||[object isKindOfClass:[NSURLSessionDownloadTask class]]){

        //设置上传和下载的新值

    }

    else if([object isEqual:self.downloadProgress]){

        if(self.downloadProgressBlock){

            self.downloadProgressBlock(object);

        }

    }

    else if([object isEqual:self.uploadProgress]){

        if(self.uploadProgressBlock){

            self.uploadProgressBlock(object);

        }

    }

}

在NSURLSessionTaskDelegate的代理里面，只是做了两件事情，第一个是获取数据，将responseSerializer和downloadFileURL或data存到userInfo里面，第二个是根据error是否为空值，做下一步处理

#pragma mark - NSURLSessionTaskDelegate

-(void)URLSession:(__unused NSURLSession *)session

              task:(NSURLSessionTask *)task

didCompleteWithError:(NSError *)error

{

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wgnu"

    //获取数据，将responseSerializer和downloadFileURL或data存到userInfo里面

    __strong AFURLSessionManager *manager = self.manager;

    __block id responseObject = nil;

    __block NSMutableDictionary *userInfo =[NSMutableDictionary dictionary];

    userInfo[AFNetworkingTaskDidCompleteResponseSerializerKey]= manager.responseSerializer;

    //Performance Improvement from #2672

    NSData *data = nil;

    if(self.mutableData){

        data =[self.mutableData copy];

        //We no longer need the reference,so nil it out to gain back some memory.

        self.mutableData = nil;

    }

    if(self.downloadFileURL){

        userInfo[AFNetworkingTaskDidCompleteAssetPathKey]= self.downloadFileURL;

    } else if(data){

        userInfo[AFNetworkingTaskDidCompleteResponseDataKey]= data;

    }

    if(error){

      //有error时处理

    } else {

      //无error时正常处理

    }

#pragma clang diagnostic pop

}

2：AFHTTPSessionManager

AFHTTPSessionManager继承于AFURLSessionManager，提供了更方便的HTTP请求方法，包括了GET、POST、PUT、PATCH、DELETE这五种方式，并且AF鼓励我们在AFHTTPSessionManager再进行一次封装来满足我们自己的业务需求

baseURL 在初始化的方法里面，我们看到这个方法

-(instancetype)initWithBaseURL:(nullable NSURL *)url;

-(instancetype)initWithBaseURL:(nullable NSURL *)url

           sessionConfiguration:(nullable NSURLSessionConfiguration *)configuration NS_DESIGNATED_INITIALIZER;

NS_DESIGNATED_INITIALIZER的作用是什么呢？

指定的构造器通过发送初始化消息到父类来保证object被完全初始化

-(nullable NSURLSessionDataTask *)GET:(NSString *)URLString

                   parameters:(nullable id)parameters

                      success:(nullable void(^)(NSURLSessionDataTask *task,id _Nullable responseObject))success

                      failure:(nullable void(^)(NSURLSessionDataTask * _Nullable task,NSError *error))failure DEPRECATED_ATTRIBUTE;

下面POST、GET、PUT、PATCH、DELETE方法传参基本都是大同小异

URLString表示请求的URL，parameters表示客户端请求内容的存储器，progress表示请求的进度，constructingBodyWithBlock里面只有一个formData用来拼接到HTTP的请求体，success表示请求成功后的block回调，failure表示请求失败的block回调

-(NSURLSessionDataTask *)dataTaskWithHTTPMethod:(NSString *)method

                                       URLString:(NSString *)URLString

                                      parameters:(id)parameters

                                  uploadProgress:(nullable void(^)(NSProgress *uploadProgress))uploadProgress

                                downloadProgress:(nullable void(^)(NSProgress *downloadProgress))downloadProgress

                                         success:(void(^)(NSURLSessionDataTask *,id))success

                                         failure:(void(^)(NSURLSessionDataTask *,NSError *))failure

{

    NSError *serializationError = nil;

    NSMutableURLRequest *request =[self.requestSerializer requestWithMethod:method URLString:[[NSURL URLWithString:URLString relativeToURL:self.baseURL]absoluteString]parameters:parameters error:&serializationError];

    if(serializationError){

        if(failure){

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wgnu"

            dispatch_async(self.completionQueue ?: dispatch_get_main_queue(),^{

                failure(nil,serializationError);

            });

#pragma clang diagnostic pop

        }

        return nil;

    }

    __block NSURLSessionDataTask *dataTask = nil;

    dataTask =[self dataTaskWithRequest:request

                          uploadProgress:uploadProgress

                        downloadProgress:downloadProgress

                       completionHandler:^(NSURLResponse * __unused response,id responseObject,NSError *error){

        //失败成功处理

    }];

    return dataTask;

}

3：NSAppTransportSecurity

AFSecurityPolicy主要的作用就是验证HTTPS请求的证书的有效性

AFSecurityPolicy是安全策略类，有三种SSL Pinning模式

typedef NS_ENUM(NSUInteger,AFSSLPinningMode){

    AFSSLPinningModeNone,//在证书列表中校验服务端返回的证书

    AFSSLPinningModePublicKey,//客户端要有服务端的证书拷贝，只是验证时只验证证书里的公钥

    AFSSLPinningModeCertificate,// 客户端要有服务端的证书拷贝，第一步先验证证书域名/有效期等信息，第二步对服务端返回的证书和客户端返回的是否一致

};

这个是证书集合，泛型里面表示了集合里面是NSData类型，表明这个是用来存证书数据的集合，这些证书根据SSL Pinning模式来和服务器进行校验，默认是没有证书的，我们需要调用+ certificatesInBundle:方法将bundle里面的证书文件转成里面是data类型的集合

第三种是需要我们多传入一个证书集合

+(instancetype)policyWithPinningMode:(AFSSLPinningMode)pinningMode withPinnedCertificates:(NSSet *)pinnedCertificates {

    AFSecurityPolicy *securityPolicy =[[self alloc]init];

    securityPolicy.SSLPinningMode = pinningMode;

    [securityPolicy setPinnedCertificates:pinnedCertificates];

    return securityPolicy;

}

设置证书的时候，就是把上面初始化时传入的证书取出公钥，再把公钥保存到mutablePinnedPublicKeys集合中

-(void)setPinnedCertificates:(NSSet *)pinnedCertificates {

    _pinnedCertificates = pinnedCertificates;

    if(self.pinnedCertificates){

        NSMutableSet *mutablePinnedPublicKeys =[NSMutableSet setWithCapacity:[self.pinnedCertificates count]];

        for(NSData *certificate in self.pinnedCertificates){

            //取出公钥

id publicKey = AFPublicKeyForCertificate(certificate);

            if(!publicKey){

                continue;

            }

            //将公钥存到集合

            [mutablePinnedPublicKeys addObject:publicKey];

        }

        self.pinnedPublicKeys =[NSSet setWithSet:mutablePinnedPublicKeys];

    } else {

        self.pinnedPublicKeys = nil;

    }

}

在AFPublicKeyForCertificate方法里面，做了一系列操作后返回公钥，如下：

-(void)setPinnedCertificates:(NSSet *)pinnedCertificates {

    _pinnedCertificates = pinnedCertificates;

    if(self.pinnedCertificates){

        NSMutableSet *mutablePinnedPublicKeys =[NSMutableSet setWithCapacity:[self.pinnedCertificates count]];

        for(NSData *certificate in self.pinnedCertificates){

            //取出公钥

id publicKey = AFPublicKeyForCertificate(certificate);

            if(!publicKey){

                continue;

            }

            //将公钥存到集合

            [mutablePinnedPublicKeys addObject:publicKey];

        }

        self.pinnedPublicKeys =[NSSet setWithSet:mutablePinnedPublicKeys];

    } else {

        self.pinnedPublicKeys = nil;

    }

}

4：AFNetworkReachabilityManager

是用来监测网络状态的类，可以通过设置状态改变回调来获得当前网络状态

网络的状态值有以下四种

typedef NS_ENUM(NSInteger,AFNetworkReachabilityStatus){

    AFNetworkReachabilityStatusUnknown          = -1,//未知

    AFNetworkReachabilityStatusNotReachable    = 0,//不可用

    AFNetworkReachabilityStatusReachableViaWWAN = 1,//无线广域网连接

    AFNetworkReachabilityStatusReachableViaWiFi = 2,// WiFi连接

};

AFNetworkReachabilityManager提供了五种初始化的方法  

如：+(instancetype)sharedManager {

    static AFNetworkReachabilityManager *_sharedManager = nil;

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken,^{

        //调用+ manager初始化方法

        _sharedManager =[self manager];

    });

    return _sharedManager;

}

开启监听 

-(void)startMonitoring {

    //停止监听

    [self stopMonitoring];

    if(!self.networkReachability){

        return;

    }

    //收到callback调用后，将status通过networkReachabilityStatusBlock回调出去

    __weak __typeof(self)weakSelf = self;

    AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status){

        __strong __typeof(weakSelf)strongSelf = weakSelf;

        strongSelf.networkReachabilityStatus = status;

        if(strongSelf.networkReachabilityStatusBlock){

            strongSelf.networkReachabilityStatusBlock(status);

        }

    };

//声明SCNetworkReachabilityContext结构体

    SCNetworkReachabilityContext context = {0,(__bridge void *)callback,AFNetworkReachabilityRetainCallback,AFNetworkReachabilityReleaseCallback,NULL};

    //设置回调

SCNetworkReachabilitySetCallback(self.networkReachability,AFNetworkReachabilityCallback,&context);

    //加到Main runloop里面对其进行监测

SCNetworkReachabilityScheduleWithRunLoop(self.networkReachability,CFRunLoopGetMain(),kCFRunLoopCommonModes);

//获取当前的网络状态，调用callback

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND,0),^{

        SCNetworkReachabilityFlags flags;

        if(SCNetworkReachabilityGetFlags(self.networkReachability,&flags)){

            AFPostReachabilityStatusChange(flags,callback);

        }

    });

}

如果没有设置回调的话，也可以通过注册通知的方式，收到网络状态的变化 

static void AFPostReachabilityStatusChange(SCNetworkReachabilityFlags flags,AFNetworkReachabilityStatusBlock block){

    //获取当前的status

AFNetworkReachabilityStatus status = AFNetworkReachabilityStatusForFlags(flags);

    dispatch_async(dispatch_get_main_queue(),^{

        //返回status值

if(block){

            block(status);

        }

//同时会发送一个通知

        NSNotificationCenter *notificationCenter =[NSNotificationCenter defaultCenter];

        NSDictionary *userInfo = @{ AFNetworkingReachabilityNotificationStatusItem: @(status)};

        [notificationCenter postNotificationName:AFNetworkingReachabilityDidChangeNotification object:nil userInfo:userInfo];

    });

}

5：AFURLRequestSerialization 

是用来对发出的请求进行一些处理

AFPercentEscapedStringFromString方法将string里面的:#[]@!$&’()*+,;=字符替换成% 

NSString * AFPercentEscapedStringFromString(NSString *string){

static NSString * const kAFCharactersGeneralDelimitersToEncode = @":#[]@";// does not include "?" or "/" due to RFC 3986 - Section 3.4

    static NSString * const kAFCharactersSubDelimitersToEncode = @"!$&'()*+,;=";

//从可用字符替换删除掉:#[]@!$&'()*+,;=这些字符

    NSMutableCharacterSet * allowedCharacterSet =[[NSCharacterSet URLQueryAllowedCharacterSet]mutableCopy];

    [allowedCharacterSet removeCharactersInString:[kAFCharactersGeneralDelimitersToEncode stringByAppendingString:kAFCharactersSubDelimitersToEncode]];

// FIXME: https://github.com/AFNetworking/AFNetworking/pull/3028

    // return[string stringByAddingPercentEncodingWithAllowedCharacters:allowedCharacterSet];

//声明批量处理的大小为50

    static NSUInteger const batchSize = 50;

    NSUInteger index = 0;

    NSMutableString *escaped = @"".mutableCopy;

//循环将string里面:#[]@!$&'()*+,;=的字符替换成%

    while(index < string.length){

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wgnu"

        NSUInteger length = MIN(string.length - index,batchSize);

#pragma GCC diagnostic pop

        NSRange range = NSMakeRange(index,length);

        // To avoid breaking up character sequences such as👴🏻👮🏽

        range =[string rangeOfComposedCharacterSequencesForRange:range];

        NSString *substring =[string substringWithRange:range];

        NSString *encoded =[substring stringByAddingPercentEncodingWithAllowedCharacters:allowedCharacterSet];

        [escaped appendString:encoded];

        index += range.length;

    }

return escaped;

}

在AFQueryStringPair类里面有个- URLEncodedStringValue方法，将请求里面的URL参数转成field=value形式 

-(NSString *)URLEncodedStringValue {

    if(!self.value ||[self.value isEqual:[NSNull null]]){

        return AFPercentEscapedStringFromString([self.field description]);

    } else {

        return[NSString stringWithFormat:@"%@=%@",AFPercentEscapedStringFromString([self.field description]),AFPercentEscapedStringFromString([self.value description])];

    }

}

字典里面是我们查询的key和value，我们通过将字典内容转成AFQueryStringPair对象，调用- URLEncodedStringValue方法，转成key=value，放到mutablePairs数组里，最后用&符拼接起来 

NSString * AFQueryStringFromParameters(NSDictionary *parameters){

    NSMutableArray *mutablePairs =[NSMutableArray array];

    for(AFQueryStringPair *pair in AFQueryStringPairsFromDictionary(parameters)){

        [mutablePairs addObject:[pair URLEncodedStringValue]];

    }

    return[mutablePairs componentsJoinedByString:@"&"];

}

NSArray * AFQueryStringPairsFromKeyAndValue(NSString *key,id value){

    NSMutableArray *mutableQueryStringComponents =[NSMutableArray array];

    NSSortDescriptor *sortDescriptor =[NSSortDescriptor sortDescriptorWithKey:@"description" ascending:YES selector:@selector(compare:)];

//如果是字典，遍历后返回key[nestedKey]=nestedValue

    if([value isKindOfClass:[NSDictionary class]]){

        NSDictionary *dictionary = value;

        // Sort dictionary keys to ensure consistent ordering in query string,which is important when deserializing potentially ambiguous sequences,such as an array of dictionaries

        for(id nestedKey in[dictionary.allKeys sortedArrayUsingDescriptors:@[sortDescriptor]]){

            id nestedValue = dictionary[nestedKey];

            if(nestedValue){

                [mutableQueryStringComponents addObjectsFromArray:AFQueryStringPairsFromKeyAndValue((key ?[NSString stringWithFormat:@"%@[%@]",key,nestedKey]: nestedKey),nestedValue)];

            }

        }

    } //如果是数组，遍历后返回key[]=nestedValue

else if([value isKindOfClass:[NSArray class]]){

        NSArray *array = value;

        for(id nestedValue in array){

            [mutableQueryStringComponents addObjectsFromArray:AFQueryStringPairsFromKeyAndValue([NSString stringWithFormat:@"%@[]",key],nestedValue)];

        }

    } //如果是集合，遍历后返回key=obj

else if([value isKindOfClass:[NSSet class]]){

        NSSet *set = value;

        for(id obj in[set sortedArrayUsingDescriptors:@[sortDescriptor]]){

            [mutableQueryStringComponents addObjectsFromArray:AFQueryStringPairsFromKeyAndValue(key,obj)];

        }

    } //其他返回key=value 

else {

        [mutableQueryStringComponents addObject:[[AFQueryStringPair alloc]initWithField:key value:value]];

    }

    return mutableQueryStringComponents;

}

我们使用AFHTTPRequestSerializer对HTTP请求的头部进行处理

首先调用+ serializer进行初始化，里面调用了自己init方法

init里面先将Accept-Language存到mutableHTTPRequestHeaders里

然后拼接User-Agent，格式为”%@/%@ (%@; iOS %@; Scale/%0.2f)”，里面需要5个参数，第一个参数先获取项目名，如果没有，就用BundleIdentifier，第二个参数先获取短版本号，如果没有就用版本号，第三个参数是当前设备的类型，第四个参数是当前设备的版本号，第五个参数是屏幕的比例 

然后设置属性的监听，这些属性在头文件里面都可以找到，实现文件里面也实现了set方法 

通过KVO判断是否是新值，如果是的话，就加到mutableObservedChangedKeyPaths里面 

设置验证字段 

初始化之后，需要调用 

-(NSMutableURLRequest *)requestWithMethod:(NSString *)method

                                 URLString:(NSString *)URLString

                                parameters:(id)parameters

                                     error:(NSError *__autoreleasing *)error

{

    //断言                                     

    NSParameterAssert(method);

    NSParameterAssert(URLString);

    NSURL *url =[NSURL URLWithString:URLString];

    NSParameterAssert(url);

//根据url初始化request

    NSMutableURLRequest *mutableRequest =[[NSMutableURLRequest alloc]initWithURL:url];

    //设置HTTP方法                                   

    mutableRequest.HTTPMethod = method;

//根据mutableObservedChangedKeyPaths存储的属性，设置到mutableRequest

    for(NSString *keyPath in AFHTTPRequestSerializerObservedKeyPaths()){

        if([self.mutableObservedChangedKeyPaths containsObject:keyPath]){

            [mutableRequest setValue:[self valueForKeyPath:keyPath]forKey:keyPath];

        }

    }

//调用-[requestBySerializingRequest:withParameters:error]方法

    mutableRequest =[[self requestBySerializingRequest:mutableRequest withParameters:parameters error:error]mutableCopy];

return mutableRequest;

}

6：AFURLResponseSerialization

是用来将返回的response处理成相应的格式，它通过协议对特定response的data进行解码

-(nullable id)responseObjectForResponse:(nullable NSURLResponse *)response

                           data:(nullable NSData *)data

                          error:(NSError * _Nullable __autoreleasing *)error NS_SWIFT_NOTHROW;

acceptableStatusCodes和acceptableContentTypes可以通过外部进行设置

@property(nonatomic,copy,nullable)NSIndexSet *acceptableStatusCodes;

@property(nonatomic,copy,nullable)NSSet *acceptableContentTypes;

然后可以调用- [validateResponse:data:error:]检查这个response是否包含可接受的状态码和可接受MIME类型来验证response的有效性，子类也可以增加特定域名检查，- [responseObjectForResponse:data:error]也是调用了这个方法，返回data 

-(id)responseObjectForResponse:(NSURLResponse *)response

                           data:(NSData *)data

                          error:(NSError *__autoreleasing *)error

{

    //调用-[validateResponse:data:error:]方法，返回data 

    [self validateResponse:(NSHTTPURLResponse *)response data:data error:error];

    return data;

}

-(BOOL)validateResponse:(NSHTTPURLResponse *)response

                    data:(NSData *)data

                   error:(NSError * __autoreleasing *)error

{

    //设置初始值

    BOOL responseIsValid = YES;

    NSError *validationError = nil;

    //检查这个response是否包含可接受的状态码和可接受MIME类型

    if(error && !responseIsValid){

        *error = validationError;

    }

    //返回response是否有效性

    return responseIsValid;

}

检查这个response是否包含可接受的状态码和可接受MIME类型 

//检查response是否为空，以及response是否是NSHTTPURLResponse类

    if(response &&[response isKindOfClass:[NSHTTPURLResponse class]]){

        // acceptableContentTypes不为空并且response的MIME类型不在可接受的范围里

        if(self.acceptableContentTypes && ![self.acceptableContentTypes containsObject:[response MIMEType]]){

            //包装错误信息

            if([data length]> 0 &&[response URL]){

                NSMutableDictionary *mutableUserInfo =[@{

                                                          NSLocalizedDescriptionKey:[NSString stringWithFormat:NSLocalizedStringFromTable(@"Request failed: unacceptable content-type: %@",@"AFNetworking",nil),[response MIMEType]],

                                                          NSURLErrorFailingURLErrorKey:[response URL],

                                                          AFNetworkingOperationFailingURLResponseErrorKey: response,

                                                        } mutableCopy];

                if(data){

                    mutableUserInfo[AFNetworkingOperationFailingURLResponseDataErrorKey]= data;

                }

                validationError = AFErrorWithUnderlyingError([NSError errorWithDomain:AFURLResponseSerializationErrorDomain code:NSURLErrorCannotDecodeContentData userInfo:mutableUserInfo],validationError);

            }

            responseIsValid = NO;

        }

        // acceptableStatusCodes不为空并且acceptableStatusCodes包含response的状态码，response的URL也存在

        if(self.acceptableStatusCodes && ![self.acceptableStatusCodes containsIndex:(NSUInteger)response.statusCode]&&[response URL]){

            //包装错误信息

            NSMutableDictionary *mutableUserInfo =[@{

                                               NSLocalizedDescriptionKey:[NSString stringWithFormat:NSLocalizedStringFromTable(@"Request failed: %@(%ld)",@"AFNetworking",nil),[NSHTTPURLResponse localizedStringForStatusCode:response.statusCode],(long)response.statusCode],

                                               NSURLErrorFailingURLErrorKey:[response URL],

                                               AFNetworkingOperationFailingURLResponseErrorKey: response,

                                       } mutableCopy];

            if(data){

                mutableUserInfo[AFNetworkingOperationFailingURLResponseDataErrorKey]= data;

            }

            validationError = AFErrorWithUnderlyingError([NSError errorWithDomain:AFURLResponseSerializationErrorDomain code:NSURLErrorBadServerResponse userInfo:mutableUserInfo],validationError);

            responseIsValid = NO;

        }

    }

AFImageResponseSerializer在验证response之后，会根据设置是否自动解压automaticallyInflatesResponseImage布尔值，来对imageData按图片比例返回UIImage对象 

如果用imageWithData转成UIImage对象后，由于网络图片PNG和JPG都是压缩格式，需要解压成bitmap后才能渲染到屏幕，这时会在主线程对图片进行解压操作，这是比较耗时的，可能还会对主线程造成阻塞，所以AF还提供了AFInflatedImageFromResponseWithDataAtScale方法，对PNG和JPG解压后，返回UIImage对象，这样避免了在主线程的解压操作，不会对主线程造成卡顿

static UIImage * AFInflatedImageFromResponseWithDataAtScale(NSHTTPURLResponse *response,NSData *data,CGFloat scale){

    if(!data ||[data length]== 0){

        return nil;

    }

//创建CGImageRef

    CGImageRef imageRef = NULL;

    //用data创建CGDataProviderRef

    CGDataProviderRef dataProvider = CGDataProviderCreateWithCFData((__bridge CFDataRef)data);

    if([response.MIMEType isEqualToString:@"image/png"]){

        imageRef = CGImageCreateWithPNGDataProvider(dataProvider,  NULL,true,kCGRenderingIntentDefault);

    } else if([response.MIMEType isEqualToString:@"image/jpeg"]){

        imageRef = CGImageCreateWithJPEGDataProvider(dataProvider,NULL,true,kCGRenderingIntentDefault);

        if(imageRef){

            CGColorSpaceRef imageColorSpace = CGImageGetColorSpace(imageRef);

            CGColorSpaceModel imageColorSpaceModel = CGColorSpaceGetModel(imageColorSpace);

            //如果色彩空间是CMKY，CGImageCreateWithJPEGDataProvider是不会进行处理的，也就是不进行解压，将调用AFImageWithDataAtScale返回image

            if(imageColorSpaceModel == kCGColorSpaceModelCMYK){

                CGImageRelease(imageRef);

                imageRef = NULL;

            }

        }

    }

    CGDataProviderRelease(dataProvider);

//不符合解压条件的，将调用AFImageWithDataAtScale返回image，但是这里如果符合解压条件的也会调用，以及下面会对超出大小的，直接返回image，这里我觉得应该统一对不符合条件的返回image，符合条件的就不需要调用AFImageWithDataAtScale

    UIImage *image = AFImageWithDataAtScale(data,scale);

    if(!imageRef){

        if(image.images || !image){

            return image;

        }

//这里调用CGImageCreateCopy，只会对图形本身结构进行拷贝，底层的数据是不会拷贝的

        imageRef = CGImageCreateCopy([image CGImage]);

        if(!imageRef){

            return nil;

        }

    }

//设置图片的宽和高和存储一个像素所需要用到的字节

    size_t width = CGImageGetWidth(imageRef);

    size_t height = CGImageGetHeight(imageRef);

    size_t bitsPerComponent = CGImageGetBitsPerComponent(imageRef);

//如果图片大小宽高乘积超过1024*1024或者bitsPerComponent大于8都不解压了，因为bitmap是一直存在UIImage对象里的，可能会把内存爆了

    if(width * height > 1024 * 1024 || bitsPerComponent > 8){

        CGImageRelease(imageRef);

        return image;

    }

    //画布参数

    size_t bytesPerRow = 0;

    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();

    CGColorSpaceModel colorSpaceModel = CGColorSpaceGetModel(colorSpace);

    CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);

    if(colorSpaceModel == kCGColorSpaceModelRGB){

        uint32_t alpha =(bitmapInfo & kCGBitmapAlphaInfoMask);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassign-enum"

        if(alpha == kCGImageAlphaNone){

            bitmapInfo &= ~kCGBitmapAlphaInfoMask;

            bitmapInfo |= kCGImageAlphaNoneSkipFirst;

        } else if(!(alpha == kCGImageAlphaNoneSkipFirst || alpha == kCGImageAlphaNoneSkipLast)){

            bitmapInfo &= ~kCGBitmapAlphaInfoMask;

            bitmapInfo |= kCGImageAlphaPremultipliedFirst;

        }

#pragma clang diagnostic pop

    }

//创建画布

    CGContextRef context = CGBitmapContextCreate(NULL,width,height,bitsPerComponent,bytesPerRow,colorSpace,bitmapInfo);

    CGColorSpaceRelease(colorSpace);

    if(!context){

        CGImageRelease(imageRef);

        return image;

    }

//在画布上画出图片

    CGContextDrawImage(context,CGRectMake(0.0f,0.0f,width,height),imageRef);

    //保存成CGImageRef

CGImageRef inflatedImageRef = CGBitmapContextCreateImage(context);

    CGContextRelease(context);

//再转成UIImage对象

    UIImage *inflatedImage =[[UIImage alloc]initWithCGImage:inflatedImageRef scale:scale orientation:image.imageOrientation];

    CGImageRelease(inflatedImageRef);

    CGImageRelease(imageRef);

    return inflatedImage;

}

AFCompoundResponseSerializer

-(id)responseObjectForResponse:(NSURLResponse *)response

                           data:(NSData *)data

                          error:(NSError *__autoreleasing *)error

{

    //遍历responseSerializers                   

    for(id serializer in self.responseSerializers){

        //如果serializer不是AFHTTPResponseSerializer类，则继续

if(![serializer isKindOfClass:[AFHTTPResponseSerializer class]]){

            continue;

        }

        NSError *serializerError = nil;

        //一层一层的调用自己的-[responseObjectForResponse:data:error:]，直到返回responseObject

        id responseObject =[serializer responseObjectForResponse:response data:data error:&serializerError];

        if(responseObject){

            if(error){

                *error = AFErrorWithUnderlyingError(serializerError,*error);

            }

            return responseObject;

        }

    }

    return[super responseObjectForResponse:response data:data error:error];

}