AFNetworking 3.0 源码解读（三）之 AFURLRequestSerialization

这篇就讲到了跟请求相关的类了

关于AFNetworking 3.0 源码解读 的文章篇幅都会很长，因为不仅仅要把代码进行详细的的解释，还会大概讲解和代码相关的知识点。

上半篇： URI编码的知识

关于什么叫URI编码和为什么要编码，请看我转载的这篇文章 url 编码（percentcode 百分号编码）

给定一个URL：http://www.imkevinyang.com/2009/08/%E8%AF%A6%E8%A7%A3javascript%E4%B8%AD%E7%9A%84url%E7%BC%96%E8%A7%A3%E7%A0%81.html

其实这个URL并不算复杂，查询部分(query)都是简单的key：NSString value: NSString 还有一些比这个更复杂的例子。

我们现在这埋个伏笔：假如你的请求参数是这样的，那么编码后的URL是什么样呢？ 不用着急，后边会做出详细解答。

根据RFC 3986的规定：URL百分比编码的保留字段分为：

1.   ':'  '#'  '['  ']'  '@'  '?'  '/'

2.   '!'  '$'  '&'  '''  '('  ')'  '*'  '+'  ','  ';' '='

在对查询字段百分比编码时，'?'和'/'可以不用编码，其他的都要进行编码。

这个方法是上边的那个方法的实现部分。

这里值得注意的是：

1. 字符串需要经过过滤 ，过滤法则通过 NSMutableCharacterSet 实现。添加规则后，只对规则内的因子进行编码。

2. 为了处理类似emoji这样的字符串，rangeOfComposedCharacterSequencesForRange 使用了while循环来处理，也就是把字符串按照batchSize分割处理完再拼回。

该方法最终把类型为NSDictionary的参数处理为字符串类型。

举个简单的没进行百分百编码的例子：

如果参数是NSDictionary *info = @{@"name":@"zhangsan",@"age":20} ;

AFQueryStringFromParameters(info)  的结果就是：name=zhangsan&age=20 (没有百分比编码)

上边的AFQueryStringFromParameters 这个方法的实现部分还是有点复杂的。我们先逐步分析一下。

可以看出最终转化后的结果肯定有一个=号，这个等号左边和右边都有一个数据。而且这个数据是字符串，因此我们定义一个模型用来记录左边和右边的数据。

有名字就可得知这个类 代表一个查询字符串对。field代表=号左边的，value代表=号右边的数据。

核心方法URLEncodedStringValue 可定也是把左右的数据使用AFPercentEscapedStringFromString函数百分比编码后用=拼接起来。

看到那两个方法的声明了吗？我们不看下边的代码也应该能猜到这个核心方法的实现肯定借助了这两个被声明的方法。当然也可以调整函数的顺序，没有这么做也是为了可读性的考虑吧。

看这个方法的实现，由一个字符串数组根据连接符&拼接成一个字符串并返回。

这行代码也说明上边声明的AFQueryStringPairsFromDictionary函数接受一个字典参数，最终返回一个装着AFQueryStringPair模型的数组。便利数组后取出模型，然后转换成字符串，保存到新的数组中。

接下来在看看AFQueryStringPairsFromDictionary 这个函数的实现部分。

可以看出，这个函数又借助了另外一个函数AFQueryStringPairsFromKeyAndValue

其实到了这里，有一个疑问，感觉AFQueryStringPairsFromDictionary这个函数有点多余，这两个函数差不多啊，能不能使用一个呢？

其实也是可以的，这里这么写我猜应该也是出于函数编程的想法吧。更容易理解为根据一个字典得到一个数组，当然还有就是参数的限制，这里只能接受字典，下边的方法的value是id类型。（如有错误，请留言指正，谢谢）

改成这样也行：

好了，在来看看下班的函数

 // 把 key value 数据转换成数组
 NSArray * AFQueryStringPairsFromKeyAndValue(NSString *key, id value) {
     NSMutableArray *mutableQueryStringComponents = [NSMutableArray array];

     //排序： 升序
     NSSortDescriptor *sortDescriptor = [NSSortDescriptor sortDescriptorWithKey:@"description" ascending:YES selector:@selector(compare:)];

     // 如果参数的value 是字典数据
     /*
       举个例子：
       key: info
      value: @{@"name":@"zhangsan",@"age": @"30"}
      */
     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)];
             }
         }
     } else if ([value isKindOfClass:[NSArray class]]) {
         NSArray *array = value;
         for (id nestedValue in array) {
             [mutableQueryStringComponents addObjectsFromArray:AFQueryStringPairsFromKeyAndValue([NSString stringWithFormat:@"%@[]", key], nestedValue)];
         }
     } else if ([value isKindOfClass:[NSSet class]]) {
         NSSet *set = value;
         for (id obj in [set sortedArrayUsingDescriptors:@[ sortDescriptor ]]) {
             [mutableQueryStringComponents addObjectsFromArray:AFQueryStringPairsFromKeyAndValue(key, obj)];
         }
     } else {
         [mutableQueryStringComponents addObject:[[AFQueryStringPair alloc] initWithField:key value:value]];
     }

     return mutableQueryStringComponents;
 }

这里值得注意的有两点：

1. 函数迭代的一种思想 ，当value时NSDictionary/NSArray/NSSet 这种集合类型的时候，通过调用自身这种思想来实现功能，这个很重要，在很多地方能够用到，

看看YYModel 源码解读（二）之NSObject+YYModel.h (4)就知道了。

2. 就是为什么排序呢？这个不是很懂，如果有懂得，可以留言。

===============================  分割线 ============================

介绍了URI编码的一些知识，我们继续看源码，但是，往下看，就感觉有点乱了，1000多行的带码中有好几个小类，要是按照顺序一点点看，难免让人烦躁，难度也不小。

因此，我决定对它进行拆分，分成好几部分进行介绍，然后再串联起来。

那就先从HTTPBody开始说起。大家在使用AFNetworking上传图片或者其他文件的时候会用到AFMultipartFormData这个协议，然后调用协议内的方法，拼接数据，这个使用起来非常简单，但是它内部又是如何实现的呢？接下来就对他进行解析。

我们先来看一个完整的post请求：

某app的一个登录POST请求：

POST / HTTP/1.1
Host: log.nuomi.com
Content-Type: multipart/form-data; boundary=Boundary+6D3E56AA6EAA83B7
Cookie: access_log=7bde65268e2260bb0a85c7de2c67c468; BAIDUID=428D86FDBA6028DE2A5496BE3E7FC308:FG=; BAINUOCUID=4368e1b7499c455dcd437da336ca1ca9feb8f57d; BDUSS=Ecwa3NvN1NjNWhsVGxWZktFfkc2bzJxQjZ3RFJpTFBiUzZqZUJZU0ZTSmZsN0ZXQVFBQUFBJCQAAAAAAAAAAAEAAABxbLRYWXV1dXV3dXV1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF8KilZfCopWR; bn_na_copid=60139b4b2ba75706fc384d987c2e4007; bn_na_ctag=W3siayI6Imljb25fMSIsInMiOiJ0dWFuIiwidiI6IjMyNiIsInQiOiIxNDUxODg2OTE0In1d; channel=user_center%7C%7C; channel_content=; channel_webapp=webapp; condition=6.0.; domainUrl=sh; na_qab=6be39bfce918bb7b51887412e009faa6; UID=
Connection: keep-alive
Accept: */*
User-Agent: Bainuo/6.1.0 (iPhone; iOS 9.0; Scale/2.00)
Accept-Language: zh-Hans-CN;q=1, en-CN;q=0.9
Content-Length: 22207
Accept-Encoding: gzip, deflate

--Boundary+6D3E56AA6EAA83B7 /// 开始
Content-Disposition: form-data; name="app_version"

6.1.0
--Boundary+6D3E56AA6EAA83B7

HTTP请求头我们就暂时不说了，看这个body的内容

--Boundary+6D3E56AA6EAA83B7 /// 开始
Content-Disposition: form-data; name="app_version"

6.1.
--Boundary+6D3E56AA6EAA83B7

组成分为4个部分： 1.初始边界 2.body头 3.body 4.结束边界。 下边就会用着这些知识。

我把AFMultipartFormData协议提供的方法总结成了一张图？

当然这几个方法在下边都会有介绍。我们还是介绍body部分。

看着个body类的声明就能够知道body包含的所有信息，这些信息也和例子中的body的4大组成部分息息相关。

对AFHTTPBodyPart的扩展部分，可以看出曾加了三个属性：

1. phase：使用枚举包装body4大组成部分

2. 输入流

3. 每个组成部分的位置

增加了两个方法：

- (BOOL)transitionToNextPhase;    转移到下一个阶段

- (NSInteger)readData:(NSData *)data

intoBuffer:(uint8_t *)buffer

maxLength:(NSUInteger)length;          读取数据

实现部分呢，这个就没什么好解释的了，我们看看transitionToNextPhase这个函数的实现部分。

这个就是把这几个阶段，依次往后传递，值得注意的是在第②个阶段打开了流，第③个阶段关闭了流。

body可能有好几种类型，根据不同的类型返回不同方法创建的NSInputStream 。

这个方法是根据headers字典来拼接body头，看个例子：

Content-Disposition: form-data; name="record"; filename="record.jpg"
Content-Type: application/json

规则：Content-Disposition + : + 空格 + 其他 然后以\r\n结尾，在头部结束部分再拼接一个\r\n

这个比较好理解了，HTTP协议就是这么用的，在这个例子中self.headers 的值为：

{
    "Content-Disposition" = "form-data; name=\"record\"; filename=\"record.jpg\"";
    "Content-Type" = "application/json";
}

这个方法用来获取body的大小的。方法实现比较简单，需要注意的是初始和结束边界的问题，要做个判断，然后调用函数转换为NSData，计算大小

该方法返回是否还有数据可读。

 - (NSInteger)read:(uint8_t *)buffer
         maxLength:(NSUInteger)length
 {
     NSInteger totalNumberOfBytesRead = ;

     if (_phase == AFEncapsulationBoundaryPhase) {
         NSData *encapsulationBoundaryData = [([self hasInitialBoundary] ? AFMultipartFormInitialBoundary(self.boundary) : AFMultipartFormEncapsulationBoundary(self.boundary)) dataUsingEncoding:self.stringEncoding];
         totalNumberOfBytesRead += [self readData:encapsulationBoundaryData intoBuffer:&buffer[totalNumberOfBytesRead] maxLength:(length - (NSUInteger)totalNumberOfBytesRead)];
     }

     if (_phase == AFHeaderPhase) {
         NSData *headersData = [[self stringForHeaders] dataUsingEncoding:self.stringEncoding];
         totalNumberOfBytesRead += [self readData:headersData intoBuffer:&buffer[totalNumberOfBytesRead] maxLength:(length - (NSUInteger)totalNumberOfBytesRead)];
     }

     if (_phase == AFBodyPhase) {
         NSInteger numberOfBytesRead = ;

         numberOfBytesRead = [self.inputStream read:&buffer[totalNumberOfBytesRead] maxLength:(length - (NSUInteger)totalNumberOfBytesRead)];
         if (numberOfBytesRead == -) {
             return -;
         } else {
             totalNumberOfBytesRead += numberOfBytesRead;

             if ([self.inputStream streamStatus] >= NSStreamStatusAtEnd) {
                 [self transitionToNextPhase];
             }
         }
     }

     if (_phase == AFFinalBoundaryPhase) {
         NSData *closingBoundaryData = ([self hasFinalBoundary] ? [AFMultipartFormFinalBoundary(self.boundary) dataUsingEncoding:self.stringEncoding] : [NSData data]);
         totalNumberOfBytesRead += [self readData:closingBoundaryData intoBuffer:&buffer[totalNumberOfBytesRead] maxLength:(length - (NSUInteger)totalNumberOfBytesRead)];
     }

     return totalNumberOfBytesRead;
 }

 - (NSInteger)readData:(NSData *)data
            intoBuffer:(uint8_t *)buffer
             maxLength:(NSUInteger)length
 {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu"
     // 比较数据和允许的最大长度 选取比较小的那个
     NSRange range = NSMakeRange((NSUInteger)_phaseReadOffset, MIN([data length] - ((NSUInteger)_phaseReadOffset), length));

     // copy data中range的数据到buffer
     [data getBytes:buffer range:range];
 #pragma clang diagnostic pop

     _phaseReadOffset += range.length;

     if (((NSUInteger)_phaseReadOffset) >= [data length]) {
         [self transitionToNextPhase];
     }

     return (NSInteger)range.length;
 }

这两个方法是把body数据写入到buffer中。通过观察着这两个方法，可得知，这两个方法肯定在其他的代码中的某个循环中被调用，目的是得到想要的数据格式。

举个正常点的例子吧：

假如说初始的边界的大小为10 头部为20 主体为30 结束边界为10  最大长度为100

在

- (NSInteger)readData:(NSData *)data
           intoBuffer:(uint8_t *)buffer
            maxLength:(NSUInteger)length

内部大概是这样的：

_phaseReadOffset == 0   -》  range == (0,10)   -》  buffer[0-10] == data(10)   -》 _phaseReadOffset == 10

由于_phaseReadOffset == 10   >= 10    -》  [self transitionToNextPhase]; 进入下一个阶段。

由于这个小类遵守NSCopying协议，加了下边方法。

============================= 分割线 ==============================

在这里补充一点。对于NSInputStream的使用来说，我们要手动实现方法

- (NSInteger)read:(uint8_t *)buffer
        maxLength:(NSUInteger)length;

这样当我们使用open打开流的时候，就会调用这个方法，我们需要在这个方法中处理我们的逻辑。

这也是上边中为什么能完整的读取body中的数据的解释。

还有这个maxLength和buffer有关系，uint8_t在mac 64为上为32768.

============================= 分割线 ===========================

下边介绍 AFMultipartBodyStream

其实AFHTTPBodyPart就像是一个个具体的数据一样，而AFMultipartBodyStream更像是一个管道，和body相连，数据从body沿着管道流入request中去。

这层抽象的概念还是蛮重要的。再设计之初，这两个抽象类就应该各自完成各自的任务，即使body中也有stream 但那也只属于body自身的业务。

它是继承自NSInputStream的，那么为什么要继承自这个呢？ 就要看下边的这个方法了。

由此可以看出，数据最终是通过setHTTPBodySteam方法传递给Request的。是一个NSInputStream类型，因此AFMultipartBodyStream 继承自NSInputStream。

这个是又增加了一些需要的属性，这个会在下边的方法中介绍到，在这里就先略过。

初始化一些属性。

重置初始边界和结束边界，当有多个body的时候，只需要拼接一个头部边界和一个结束边界就可以了。

 - (NSInteger)read:(uint8_t *)buffer
         maxLength:(NSUInteger)length
 {

     NSLog(@"length:%ld",(long)length);
     if ([self streamStatus] == NSStreamStatusClosed) {
         return ;
     }

     NSInteger totalNumberOfBytesRead = ;

 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu"
     // 遍历读取数据
     while ((NSUInteger)totalNumberOfBytesRead < MIN(length, self.numberOfBytesInPacket)) {
         // 如果当前读取的body不存在或者body没有可读字节
         if (!self.currentHTTPBodyPart || ![self.currentHTTPBodyPart hasBytesAvailable]) {
             //把下一个body赋值给当前的body 如果下一个为nil 就退出循环
             if (!(self.currentHTTPBodyPart = [self.HTTPBodyPartEnumerator nextObject])) {
                 break;
             }
         } else { // 当前body存在

             // 剩余可读文件的大小
             NSUInteger maxLength = MIN(length, self.numberOfBytesInPacket) - (NSUInteger)totalNumberOfBytesRead;
              NSLog(@"maxLength:%ld",(long)maxLength);
             // 把当前的body的数据读入到buffer中
             NSInteger numberOfBytesRead = [self.currentHTTPBodyPart read:&buffer[totalNumberOfBytesRead] maxLength:maxLength];
 //            NSInteger numberOfBytesRead = 0;
             NSLog(@"numberOfBytesRead:%ld",(long)maxLength);
             if (numberOfBytesRead == -) {
                 self.streamError = self.currentHTTPBodyPart.inputStream.streamError;
                 break;
             } else {

                 //
                 totalNumberOfBytesRead += numberOfBytesRead;

                 if (self.delay > 0.0f) {
                     [NSThread sleepForTimeInterval:self.delay];
                 }
             }
         }
     }
 #pragma clang diagnostic pop

     return totalNumberOfBytesRead;
 }

这个方法是AFMultipartBodyStream通过body读取数据的核心方法。下面通过举一个例子来看看这个方法究竟是怎么工作的？

1. 假如我们上传一张图片img.png 他的大小为80000，也就是差不多80k吧。

2. 通过AFMultipartBodyStream读取数据，会首先调用上边的方法。读取数据并不是一次性读取的，而是分批分次读取的，这这个方法中，每次读取的大小为32k，也就是32*1024 = 32768的大小。

3. 第一次调用后self.currentHTTPBodyPart 指向我们的img.png 通过

NSInteger numberOfBytesRead = [self.currentHTTPBodyPart read:&buffer[totalNumberOfBytesRead] maxLength:maxLength]; 方法在body中读取了32768大小的数据保存到了缓存buffer中。

4. 由于整个图片大小是80000 一次调用只读取了32768 还有数据没读完，一次这个方法还会再次被调用。

5. 第二次调用这个方法，由于[self.currentHTTPBodyPart hasBytesAvailable]还有数据，所以还是会走到else的方法中，self.currentHTTPBodyPart并没有指向别的body。因此继续执行 3.的方法。

6. 至于为什么能接着从上次的已读取的数据开始读数据，这个是body内部封装实现的，可参考本文上边关于body的介绍。

7. 重复 3 4 5 的步骤，直到没有数据可读时，stream就会关闭流。到此我们的突变数据就以流的形式上传到服务器了。

ps： 如有错误地方，请给与指正哦。

关闭读取缓存和设置getter方法

重写open close方法

重写NSSteam的方法，说实话不太明白为什么写这个？？

返回总大小

设置 跟CoreFoundation相关的方法。

实现NSCopying协议。

=============================  分割线 ==============================

在写一个功能的时候，我们往往并不能把业务功能分隔的很完美，这个就跟经验相关了，通过封装AFHTTPBodyPart和AFMultipartBodyStream这两个小工具，我们已经能够拿到数据了。还记得之前的 AFMultipartFormData 协议吗？在使用时，我们调用协议的方法，来把数据上传的。理所当然，我们只要让AFMultipartBodyStream实现这个协议不就可以做到我们的目的了吗？

但这显然是不够好的，因此AFNetworking 又 再次对 AFHTTPBodyPart和AFMultipartBodyStream 进行了封装。

看到这个类，应该能联想到它的作用了。再看这个方法

那个formData 正好是AFStreamingMultipartFormData啊，他也遵守AFMultipartFormData协议，这个下边会详细说。

之所以说他起到了连接request和数据的作用，就是因为用于这两个属性。

初始化方法，在这里，创建了边界和管道。

 - (BOOL)appendPartWithFileURL:(NSURL *)fileURL
                          name:(NSString *)name
                      fileName:(NSString *)fileName
                      mimeType:(NSString *)mimeType
                         error:(NSError * __autoreleasing *)error
 {
     NSParameterAssert(fileURL);
     NSParameterAssert(name);
     NSParameterAssert(fileName);
     NSParameterAssert(mimeType);

     if (![fileURL isFileURL]) {
         NSDictionary *userInfo = @{NSLocalizedFailureReasonErrorKey: NSLocalizedStringFromTable(@"Expected URL to be a file URL", @"AFNetworking", nil)};
         if (error) {
             *error = [[NSError alloc] initWithDomain:AFURLRequestSerializationErrorDomain code:NSURLErrorBadURL userInfo:userInfo];
         }

         return NO;
     } else if ([fileURL checkResourceIsReachableAndReturnError:error] == NO) {
         NSDictionary *userInfo = @{NSLocalizedFailureReasonErrorKey: NSLocalizedStringFromTable(@"File URL not reachable.", @"AFNetworking", nil)};
         if (error) {
             *error = [[NSError alloc] initWithDomain:AFURLRequestSerializationErrorDomain code:NSURLErrorBadURL userInfo:userInfo];
         }

         return NO;
     }

     NSDictionary *fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:[fileURL path] error:error];
     if (!fileAttributes) {
         return NO;
     }

     NSMutableDictionary *mutableHeaders = [NSMutableDictionary dictionary];
     [mutableHeaders setValue:[NSString stringWithFormat:@"form-data; name=\"%@\"; filename=\"%@\"", name, fileName] forKey:@"Content-Disposition"];
     [mutableHeaders setValue:mimeType forKey:@"Content-Type"];

     AFHTTPBodyPart *bodyPart = [[AFHTTPBodyPart alloc] init];
     bodyPart.stringEncoding = self.stringEncoding;
     bodyPart.headers = mutableHeaders;
     bodyPart.boundary = self.boundary;
     bodyPart.body = fileURL;
     bodyPart.bodyContentLength = [fileAttributes[NSFileSize] unsignedLongLongValue];
     [self.bodyStream appendHTTPBodyPart:bodyPart];

     return YES;
 }

这个方法其实很好理解，就是通过本地的一个文件的URL获取数据。

我们通过这个URL能够获取到一些和文件相关的信息，然后再进行一些必要的判断，最后生成一个AFHTTPBodyPart模型，最终把这个模型拼接到管道的模型数组中。就完成任务了。也就是说，一个良好的设计，在使用时就会很顺畅。

我们能够在这个方法中学到的“

1.  NSParameterAssert()  用来判断参数是否为空，如果为空就抛出异常

2. 使用isFileURL 判断一个URL是否为fileURL 使用checkResourceIsReachableAndReturnError判断路径能够到达

3. 使用 [[NSFileManager defaultManager] attributesOfItemAtPath:[fileURL path] error:error] 获取本地文件属性

 - (BOOL)appendPartWithFileURL:(NSURL *)fileURL
                          name:(NSString *)name
                         error:(NSError * __autoreleasing *)error
 {
     NSParameterAssert(fileURL);
     NSParameterAssert(name);

     NSString *fileName = [fileURL lastPathComponent];
     NSString *mimeType = AFContentTypeForPathExtension([fileURL pathExtension]);

     return [self appendPartWithFileURL:fileURL name:name fileName:fileName mimeType:mimeType error:error];
 }

再来看这个方法，参数比上边的那个方法少了几个，不难猜测，应该是有些参数会采取计算或者默认的方法初始化的。

1. lastPathComponent  ，https://www.baidu.com/abc.html     结果就是abc.html

2. pathExtension   https://www.baidu.com/abc.html     结果就是html

这里边有一个AFContentTypeForPathExtension（） 方法，我们看看是怎么实现的：

static inline NSString * AFContentTypeForPathExtension(NSString *extension) {
    NSString *UTI = (__bridge_transfer NSString *)UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, (__bridge CFStringRef)extension, NULL);
    NSString *contentType = (__bridge_transfer NSString *)UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)UTI, kUTTagClassMIMEType);
    if (!contentType) {
        return @"application/octet-stream";
    } else {
        return contentType;
    }
}

首先这算是一个内联函数，可以根据一个后缀名获取contentType  这个记住就行了，中间的两个函数包含在

#import <MobileCoreServices/MobileCoreServices.h>中。

 - (void)appendPartWithInputStream:(NSInputStream *)inputStream
                              name:(NSString *)name
                          fileName:(NSString *)fileName
                            length:(int64_t)length
                          mimeType:(NSString *)mimeType
 {
     NSParameterAssert(name);
     NSParameterAssert(fileName);
     NSParameterAssert(mimeType);

     NSMutableDictionary *mutableHeaders = [NSMutableDictionary dictionary];
     [mutableHeaders setValue:[NSString stringWithFormat:@"form-data; name=\"%@\"; filename=\"%@\"", name, fileName] forKey:@"Content-Disposition"];
     [mutableHeaders setValue:mimeType forKey:@"Content-Type"];

     AFHTTPBodyPart *bodyPart = [[AFHTTPBodyPart alloc] init];
     bodyPart.stringEncoding = self.stringEncoding;
     bodyPart.headers = mutableHeaders;
     bodyPart.boundary = self.boundary;
     bodyPart.body = inputStream;

     bodyPart.bodyContentLength = (unsigned long long)length;

     [self.bodyStream appendHTTPBodyPart:bodyPart];
 }

通过流来获取数据。这个没什么好说的。

 - (void)appendPartWithFileData:(NSData *)data
                           name:(NSString *)name
                       fileName:(NSString *)fileName
                       mimeType:(NSString *)mimeType
 {
     NSParameterAssert(name);
     NSParameterAssert(fileName);
     NSParameterAssert(mimeType);

     NSMutableDictionary *mutableHeaders = [NSMutableDictionary dictionary];
     [mutableHeaders setValue:[NSString stringWithFormat:@"form-data; name=\"%@\"; filename=\"%@\"", name, fileName] forKey:@"Content-Disposition"];
     [mutableHeaders setValue:mimeType forKey:@"Content-Type"];

     [self appendPartWithHeaders:mutableHeaders body:data];
 }

 - (void)appendPartWithFormData:(NSData *)data
                           name:(NSString *)name
 {
     NSParameterAssert(name);

     NSMutableDictionary *mutableHeaders = [NSMutableDictionary dictionary];
     [mutableHeaders setValue:[NSString stringWithFormat:@"form-data; name=\"%@\"", name] forKey:@"Content-Disposition"];

     [self appendPartWithHeaders:mutableHeaders body:data];
 }

 - (void)appendPartWithHeaders:(NSDictionary *)headers
                          body:(NSData *)body
 {
     NSParameterAssert(body);

     AFHTTPBodyPart *bodyPart = [[AFHTTPBodyPart alloc] init];
     bodyPart.stringEncoding = self.stringEncoding;
     bodyPart.headers = headers;
     bodyPart.boundary = self.boundary;
     bodyPart.bodyContentLength = [body length];
     bodyPart.body = body;

     [self.bodyStream appendHTTPBodyPart:bodyPart];
 }

这三个方法，是根据NSData 获取数据的方法，为了尽量不出现重复的代码，抽象了这个方法

- (void)appendPartWithHeaders:(NSDictionary *)headers

body:(NSData *)body

- (void)throttleBandwidthWithPacketSize:(NSUInteger)numberOfBytes
                                  delay:(NSTimeInterval)delay
{
    self.bodyStream.numberOfBytesInPacket = numberOfBytes;
    self.bodyStream.delay = delay;
}

设置管道的两个属性

 - (NSMutableURLRequest *)requestByFinalizingMultipartFormData {
     if ([self.bodyStream isEmpty]) {
         return self.request;
     }

     // Reset the initial and final boundaries to ensure correct Content-Length
     [self.bodyStream setInitialAndFinalBoundaries];
     [self.request setHTTPBodyStream:self.bodyStream];

     [self.request setValue:[NSString stringWithFormat:@"multipart/form-data; boundary=%@", self.boundary] forHTTPHeaderField:@"Content-Type"];
     [self.request setValue:[NSString stringWithFormat:@"%llu", [self.bodyStream contentLength]] forHTTPHeaderField:@"Content-Length"];

     return self.request;
 }

这个是把数据跟请求建立联系的核心方法，通过 [self.request setHTTPBodyStream:self.bodyStream];这个方法建立联系，然后设置Content-Type

和 Content-Length 最后返回一个NSMutableURLRequest。

=================================  分割线 =====================================

看完了上边所有的算是辅助功能的小工具类后，我们进入正题，也正验证了那句话，一切复杂的问题，分割成若干子问题后，就很容已解决。

我们先看看AFHTTPRequestSerializer 暴露出来的接口有什么

我们给每一个暴露出来的属性或方法添加一个标记，到后边实现方法的时候我们就使用标记来代替名称

1. 标记①

2. 标记②

3. 标记③

这个要仔细介绍下，在某些特殊的场景下还是能用到的。我们点开NSURLRequestCachePolicy 可以看到是一个枚举值

 typedef NS_ENUM(NSUInteger, NSURLRequestCachePolicy)
 {
     NSURLRequestUseProtocolCachePolicy = ,

     NSURLRequestReloadIgnoringLocalCacheData = ,
     NSURLRequestReloadIgnoringLocalAndRemoteCacheData = , // Unimplemented
     NSURLRequestReloadIgnoringCacheData = NSURLRequestReloadIgnoringLocalCacheData,

     NSURLRequestReturnCacheDataElseLoad = ,
     NSURLRequestReturnCacheDataDontLoad = ,

     NSURLRequestReloadRevalidatingCacheData = , // Unimplemented
 };

NSURLRequestUseProtocolCachePolicy      这个是默认的缓存策略，缓存不存在，就请求服务器，缓存存在，会根据response中的Cache-Control字段判断下一步操作，如: Cache-Control字段为must-revalidata, 则询问服务端该数据是否有更新，无更新的话直接返回给用户缓存数据，若已更新，则请求服务端。

NSURLRequestReloadIgnoringLocalCacheData   这个策略是不管有没有本地缓存，都请求服务器。

NSURLRequestReloadIgnoringLocalAndRemoteCacheData   这个策略会忽略本地缓存和中间代理 直接访问源server

NSURLRequestReturnCacheDataElseLoad    这个策略指，有缓存就是用，不管其有效性，即Cache-Control字段 ，没有就访问源server

NSURLRequestReturnCacheDataDontLoad   这个策略只加载本地数据，不做其他操作，适用于没有网路的情况

NSURLRequestReloadRevalidatingCacheData  这个策略标示缓存数据必须得到服务器确认才能使用，未实现。

4. 标记④

在HTTP连接中，一般都是一个请求对应一个连接，每次简历tcp连接是需要一定时间的。管线化，允许一次发送一组请求而不必等到相应。但由于目前并不是所有的服务器都支持这项功能，因此这个属性默认是不开启的。管线化使用同一tcp连接完成任务，因此能够大大提交请求的时间。但是响应要和请求的顺序 保持一致才行。使用场景也有，比如说首页要发送很多请求，可以考虑这种技术。但前提是建立连接成功后才可以使用。

5. 标记⑤

网络服务类型 是一个枚举值

typedef NS_ENUM(NSUInteger, NSURLRequestNetworkServiceType)
{
    NSURLNetworkServiceTypeDefault = ,    // Standard internet traffic
    NSURLNetworkServiceTypeVoIP = ,    // Voice over IP control traffic
    NSURLNetworkServiceTypeVideo = ,    // Video traffic
    NSURLNetworkServiceTypeBackground = , // Background traffic
    NSURLNetworkServiceTypeVoice =        // Voice data
};

可以通过这个值来指定当前的网络类型，系统会跟据制定的网络类型对很多方面进行优化，这个就设计到很细微的编程技巧了，可作为一个优化的点备用。

6. 标记⑥

设置请求超时时间，以秒为单位，默认为60秒。

7. 标记⑦

8. 标记⑧

9. 标记⑨

10. 标记⑩

这两个方法Authorization 这个词有关，上边的那个方法是根据用户名和密码 生成一个 Authorization 和值，拼接到请求头中规则是这样的

Authorization: Basic YWRtaW46YWRtaW4=    其中Basic表示基础认证，当然还有其他认证，如果感兴趣，可以看看本文开始提出的那本书。后边的YWRtaW46YWRtaW4= 是根据username:password 拼接后然后在经过Base64编码后的结果。

如果header中有 Authorization这个字段，那么服务器会验证用户名和密码，如果不正确的话会返回401错误。

11. 标记⑪

12. 标记⑫

13. 标记⑬

ps 这个要介绍一下 ，当我们需要一些东西或控件或对象需要自定义的时候，我们可以把我们的要求封装到一个block中。通过定制这个block达到*定制的目的。

举个简单的例子，加入我们需要创建一个view，这个view跟两个参数相关，title，subtitle。 我们就可以使用上边的这个思想，返回一个返回值为view的block，这样通过参数，我们可以*定制各种各样的view。

这样的场景还是很多，我现在也还没想好具体怎么用，只是突然有了这样的想法，大家如果有好的想法，可以留言。

14. 标记⑭

下边这三个是核心方法了，用来创建NSMutableURLRequest 这个对象，这个对象的创建又与上边①--⑬的设置息息相关

参数就不必介绍了，大家应该都懂，根据这个方法的注释，当method为GET/HEAD/DELETE 时，参数会被拼接到URL中，其他情况则会当做requset的body处理。

这个方法支持上传数据，值得注意的是之所以能够把本地磁盘或者内存中的数据发送到服务器，是因为NSURLRequest 有两个属性 ：

NSData *HTTPBody;

NSInputStream *HTTPBodyStream;

这个方法可以把一个请求中的body数据保存到一个文件中，然后返回一个HTTPBodyStream为nil的请求，按照注释说的，NSURLSessionTask在使用流传数据时。如果没拼接Content-Length 会有问题。然后可以把这文件上传或者把它转为二进制文件上传。

=================================== 分割线 =====================================

我们已经知道了很多了，这篇真的很长，但耐心看完，一定会受益匪浅，知道了每个属性或者方法的作用，那么它的实现也基本上有点思路了。

这个是需要监听的属性，但看这些属性而言，要想实现当属性变化时，就调用监听方法，就需要我们手动实现监听方法。这也就说明，如果在平时开发中想要监听一个对象中某个自定义的属性时，只需要手动实现监听方法就行了。看看是怎么做的：

 // Workarounds for crashing behavior using Key-Value Observing with XCTest
 // See https://github.com/AFNetworking/AFNetworking/issues/2523
 /**
  *  下边的这几个setter方法，主要目的是触发kvo监听
  */
 - (void)setAllowsCellularAccess:(BOOL)allowsCellularAccess {
     [self willChangeValueForKey:NSStringFromSelector(@selector(allowsCellularAccess))];
     _allowsCellularAccess = allowsCellularAccess;
     [self didChangeValueForKey:NSStringFromSelector(@selector(allowsCellularAccess))];
 }

 - (void)setCachePolicy:(NSURLRequestCachePolicy)cachePolicy {
     [self willChangeValueForKey:NSStringFromSelector(@selector(cachePolicy))];
     _cachePolicy = cachePolicy;
     [self didChangeValueForKey:NSStringFromSelector(@selector(cachePolicy))];
 }

 - (void)setHTTPShouldHandleCookies:(BOOL)HTTPShouldHandleCookies {
     [self willChangeValueForKey:NSStringFromSelector(@selector(HTTPShouldHandleCookies))];
     _HTTPShouldHandleCookies = HTTPShouldHandleCookies;
     [self didChangeValueForKey:NSStringFromSelector(@selector(HTTPShouldHandleCookies))];
 }

 - (void)setHTTPShouldUsePipelining:(BOOL)HTTPShouldUsePipelining {
     [self willChangeValueForKey:NSStringFromSelector(@selector(HTTPShouldUsePipelining))];
     _HTTPShouldUsePipelining = HTTPShouldUsePipelining;
     [self didChangeValueForKey:NSStringFromSelector(@selector(HTTPShouldUsePipelining))];
 }

 - (void)setNetworkServiceType:(NSURLRequestNetworkServiceType)networkServiceType {
     [self willChangeValueForKey:NSStringFromSelector(@selector(networkServiceType))];
     _networkServiceType = networkServiceType;
     [self didChangeValueForKey:NSStringFromSelector(@selector(networkServiceType))];
 }

 - (void)setTimeoutInterval:(NSTimeInterval)timeoutInterval {
     [self willChangeValueForKey:NSStringFromSelector(@selector(timeoutInterval))];
     _timeoutInterval = timeoutInterval;
     [self didChangeValueForKey:NSStringFromSelector(@selector(timeoutInterval))];
 }

可以看出只要在setter方法中加入两行代码就行了。

 - (instancetype)init {
     self = [super init];
     if (!self) {
         return nil;
     }

     self.stringEncoding = NSUTF8StringEncoding;

     self.mutableHTTPRequestHeaders = [NSMutableDictionary dictionary];

     // Accept-Language HTTP Header; see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
     /**
      *  传递可接受的语言，q代表对语言的喜好程度，默认是取出前5个的数据，不足5个，取实际的个数
      */
     NSMutableArray *acceptLanguagesComponents = [NSMutableArray array];
     [[NSLocale preferredLanguages] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
         float q = 1.0f - (idx * 0.1f);
         [acceptLanguagesComponents addObject:[NSString stringWithFormat:@"%@;q=%0.1g", obj, q]];
         *stop = q <= 0.5f;
     }];

     // 设置请求头
     [self setValue:[acceptLanguagesComponents componentsJoinedByString:@", "] forHTTPHeaderField:@"Accept-Language"];

     // 获取信息
     NSString *userAgent = nil;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu"
 #if TARGET_OS_IOS
     // User-Agent Header; see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.43
     userAgent = [NSString stringWithFormat:@"%@/%@ (%@; iOS %@; Scale/%0.2f)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[UIDevice currentDevice] model], [[UIDevice currentDevice] systemVersion], [[UIScreen mainScreen] scale]];
 #elif TARGET_OS_WATCH
     // User-Agent Header; see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.43
     userAgent = [NSString stringWithFormat:@"%@/%@ (%@; watchOS %@; Scale/%0.2f)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[WKInterfaceDevice currentDevice] model], [[WKInterfaceDevice currentDevice] systemVersion], [[WKInterfaceDevice currentDevice] screenScale]];
 #elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
     userAgent = [NSString stringWithFormat:@"%@/%@ (Mac OS X %@)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[NSProcessInfo processInfo] operatingSystemVersionString]];
 #endif
 #pragma clang diagnostic pop
     if (userAgent) {
         if (![userAgent canBeConvertedToEncoding:NSASCIIStringEncoding]) {
             NSMutableString *mutableUserAgent = [userAgent mutableCopy];

             // 转换字符串的方法 http://nshipster.com/cfstringtransform/
             if (CFStringTransform((__bridge CFMutableStringRef)(mutableUserAgent), NULL, (__bridge CFStringRef)@"Any-Latin; Latin-ASCII; [:^ASCII:] Remove", false)) {
                 userAgent = mutableUserAgent;
             }
         }
         [self setValue:userAgent forHTTPHeaderField:@"User-Agent"];
     }

     // HTTP Method Definitions; see http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html
     self.HTTPMethodsEncodingParametersInURI = [NSSet setWithObjects:@"GET", @"HEAD", @"DELETE", nil];

     // 设置监听
     self.mutableObservedChangedKeyPaths = [NSMutableSet set];
     for (NSString *keyPath in AFHTTPRequestSerializerObservedKeyPaths()) {
         if ([self respondsToSelector:NSSelectorFromString(keyPath)]) {
             [self addObserver:self forKeyPath:keyPath options:NSKeyValueObservingOptionNew context:AFHTTPRequestSerializerObserverContext];
         }
     }

     return self;
 }

 - (void)dealloc {

     // 取消监听
     for (NSString *keyPath in AFHTTPRequestSerializerObservedKeyPaths()) {
         if ([self respondsToSelector:NSSelectorFromString(keyPath)]) {
             [self removeObserver:self forKeyPath:keyPath context:AFHTTPRequestSerializerObserverContext];
         }
     }
 }

这个比较好理解，就是对请求头字典的操作。

这两个方法是标记⑩的实现部分，上边也说明了，拼接Authorization 只要按照一定的规则就可以了。

这个是对标记⑫ 和 标记⑬ 的实现部分，再次声明下，关于URI中查询字段 也就是 query部分，的转换是通过block来转换的。

 - (NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request
                                withParameters:(id)parameters
                                         error:(NSError *__autoreleasing *)error
 {
     NSParameterAssert(request);

     NSMutableURLRequest *mutableRequest = [request mutableCopy];

     // 设置请求头
     [self.HTTPRequestHeaders enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL * __unused stop) {
         if (![request valueForHTTPHeaderField:field]) {
             [mutableRequest setValue:value forHTTPHeaderField:field];
         }
     }];

     // 设置查询字段
     NSString *query = nil;
     if (parameters) {
         if (self.queryStringSerialization) {
             NSError *serializationError;
             query = self.queryStringSerialization(request, parameters, &serializationError);

             if (serializationError) {
                 if (error) {
                     *error = serializationError;
                 }

                 return nil;
             }
         } else {
             switch (self.queryStringSerializationStyle) {
                 case AFHTTPRequestQueryStringDefaultStyle:
                     query = AFQueryStringFromParameters(parameters);
                     break;
             }
         }
     }

     // 如果请求的method 为 GET/HEAD/DELETE 直接把查询拼接到URL中
     if ([self.HTTPMethodsEncodingParametersInURI containsObject:[[request HTTPMethod] uppercaseString]]) {
         if (query && query.length > ) {
             mutableRequest.URL = [NSURL URLWithString:[[mutableRequest.URL absoluteString] stringByAppendingFormat:mutableRequest.URL.query ? @"&%@" : @"?%@", query]];
         }
     }

     // 其他的 要设置下边的内容，然后给请求的HTTPBody 赋值就可以了
     else {
         // #2864: an empty string is a valid x-www-form-urlencoded payload
         if (!query) {
             query = @"";
         }
         if (![mutableRequest valueForHTTPHeaderField:@"Content-Type"]) {
             [mutableRequest setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"];
         }
         [mutableRequest setHTTPBody:[query dataUsingEncoding:self.stringEncoding]];
     }

     return mutableRequest;
 }

这个方法也不是很复杂，主要的作用就是根据参数对NSURLRequest 进行设置，设置包括

1. 请求头

2. query字段，如果是GET/HEAD/DELETE 直接拼接到URL中，其他情况拼接到HTTPBody中。

注意：这个方法不处理数据流，只处理参数类型的数据。

 - (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);

     NSMutableURLRequest *mutableRequest = [[NSMutableURLRequest alloc] initWithURL:url];
     mutableRequest.HTTPMethod = method;

     // 设置mutableRequest的一些属性，这些属性就是AFHTTPRequestSerializerObservedKeyPaths() f返回的数组，
     for (NSString *keyPath in AFHTTPRequestSerializerObservedKeyPaths()) {
         if ([self.mutableObservedChangedKeyPaths containsObject:keyPath]) {
             [mutableRequest setValue:[self valueForKeyPath:keyPath] forKey:keyPath];
         }
     }

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

     return mutableRequest;
 }

这个是一个创建NSMutableURLRequest 的方法，也是对上边的标记⑭的实现部分，简单说一下创建的过程

1. 新建一个NSMutableURLRequest

2. HTTPMethod  赋值

3. 根据 mutableObservedChangedKeyPaths  设置请求的一些属性

4. 通过

- (NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request

withParameters:(id)parameters

error:(NSError *__autoreleasing *)error 方法过滤和设置请求

 - (NSMutableURLRequest *)multipartFormRequestWithMethod:(NSString *)method
                                               URLString:(NSString *)URLString
                                              parameters:(NSDictionary *)parameters
                               constructingBodyWithBlock:(void (^)(id <AFMultipartFormData> formData))block
                                                   error:(NSError *__autoreleasing *)error
 {
     // method 不能为空
     // method 不能是GET 和 HEAD
     NSParameterAssert(method);
     NSParameterAssert(![method isEqualToString:@"GET"] && ![method isEqualToString:@"HEAD"]);

     // 通过私有方法获取NSMutableURLRequest
     NSMutableURLRequest *mutableRequest = [self requestWithMethod:method URLString:URLString parameters:nil error:error];

     // 创建一个AFStreamingMultipartFormData实例，用来处理数据。
     __block AFStreamingMultipartFormData *formData = [[AFStreamingMultipartFormData alloc] initWithURLRequest:mutableRequest stringEncoding:NSUTF8StringEncoding];

     if (parameters) {

         // 遍历parameters后 把value转成NSData然后拼接到formData中
         for (AFQueryStringPair *pair in AFQueryStringPairsFromDictionary(parameters)) {
             NSData *data = nil;
             if ([pair.value isKindOfClass:[NSData class]]) {
                 data = pair.value;
             } else if ([pair.value isEqual:[NSNull null]]) {
                 data = [NSData data];
             } else {
                 data = [[pair.value description] dataUsingEncoding:self.stringEncoding];
             }

             if (data) {
                 [formData appendPartWithFormData:data name:[pair.field description]];
             }
         }
     }

     if (block) {
         block(formData);
     }

     return [formData requestByFinalizingMultipartFormData];
 }

这个方法是专门处理上传数据的方法，这里就不允许使用GET / HEAD HTTPMethod了。而且会把参数拼到formdata中了。

 - (NSMutableURLRequest *)requestWithMultipartFormRequest:(NSURLRequest *)request
                              writingStreamContentsToFile:(NSURL *)fileURL
                                        completionHandler:(void (^)(NSError *error))handler
 {
     NSParameterAssert(request.HTTPBodyStream);
     NSParameterAssert([fileURL isFileURL]);

     // 加上上边的两个判断，下边的这些代码就是把文件写到另一个地方的典型使用方法了
     NSInputStream *inputStream = request.HTTPBodyStream;
     NSOutputStream *outputStream = [[NSOutputStream alloc] initWithURL:fileURL append:NO];
     __block NSError *error = nil;

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, ), ^{
         [inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
         [outputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];

         [inputStream open];
         [outputStream open];

         // 读取数据
         while ([inputStream hasBytesAvailable] && [outputStream hasSpaceAvailable]) {
             uint8_t buffer[];

             NSInteger bytesRead = [inputStream read:buffer maxLength:];
             if (inputStream.streamError || bytesRead < ) {
                 error = inputStream.streamError;
                 break;
             }

             NSInteger bytesWritten = [outputStream write:buffer maxLength:(NSUInteger)bytesRead];
             if (outputStream.streamError || bytesWritten < ) {
                 error = outputStream.streamError;
                 break;
             }

             if (bytesRead ==  && bytesWritten == ) {
                 break;
             }
         }

         [outputStream close];
         [inputStream close];

         if (handler) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 handler(error);
             });
         }
     });

     NSMutableURLRequest *mutableRequest = [request mutableCopy];
     mutableRequest.HTTPBodyStream = nil;

     return mutableRequest;
 }

这个方法可以说是一个关于使用NSInputStream和NSOutputSteam 的经典案例，用法可以记下来或那这个方法的代码做参考。

 + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
     if ([AFHTTPRequestSerializerObservedKeyPaths() containsObject:key]) {
         return NO;
     }

     return [super automaticallyNotifiesObserversForKey:key];
 }

 - (void)observeValueForKeyPath:(NSString *)keyPath
                       ofObject:(__unused id)object
                         change:(NSDictionary *)change
                        context:(void *)context
 {
     if (context == AFHTTPRequestSerializerObserverContext) {
         if ([change[NSKeyValueChangeNewKey] isEqual:[NSNull null]]) {
             [self.mutableObservedChangedKeyPaths removeObject:keyPath];
         } else {
             [self.mutableObservedChangedKeyPaths addObject:keyPath];
         }
     }
 }

这两个方法是关于kvo的。 值得学习的地方是我们通过判断change[NSKeyValueChangeNewKey] 是不是等于[NSNull null] 来写出不同的结果。

 + (BOOL)supportsSecureCoding {
     return YES;
 }

 - (instancetype)initWithCoder:(NSCoder *)decoder {
     self = [self init];
     if (!self) {
         return nil;
     }

     self.mutableHTTPRequestHeaders = [[decoder decodeObjectOfClass:[NSDictionary class] forKey:NSStringFromSelector(@selector(mutableHTTPRequestHeaders))] mutableCopy];
     self.queryStringSerializationStyle = (AFHTTPRequestQueryStringSerializationStyle)[[decoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(queryStringSerializationStyle))] unsignedIntegerValue];

     return self;
 }

 - (void)encodeWithCoder:(NSCoder *)coder {
     [coder encodeObject:self.mutableHTTPRequestHeaders forKey:NSStringFromSelector(@selector(mutableHTTPRequestHeaders))];
     [coder encodeInteger:self.queryStringSerializationStyle forKey:NSStringFromSelector(@selector(queryStringSerializationStyle))];
 }

 #pragma mark - NSCopying

 - (instancetype)copyWithZone:(NSZone *)zone {
     AFHTTPRequestSerializer *serializer = [[[self class] allocWithZone:zone] init];
     serializer.mutableHTTPRequestHeaders = [self.mutableHTTPRequestHeaders mutableCopyWithZone:zone];
     serializer.queryStringSerializationStyle = self.queryStringSerializationStyle;
     serializer.queryStringSerialization = self.queryStringSerialization;

     return serializer;
 }

==============================  分割线 ==============================

 @implementation AFJSONRequestSerializer

 + (instancetype)serializer {
     return [self serializerWithWritingOptions:(NSJSONWritingOptions)];
 }

 + (instancetype)serializerWithWritingOptions:(NSJSONWritingOptions)writingOptions
 {
     AFJSONRequestSerializer *serializer = [[self alloc] init];
     serializer.writingOptions = writingOptions;

     return serializer;
 }

 #pragma mark - AFURLRequestSerialization

 - (NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request
                                withParameters:(id)parameters
                                         error:(NSError *__autoreleasing *)error
 {
     NSParameterAssert(request);

     if ([self.HTTPMethodsEncodingParametersInURI containsObject:[[request HTTPMethod] uppercaseString]]) {
         return [super requestBySerializingRequest:request withParameters:parameters error:error];
     }

     NSMutableURLRequest *mutableRequest = [request mutableCopy];

     [self.HTTPRequestHeaders enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL * __unused stop) {
         if (![request valueForHTTPHeaderField:field]) {
             [mutableRequest setValue:value forHTTPHeaderField:field];
         }
     }];

     if (parameters) {
         if (![mutableRequest valueForHTTPHeaderField:@"Content-Type"]) {
             [mutableRequest setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
         }

         [mutableRequest setHTTPBody:[NSJSONSerialization dataWithJSONObject:parameters options:self.writingOptions error:error]];
     }

     return mutableRequest;
 }

 #pragma mark - NSSecureCoding

 - (instancetype)initWithCoder:(NSCoder *)decoder {
     self = [super initWithCoder:decoder];
     if (!self) {
         return nil;
     }

     self.writingOptions = [[decoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(writingOptions))] unsignedIntegerValue];

     return self;
 }

 - (void)encodeWithCoder:(NSCoder *)coder {
     [super encodeWithCoder:coder];

     [coder encodeInteger:self.writingOptions forKey:NSStringFromSelector(@selector(writingOptions))];
 }

 #pragma mark - NSCopying

 - (instancetype)copyWithZone:(NSZone *)zone {
     AFJSONRequestSerializer *serializer = [super copyWithZone:zone];
     serializer.writingOptions = self.writingOptions;

     return serializer;
 }

 @end

AFJSONRequestSerializer 这个类呢，可以把参数 转为json进行上传，当服务器要求我们上传的数据格式是json的时候呢，就用上了

==============================  分割线 ============================

 @implementation AFPropertyListRequestSerializer

 + (instancetype)serializer {
     return [self serializerWithFormat:NSPropertyListXMLFormat_v1_0 writeOptions:];
 }

 + (instancetype)serializerWithFormat:(NSPropertyListFormat)format
                         writeOptions:(NSPropertyListWriteOptions)writeOptions
 {
     AFPropertyListRequestSerializer *serializer = [[self alloc] init];
     serializer.format = format;
     serializer.writeOptions = writeOptions;

     return serializer;
 }

 #pragma mark - AFURLRequestSerializer

 - (NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request
                                withParameters:(id)parameters
                                         error:(NSError *__autoreleasing *)error
 {
     NSParameterAssert(request);

     if ([self.HTTPMethodsEncodingParametersInURI containsObject:[[request HTTPMethod] uppercaseString]]) {
         return [super requestBySerializingRequest:request withParameters:parameters error:error];
     }

     NSMutableURLRequest *mutableRequest = [request mutableCopy];

     [self.HTTPRequestHeaders enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL * __unused stop) {
         if (![request valueForHTTPHeaderField:field]) {
             [mutableRequest setValue:value forHTTPHeaderField:field];
         }
     }];

     if (parameters) {
         if (![mutableRequest valueForHTTPHeaderField:@"Content-Type"]) {
             [mutableRequest setValue:@"application/x-plist" forHTTPHeaderField:@"Content-Type"];
         }

         [mutableRequest setHTTPBody:[NSPropertyListSerialization dataWithPropertyList:parameters format:self.format options:self.writeOptions error:error]];
     }

     return mutableRequest;
 }

 #pragma mark - NSSecureCoding

 - (instancetype)initWithCoder:(NSCoder *)decoder {
     self = [super initWithCoder:decoder];
     if (!self) {
         return nil;
     }

     self.format = (NSPropertyListFormat)[[decoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(format))] unsignedIntegerValue];
     self.writeOptions = [[decoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(writeOptions))] unsignedIntegerValue];

     return self;
 }

 - (void)encodeWithCoder:(NSCoder *)coder {
     [super encodeWithCoder:coder];

     [coder encodeInteger:self.format forKey:NSStringFromSelector(@selector(format))];
     [coder encodeObject:@(self.writeOptions) forKey:NSStringFromSelector(@selector(writeOptions))];
 }

 #pragma mark - NSCopying

 - (instancetype)copyWithZone:(NSZone *)zone {
     AFPropertyListRequestSerializer *serializer = [super copyWithZone:zone];
     serializer.format = self.format;
     serializer.writeOptions = self.writeOptions;

     return serializer;
 }

 @end

好了，关于这篇文章，就到这了，其中还是设计了很多的知识点，而且设计上也非常完美，只有反复阅读，才能领悟到精髓所在。