Alamofire从源码浅析2种不符合实际需求的参数格式总结

目前公司的Swift项目网络请求使用的是第三方开源库Alamofire，在使用的过程中有遇到过2种参数格式无法正确传递到后端的情况；

1）参数包含空数组

直接会被过滤删除掉

2）参数包含二维数组

会把二维数组转换为一维数组

下面将结合Alamofire参数编码部分的源码来一步一步的分析为啥不满足这2种参数格式。

1、首先看下实际结果

这里有必要先说下测试接口使用 httpbin.org来进行测试的好处；因为它在被调用后可以返回服务端所接收到的所有参数；在我们这里仅仅调试参数，所以比使用抓包工具要更方便一些，可以直接查看print的结果。

1）发起一个网络请求

// GET请求

AF.request("http://httpbin.org/get", method: .get, parameters: ["name": "kang", "score": 90, "nulllArr": [], "twoDArr": [["1","2"],["3","4"]]]).responseJSON { (response) in
    switch response.result {
    case .success(let value):
        print(value)
    case .failure(let error):
        print(error)
    }
}

输出结果：

{
    args =     {
        name = kang;
        score = 90;
        "twoDArr[][]" =         (
            1,
            2,
            3,
            4
        );
    };
    headers =     {
        Accept = "*/*";
        "Accept-Encoding" = "br;q=1.0, gzip;q=0.9, deflate;q=0.8";
        "Accept-Language" = "en;q=1.0";
        Host = "httpbin.org";
        "User-Agent" = "Test/1.0 ( build:1; iOS 14.0.0) Alamofire/5.2.2";
        "X-Amzn-Trace-Id" = "Root=1-5f8d57cd-039301d94fe8ad1d6311287c";
    };
    origin = "";
    url = "http://httpbin.org/get?name=kang&score=90&twoDArr[][]=1&twoDArr[][]=2&twoDArr[][]=3&twoDArr[][]=4";
}

// POST请求

AF.request("http://httpbin.org/post", method: .post, parameters: ["name": "kang", "score": 90, "nulllArr": [], "twoDArr": [["1","2"],["3","4"]]]).responseJSON { (response) in
    switch response.result {
    case .success(let value):
        print(value)
    case .failure(let error):
        print(error)
    }
}

输出结果：

{
    args =     {
    };
    data = "";
    files =     {
    };
    form =     {
        name = kang;
        score = 90;
        "twoDArr[][]" =         (
            1,
            2,
            3,
            4
        );
    };
    headers =     {
        Accept = "*/*";
        "Accept-Encoding" = "br;q=1.0, gzip;q=0.9, deflate;q=0.8";
        "Accept-Language" = "en;q=1.0";
        "Content-Length" = 106;
        "Content-Type" = "application/x-www-form-urlencoded; charset=utf-8";
        Host = "httpbin.org";
        "User-Agent" = "Test/1.0 (; build:1; iOS 14.0.0) Alamofire/5.2.2";
        "X-Amzn-Trace-Id" = "Root=1-5f8e5cd1-5aa70b642cee70930c0eedd7";
    };
    json = "";
    origin = "";
    url = "https://httpbin.org/post";
}

可以看到无论是GET还是POST，空数组被过滤掉了，以及二维数组变成了一维数组

2）通过抓包工具Charles验证

// GET请求抓包

// POST请求抓包

可以看到请求的参数以及接口返回的参数和上面print的结果是一样的：空数组nullArr不见了，二维数组twoDArr被转换成了一维数组。这和我们定义参数格式初衷不一样了，需要和后台的同事重新沟通定义参数格式。

2、源码调试分析

宿主工程目前是通过Pod管理第三方依赖库，并且Xcode12已经支持在同一个workspace下不同project之间进行断点调试。

前面的func调用不用看，我们直接看参数处理的部分：

ParameterEncoding.swift -> URLEncoding

// MARK: Encoding

public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
    var urlRequest = try urlRequest.asURLRequest()

    guard let parameters = parameters else { return urlRequest }
    
    // 根据请求方法不同判断处理参数是放在url后面还是body
    if let method = urlRequest.method, destination.encodesParametersInURL(for: method) {
        guard let url = urlRequest.url else {
            throw AFError.parameterEncodingFailed(reason: .missingURL)
        }

        if var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false), !parameters.isEmpty {
            let percentEncodedQuery = (urlComponents.percentEncodedQuery.map { $0 + "&" } ?? "") + query(parameters)
            urlComponents.percentEncodedQuery = percentEncodedQuery
            urlRequest.url = urlComponents.url
        }
    } else {
        if urlRequest.value(forHTTPHeaderField: "Content-Type") == nil {
            urlRequest.setValue("application/x-www-form-urlencoded; charset=utf-8", forHTTPHeaderField: "Content-Type")
        }

        urlRequest.httpBody = Data(query(parameters).utf8)
    }

    return urlRequest
}

从上面源码可以看到，无论哪种请求方式都有调用到 query(parameters) 处理参数

