最近在开发SDK时有上传图片的需求，这个需求用AF的话当然非常简单，多添加一句代码就可以搞定。但为避免第三方耦合并没有使用AFNetworking，这就需要自己走完上传图片的全部流程，所以仔细研究了一下AFNetworking的相关源码，梳理了整个流程，它的流程大致是这样的：

<img src=”http://ogdqxib8j.bkt.clouddn.com/image/png%E5%9B%BE%E7%89%87%E4%B8%8A%E4%BC%A0.png" title:”AFNetworking图片上传流程”>

看着有点眼花眼花缭乱是吧，没关系，接着往下看，看完这篇文章，你也可以自己封装一套图片上传网络工具类。

目录

  • 基本原理
  • 具体实现
    • 创建NSMutableURLRequest并设置请求方式为POST
    • 自定义HTTPBodyStream
    • 对request进行参数设置
    • 通过NSURLSession的uploadTaskWithStreamedRequest:方法发起Post请求

基本原理

首先我们来看一下AF中上传图片的方法长什么样：

1
2
3
4
5
6
- (nullable NSURLSessionDataTask *)POST:(NSString *)URLString
                             parameters:(nullable id)parameters
              constructingBodyWithBlock:(nullable void (^)(id <AFMultipartFormData> formData))block
                               progress:(nullable void (^)(NSProgress *uploadProgress))uploadProgress
                                success:(nullable void (^)(NSURLSessionDataTask *task, id _Nullable responseObject))success
                                failure:(nullable void (^)(NSURLSessionDataTask * _Nullable task, NSError *error))failure;

请求方式

这个方法和AF其他正常的POST请求一样，都是基于NSURLSession，通过自定义的NSMutableURLRequest发起网络请求。不过在这个方法中，并没有使用常用的dataTaskWithRequest方法，而使用的是uploadTaskWithStreamedRequest。

工具类AFStreamingMultipartFormData

在整个图片上传请求过程中，核心点在于为网络请求NSURLReqeust进行自定义的参数设定。为此，AFNetworking封装了一个工具类AFStreamingMultipartFormData，在这个类中完成对NSURLRequst除HTTPMethod外所有参数的设定。

InputStream的子类AFMultipartBodyStream

图片上传需要封装参数和图片数据，每一个参数的键值对都会封装成一个AFHTTPBodyPart模型，而AFMultipartBodyStream 就负责对AFHTTPBodyPart进行管理，它本身同时也是自定义的HTTPBodyStream。

参数的封装AFHTTPBodyPart

AFHTTPBodyPart是对POST请求数据的封装，并实现将请求数据转换为InputStream的方法

具体实现

上面的原理讲起来有点儿抽象，下面从图片上传的完整实现中来了解整个过程。

创建NSMutableURLRequest并设置请求方式为POST

这一步就是常规步骤，代码如下：

1
2
NSMutableURLRequest *request = [[NSMutableURLRequest alloc]initWithURL:[NSURL URLWithString:api] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:10.0f];
[request setHTTPMethod:@"POST"];

自定义HTTPBodyStream

首先，需要创建一个工具类来管理刚刚创建的request：

1
__block AFStreamingMultipartFormData *formData = [[AFStreamingMultipartFormData alloc] initWithURLRequest:request stringEncoding:NSUTF8StringEncoding];

接下来，需要将所有参数的键值对转换为AFHTTPBodyPart，这里要分两种情况：普通参数和图片相关参数。

普通参数

普通参数的转换直接遍历即可，将每一个键值对都转换为AFHTTPBodyPart，不过AFNetworking在这里将键值对又封闭了一个模型AFQueryStringPair，所以你看到的是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (parameters) {
    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]];
        }
    }
}

不过个人觉得完全没有必要，不封装模型这样写可以达到同样的效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if (parameters) {
    [parameters enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key, id  _Nonnull obj, BOOL * _Nonnull stop) {
        NSData *data = nil;
        if ([obj isKindOfClass:[NSData class]]) {
            data = obj;
        }else if ([obj isKindOfClass:[NSNull class]]) {
            data = [NSData data];
        }else {
            data = [[obj description] dataUsingEncoding:NSUTF8StringEncoding];
        }
        if (data) {
            [formData appendPartWithFormData:data name:[key description]];
        }
    }];
}

在上面的方法中，调用了-appendPartWithFormData:name:方法，这个方法的作用有两个：拼装Header字典和封装AFHTTPBodyPart模型：

