AFNetworking 源码阅读笔记（三）

AFNetworking 是 Objective-C 中用于网络请求的第三方框架，我们一般使用它来封装网络请求，这篇文章记录了阅读 AFNetworking(Version 3.1.0) 源码的笔记，简单的研究了它的实现细节。

AFURLRequestSerialization

AFURLRequestSerialization 只是个协议，其内部提供了一个方法用以序列化请求数据。

@protocol AFURLRequestSerialization <NSObject, NSSecureCoding, NSCopying>

- (nullable NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request
                               withParameters:(nullable id)parameters
                                        error:(NSError * _Nullable __autoreleasing *)error NS_SWIFT_NOTHROW;

@end

同时也要遵循 NSObject、NSSecureCoding 和 NSCopying 这三个协议，实现安全编码、拷贝等。

在 AFNetworking 内部里遵循这个协议并返回特定的数据类型有 3 种，分别是：

• AFHTTPRequestSerializer
• AFJSONRequestSerializer
• AFPropertyListRequestSerializer

一般来说请求都会按 key=value 的方式带上各种参数，GET 方法参数会直接加在 URL 上，POST 方法放在 body 上，而 NSURLRequest 没有直接对这个参数的解析，所以都是拼好字符串再往上添加的。但 AFURLRequestSerialization 提供了接口，让参数可以是 NSDictionary, NSArray, NSSet 这些类型，再由内部解析成字符串后赋给 NSURLRequest。因为 AFHTTPRequestSerializer 为 AFHTTPSessionManager 创建时默认的 requestSerializer，下面具体过程以 AFHTTPRequestSerializer 的相关方法为例。

requestWithMethod 方法

requestWithMethod:方法是 AFHTTPSessionManager 在创建 dataTask 前用来创建 request 的，方法具体实现如下：

- (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构建并初始化NSMutableURLRequest，然后设置HTTPMethod
    NSMutableURLRequest *mutableRequest = [[NSMutableURLRequest alloc] initWithURL:url];
    mutableRequest.HTTPMethod = method;

    // 给NSMutableURLRequest自带的属性赋值
    // 然后通过判断mutableObservedChangedKeyPaths（NSMutableSet）中是否有这个keyPath，来设定mutableRequest对应的keyPath值
    // AFHTTPRequestSerializerObservedKeyPaths这个数组里的属性是固定的，且在 init 方法里全都 KVO 了
    /**
     *  当 AFHTTPRequestSerializerObserverContext 中有 value 变化了(且变化后的新值不为 NSNull null)，就会响应 observerValueForKeyPath 这个函数，从而mutableObservedChangedKeyPaths就会添加这个 keyPath
     */
    for (NSString *keyPath in AFHTTPRequestSerializerObservedKeyPaths()) {
        if ([self.mutableObservedChangedKeyPaths containsObject:keyPath]) {
            [mutableRequest setValue:[self valueForKeyPath:keyPath] forKey:keyPath];
        }
    }

    // 将传入的parameters进行编码，并添加到request中
    mutableRequest = [[self requestBySerializingRequest:mutableRequest withParameters:parameters error:error] mutableCopy];

	return mutableRequest;
}

主要是使用指定的 HTTP method 和 URLString 来构建一个 NSMutableURLRequest 对象实例，如果 method 是 GET、HEAD、DELETE，那么 parameter 将会被用来构建一个基于 url 编码的查询字符串，并且这个字符串会直接加到 request 的 url 后面。对于其他的Method，比如POST/PUT，会根据 parameterEncoding 属性进行编码，而后加到 request 的 http body 上，这里具体是调用 requestBySerializingRequest: 这个方法。

requestBySerializingRequest 方法

requestBySerializingRequest: 方法做了以下事情：

• 1.设置 HTTP 的头部
• 2.构建查询字符串
• 3.拼接参数
• 4.将 query 设置到 http body 上

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

    NSMutableURLRequest *mutableRequest = [request mutableCopy];

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

    
    // 2.构建查询字符串 query
    NSString *query = nil;
    if (parameters) {
        // 第一种，自定义了queryStringSerialization
        if (self.queryStringSerialization) {
            NSError *serializationError;
            query = self.queryStringSerialization(request, parameters, &serializationError);

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

                return nil;
            }
        } else {
            // 第二种，使用AFQueryStringFromParameters() 方法
            switch (self.queryStringSerializationStyle) {
                case AFHTTPRequestQueryStringDefaultStyle:
                    query = AFQueryStringFromParameters(parameters);
                    break;
            }
        }
    }
    // 3.拼接参数
    // 这几个method的quey是拼接到url后面的。而POST、PUT是把query拼接到http body中的。
    // 判断该request中是否包含了GET、HEAD、DELETE
    if ([self.HTTPMethodsEncodingParametersInURI containsObject:[[request HTTPMethod] uppercaseString]]) {
        if (query && query.length > 0) {
            // 将query合并到mutbleRequest的query url 上
            mutableRequest.URL = [NSURL URLWithString:[[mutableRequest.URL absoluteString] stringByAppendingFormat:mutableRequest.URL.query ? @"&%@" : @"?%@", query]];
        }
    } else {
        // 4.将query设置到http body上
        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;
}