处理参数的核心代码就是以下3个方法

private func query(_ parameters: [String: Any]) -> String {
    // 创建一个数组，参数类型是2个字符串的元组类型，用于分别存储key、value
    var components: [(String, String)] = []

    // 将参数key按照字母正序的方式排序，然后遍历每个key
    for key in parameters.keys.sorted(by: <) {
        let value = parameters[key]!
        // 根据value类型具体处理参数
        components += queryComponents(fromKey: key, value: value)
    }
    // 按照key1=value1&key2=value2的格式拼接返回参数字符串
    return components.map { "\($0)=\($1)" }.joined(separator: "&")
}

// 递归遍历参数的每一层，将其展开为一维
public func queryComponents(fromKey key: String, value: Any) -> [(String, String)] {
    // 创建一个数组，参数类型是2个字符串的元组类型，用于分别存储key、value
    var components: [(String, String)] = []
    // 根据参数字典中的value类型是字典、数组、整型、布尔分别处理
    switch value {
    case let dictionary as [String: Any]:
        for (nestedKey, value) in dictionary {
            components += queryComponents(fromKey: "\(key)[\(nestedKey)]", value: value)
        }
    case let array as [Any]:
        for value in array {
            components += queryComponents(fromKey: arrayEncoding.encode(key: key), value: value)
        }
    case let number as NSNumber:
        if number.isBool {
            components.append((escape(key), escape(boolEncoding.encode(value: number.boolValue))))
        } else {
            components.append((escape(key), escape("\(number)")))
        }
    case let bool as Bool:
        components.append((escape(key), escape(boolEncoding.encode(value: bool))))
    default:
        components.append((escape(key), escape("\(value)")))
    }
    return components
}

// 对特殊字符进行URL编码
public func escape(_ string: String) -> String {
    string.addingPercentEncoding(withAllowedCharacters: .afURLQueryAllowed) ?? string
}

1）对于我们测试参数，空数组"nulllArr": []

由于是一个空数组，里面没有任何参数，所以在方法queryComponents遍历后就直接返回一个空数组var components: [(String, String)] = [] 给 components += queryComponents(fromKey: key, value: value)，而这里数组的拼接必须是有元素才可以的，空数组是不会加过去的。

这里我们可以看看数组Array定义的 += 方法：

@frozen public struct Array {
   @inlinable public static func += (lhs: inout [Element], rhs: [Element])
}

在 https://swift.org/ 查看Swift源码stdlib--public--core--Array.swift可以看到

extension Array {
  @inlinable
  public static func += (lhs: inout Array, rhs: Array) {
    lhs.append(contentsOf: rhs)
  }
}

@inlinable
  @_semantics("array.append_element")
  public mutating func append(_ newElement: __owned Element) {
    _makeUniqueAndReserveCapacityIfNotUnique()
    let oldCount = _getCount()
    _reserveCapacityAssumingUniqueBuffer(oldCount: oldCount)
    _appendElementAssumeUniqueAndCapacity(oldCount, newElement: newElement)
  }

当rhs右边的数组有元素的时候数组buffer缓存才会加；这里说得有点偏了，如果感兴趣可以去仔细看看这个方法的具体实现。

2）对于二维数组："twoDArr": [["1","2"],["3","4"]]]

由于是二维，所以在执行方法queryComponents的时候会递归调用，将里面的元素全部展开变成了一维数组，"twoDArr [] [] ": ["1","2","3","4"]，对于key后面有2个中括号，这个是可以通过Alamofire下面代码进行控制的，默认情况下是带中括号的

public init(destination: Destination = .methodDependent,
            arrayEncoding: ArrayEncoding = .brackets,
            boolEncoding: BoolEncoding = .numeric) {
    self.destination = destination
    self.arrayEncoding = arrayEncoding
    self.boolEncoding = boolEncoding
}

public enum ArrayEncoding {
    case brackets
    case noBrackets

    func encode(key: String) -> String {
        switch self {
        case .brackets:
            return "\(key)[]"
        case .noBrackets:
            return key
        }
    }
}

由于我们这里是二维数组，所以方法queryComponents递归调用了2次，所以有2个中括号，也间接说明参数是一个二维数组参数。

总结

从实际参数请求结果到一步一步分析第三方库源码，我们找到了导致这个结果的具体原因。Alamofire参数处理有字典、数组、整型、布尔等，在本文中只是对空数组、二维数组进行了验证，其它类型原理是一样的，可以得出使用Alamofire发起网络请求：

1）参数中如果有空字典、空数组都会被过滤掉；

2）如果有字典、数组嵌套的情况，都会被一层层展开成一维；

3）参数key是按照字母正序进行排序的，如果某些接口对参数的顺序也有要求可以在key之前加入正序的字母。

在github上面，Alamofire/issues也有人遇到过类似本文参数的问题，参考官方评论使用Encodable类型而不用 Parameters 字典，经过验证还是存在这种参数格式问题，具体可以参看源码ParameterEncoder.swift去进行调试。