1
2
3
4
5
6
7
8
9
- (void)appendPartWithFormData:(NSData *)data
                          name:(NSString *)name {
    NSParameterAssert(name);
	// 拼装Header字典
    NSMutableDictionary *mutableHeaders = [NSMutableDictionary dictionary];
    [mutableHeaders setValue:[NSString stringWithFormat:@"form-data; name=\"%@\"", name] forKey:@"Content-Disposition"];

    [self appendPartWithHeaders:mutableHeaders body:data];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (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;
	// bodyStream管理bodyPart
    [self.bodyStream appendHTTPBodyPart:bodyPart];
}

接下来就是在AFMultipartBodyStream中管理生成的多个AFHTTPBodyPart。

图片相关参数

如果只需要单一的上传图片的需求，直接将图片的数据、名称、类型等作为方法的参数传进来就可以，实现起来除Header的拼装有差异外几乎和上面正常参数一样。但AF为了可扩展性，添加了一个Block和代理，方便除NSData以外诸如FileURL、InputStream等上传方式。

这个Block长这个样子

1
void (^block)(id <AFMultipartFormData> formData)

Block传入的参数是除图片参数的键值对外的全部转换完成后的AFStreamingMultipartFormData，遵从AFMultipartFormData 协议。在以上正常参数转换完之后调用，Block的实现为用户自定义，用户可以选择适合的方式添加参数上传数据，这里只讲图片的NSData方式上传：

1
[formData appendPartWithFileData:imageData name:key fileName:[NSString stringWithFormat:@"%@.jpg",key] mimeType:@"image/jpeg"];

然后同样是拼接Header

1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (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];
}

然后是转换成AFHTTPBodyPart，由AFMultipartBodyStream进行管理。

1
2
3
4
5
6
7
8
9
10
11
12
13
- (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];
}

AFMultipartBodyStream管理并转换AFHTTPBodyPart内部数据的具体实现

每生成一个AFHTTPBodyPart它都会存入AFMultipartBodyStream的HTTPBodyParts这个可变数组中，方便后面对数据进行处理。