其中在第二部构建查询字符串时，提供了一个queryStringSerialization block，可以自定义这个构建方法。当然如果没设置这个 block，就会使用默认的 AFHTTPRequestQueryStringDefaultStyle case，调用 AFQueryStringFromParameters()方法来构建字符串。

AFQueryStringFromParameters 方法

这一步主要是将参数用 & 连接起来，其核心方法有三个：

FOUNDATION_EXPORT NSArray * AFQueryStringPairsFromDictionary(NSDictionary *dictionary);
FOUNDATION_EXPORT NSArray * AFQueryStringPairsFromKeyAndValue(NSString *key, id value);

// 构建字符串 用&连接
NSString * AFQueryStringFromParameters(NSDictionary *parameters) {
    NSMutableArray *mutablePairs = [NSMutableArray array];
    for (AFQueryStringPair *pair in AFQueryStringPairsFromDictionary(parameters)) {
        // URLEncoded 处理
        [mutablePairs addObject:[pair URLEncodedStringValue]];
    }

    return [mutablePairs componentsJoinedByString:@"&"];
}

NSArray * AFQueryStringPairsFromDictionary(NSDictionary *dictionary) {
    return AFQueryStringPairsFromKeyAndValue(nil, dictionary);
}

NSArray * AFQueryStringPairsFromKeyAndValue(NSString *key, id value) {
    NSMutableArray *mutableQueryStringComponents = [NSMutableArray array];

    // 根据需要排列的对象的description来进行升序排列，并且selector使用的是compare:
    // 因为对象的description返回的是NSString，所以此处compare:使用的是NSString的compare函数
    // 即@[@"foo", @"bar", @"bae"] ----> @[@"bae", @"bar",@"foo"]
    NSSortDescriptor *sortDescriptor = [NSSortDescriptor sortDescriptorWithKey:@"description" ascending:YES selector:@selector(compare:)];

    // 判断 value 类型
    // 递归调用并解析
    // 因为不能保证NSDictionary的value中存放的是一个NSArray、NSSet
    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 {
        // 结束递归 最后一个 value 为 NSString
        [mutableQueryStringComponents addObject:[[AFQueryStringPair alloc] initWithField:key value:value]];
    }

    return mutableQueryStringComponents;
}

需要注意的是在 AFQueryStringPairsFromKeyAndValue() 方法中是采用递归调用解析参数类型的，直到最后一个 value 的类型为 NSString 结束递归，在此同时也将一个 AFQueryStringPair 对象添加到数组中。来看一下这个对象的结构：

@interface AFQueryStringPair : NSObject
// 为 key
@property (readwrite, nonatomic, strong) id field;
// 为 value
@property (readwrite, nonatomic, strong) id value;

- (instancetype)initWithField:(id)field value:(id)value;

- (NSString *)URLEncodedStringValue;
@end

可以看出这是个专门存放 key 和 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 转化成 key=value 这种形式。

AFURLResponseSerialization

AFURLResponseSerialization 只是个协议，其内部提供了一个方法用以序列化返回数据。

@protocol AFURLResponseSerialization <NSObject, NSSecureCoding, NSCopying>

- (nullable id)responseObjectForResponse:(nullable NSURLResponse *)response
                           data:(nullable NSData *)data
                          error:(NSError * _Nullable __autoreleasing *)error NS_SWIFT_NOTHROW;

@end

同时也要遵循 NSObject、NSSecureCoding 和 NSCopying 这三个协议，实现安全编码、拷贝等。

在 AFNetworking 内部里遵循这个协议并返回特定的数据类型有 7 种，分别是：

• AFHTTPResponseSerializer
• AFJSONResponseSerializer
• AFXMLParserResponseSerializer
• AFXMLDocumentResponseSerializer
• AFPropertyListResponseSerializer
• AFImageResponseSerializer
• AFCompoundResponseSerializer

因为 AFJSONResponseSerializer 为 AFHTTPSessionManager 创建时默认的 responseSerializer，这里以 AFJSONResponseSerializer 的相关方法为例。

responseObjectForResponse 方法

responseObjectForResponse: 方法是 AFURLResponseSerialization 协议的方法，这里以 AFJSONResponseSerializer 所实现的 responseObjectForResponse: 方法为例：

- (id)responseObjectForResponse:(NSURLResponse *)response
                           data:(NSData *)data
                          error:(NSError *__autoreleasing *)error
{
    // 验证请求的有效性
    if (![self validateResponse:(NSHTTPURLResponse *)response data:data error:error]) {
        if (!error || AFErrorOrUnderlyingErrorHasCodeInDomain(*error, NSURLErrorCannotDecodeContentData, AFURLResponseSerializationErrorDomain)) {
            return nil;
        }
    }
    // 解决一个空格引起的 bug
    id responseObject = nil;
    NSError *serializationError = nil;
    // Workaround for behavior of Rails to return a single space for `head :ok` (a workaround for a bug in Safari), which is not interpreted as valid input by NSJSONSerialization.
    // See https://github.com/rails/rails/issues/1742
    BOOL isSpace = [data isEqualToData:[NSData dataWithBytes:" " length:1]];
    // 序列化 JSON
    if (data.length > 0 && !isSpace) {
        responseObject = [NSJSONSerialization JSONObjectWithData:data options:self.readingOptions error:&serializationError];
    } else {
        return nil;
    }
    // 移除 JSON 中的 null
    if (self.removesKeysWithNullValues && responseObject) {
        responseObject = AFJSONObjectByRemovingKeysWithNullValues(responseObject, self.readingOptions);
    }
    if (error) {
        *error = AFErrorWithUnderlyingError(serializationError, *error);
    }
    return responseObject;
}

可见其核心就是序列化 JSON，将 responseObject 转化为 JSON 格式的数据。同理，在 AFHTTPResponseSerializer 中的 responseObjectForResponse: 方法就是返回原生的 HTTP 数据，如下：

- (id)responseObjectForResponse:(NSURLResponse *)response
                           data:(NSData *)data
                          error:(NSError *__autoreleasing *)error
{
    [self validateResponse:(NSHTTPURLResponse *)response data:data error:error];

    return data;
}

那么相应的剩余的都类似，区别只是 responseObjectForResponse: 方法的实现不同。

总结

AFNetworking 源码阅读笔记就记录到这里了，剩余的类都在源码注释里有注释，感兴趣的可以看看，这里就不细说了。

Reference

AFNetworking
AFNetworking 概述