而AFMultipartBodyStream的对数据转换要从它的父类NSInputStream说起，NSInputStream是NSStream的子类，方便我们以流文件的形式读取数据。在AF中，它重写了父类的-read:maxLength:方法，在这个方法里进行数据的处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
- (NSInteger)read:(uint8_t *)buffer
        maxLength:(NSUInteger)length {
    if ([self streamStatus] == NSStreamStatusClosed) {
        return 0;
    }
    
    NSInteger totalNumberOfBytesRead = 0;
    
    while ((NSUInteger)totalNumberOfBytesRead < MIN(length, self.numberOfBytesInPacket)) {
        if (!self.currentHTTPBodyPart || ![self.currentHTTPBodyPart hasBytesAvailable]) {
            if (!(self.currentHTTPBodyPart = [self.HTTPBodyPartEnumerator nextObject])) {
                break;
            }
        } else {
            NSUInteger maxLength = MIN(length, self.numberOfBytesInPacket) - (NSUInteger)totalNumberOfBytesRead;
            NSInteger numberOfBytesRead = [self.currentHTTPBodyPart read:&buffer[totalNumberOfBytesRead] maxLength:maxLength];
            if (numberOfBytesRead == -1) {
//                self.streamError = self.currentHTTPBodyPart.inputStream.streamError;
                break;
            } else {
                totalNumberOfBytesRead += numberOfBytesRead;
                
                if (self.delay > 0.0f) {
                    [NSThread sleepForTimeInterval:self.delay];
                }
            }
        }
    }
    
    return totalNumberOfBytesRead;
}
​``` objc
上面这个方法核心就是把`bodyPart`挨个取出来进行读取数据操作，`bodyPart`读取数据的操作是在其内部实现的：

​``` objc
- (NSInteger)read:(uint8_t *)buffer
        maxLength:(NSUInteger)length {
    NSInteger totalNumberOfBytesRead = 0;
    
    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 = 0;
        
        numberOfBytesRead = [self.inputStream read:&buffer[totalNumberOfBytesRead] maxLength:(length - (NSUInteger)totalNumberOfBytesRead)];
        if (numberOfBytesRead == -1) {
            return -1;
        } 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (NSInteger)readData:(NSData *)data
           intoBuffer:(uint8_t *)buffer
            maxLength:(NSUInteger)length {
    NSRange range = NSMakeRange((NSUInteger)_phaseReadOffset, MIN([data length] - ((NSUInteger)_phaseReadOffset), length));
    [data getBytes:buffer range:range];
    
    _phaseReadOffset += range.length;
    
    if (((NSUInteger)_phaseReadOffset) >= [data length]) {
        [self transitionToNextPhase];
    }
    
    return (NSInteger)range.length;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
- (BOOL)transitionToNextPhase {
    if (![[NSThread currentThread] isMainThread]) {
        dispatch_sync(dispatch_get_main_queue(), ^{
            [self transitionToNextPhase];
        });
        return YES;
    }
    
    switch (_phase) {
        case AFEncapsulationBoundaryPhase:
            _phase = AFHeaderPhase;
            break;
        case AFHeaderPhase:
            [self.inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
            [self.inputStream open];
            _phase = AFBodyPhase;
            break;
        case AFBodyPhase:
            [self.inputStream close];
            _phase = AFFinalBoundaryPhase;
            break;
        case AFFinalBoundaryPhase:
        default:
            _phase = AFEncapsulationBoundaryPhase;
            break;
    }
    _phaseReadOffset = 0;
    
    return YES;
}

上面三个方法即是bodyPart对数据读取的全部实现，看着比较复杂，梳理下来其实它的逻辑也比较清晰。简单来说就是把数据读取分成几个阶段，不同阶段进行相应操作，其最核心的是这两句：

1
2
[self.inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
[self.inputStream open];

这两句不仅仅是把输入流加入运行循环，开始读取数据，这里还用了一个懒加载，重写了inputStream的getter方法，在这个方法里进行了inputStream的初始化，即数据源的指定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (NSInputStream *)inputStream {
    if (!_inputStream) {
        if ([self.body isKindOfClass:[NSData class]]) {
            _inputStream = [NSInputStream inputStreamWithData:self.body];
        } else if ([self.body isKindOfClass:[NSURL class]]) {
            _inputStream = [NSInputStream inputStreamWithURL:self.body];
        } else if ([self.body isKindOfClass:[NSInputStream class]]) {
            _inputStream = self.body;
        } else {
            _inputStream = [NSInputStream inputStreamWithData:[NSData data]];
        }
    }
    
    return _inputStream;
}

所有的参数的数据流读取完毕，我们的自定义HTTPBodyStream也完成了，接下来就可以把它赋值给request了。

对request进行参数设置

参数设置这步比较简单，将之前自定义好的HTTPBodyStream赋值然后补充必要的参数即可：

1
2
// 调用方法对request进行配置
[formData requestByFinalizingMultipartFormData]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (NSMutableURLRequest *)requestByFinalizingMultipartFormData {
    if ([self.bodyStream isEmpty]) {
        return self.request;
    }

    // 重设Boundary确保内容长度计算正确
    [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;
}

通过NSURLSession的uploadTaskWithStreamedRequest:方法发起Post请求

上面request配置完成，就剩最后一步发起请求了：

1
2
3
4
5
6
7
8
9
10
11
12
13
__block NSURLSessionDataTask *task = [self uploadTaskWithStreamedRequest:request progress:uploadProgress completionHandler:^(NSURLResponse * __unused response, id responseObject, NSError *error) {
        if (error) {
            if (failure) {
                failure(task, error);
            }
        } else {
            if (success) {
                success(task, responseObject);
            }
        }
    }];

    [task resume];
1
2
3
4
5
6
7
8
9
10
11
12
13
- (NSURLSessionUploadTask *)uploadTaskWithStreamedRequest:(NSURLRequest *)request
                                                 progress:(void (^)(NSProgress *uploadProgress)) uploadProgressBlock
                                        completionHandler:(void (^)(NSURLResponse *response, id responseObject, NSError *error))completionHandler
{
    __block NSURLSessionUploadTask *uploadTask = nil;
    url_session_manager_create_task_safely(^{
        uploadTask = [self.session uploadTaskWithStreamedRequest:request];
    });

    [self addDelegateForUploadTask:uploadTask progress:uploadProgressBlock completionHandler:completionHandler];

    return uploadTask;
}

在AF自定义的上传方法中，使用了自己的代理，并让代理调用Block进行上传进度和完成的回调，具体实现在这里就不赘述了，可以看源代码进一步了解。

其实这个方法也完全可以用- dataTaskWithRequest:completionHandler:代替，这就避免了自己手动实现代理和回调的麻烦。

至此，整个图片上传流程就完成了。如果你自己写一个上传图片方法，其实也完全不用像AF的这么复杂，毕竟AF是要考虑到各种复杂的使用场景，内部的复杂实现可以保证调用更灵活也更方便。