多表單是什么回事？簡單地說百揭，多表單可以讓我們一次性上傳多個不同類型的文件給服務(wù)器塞俱。

MultipartFormData，這個類可以幫助我們創(chuàng)建多表單數(shù)據(jù)渣窜，然后通過請求體上傳到服務(wù)器铺根。目前有兩種方式可以編碼多表單數(shù)據(jù)：1）直接在內(nèi)存中編碼，非常高效图毕，但是數(shù)據(jù)不能太大夷都；2）先把數(shù)據(jù)寫到一個文件中，然后再進行編碼予颤，適用于視頻等文件囤官。大文件一定要使用第二種方式，否則會造成內(nèi)存不夠用的蛤虐。

一党饮、輔助類型

1. EncodingCharacters

crlf回車換行。

struct EncodingCharacters {
    static let crlf = "\r\n"
}

2. BoundaryGenerator

因為多表單上傳的是多種不同的數(shù)據(jù)驳庭，所以我們要在不同類型的文件之間添加一個邊界刑顺。而這個邊界生成器就是用來生成邊界的。

struct BoundaryGenerator {
    // 邊界類型饲常，開始/內(nèi)部/結(jié)束
    enum BoundaryType {
        case initial, encapsulated, final
    }

    // 隨機邊界蹲堂，`arc4random()`返回`UInt32`，`%08x`表示將UInt32格式化成十六進制贝淤，
    // 并取前面8位柒竞，如果不夠8位，用0代替
    static func randomBoundary() -> String {
        return String(format: "alamofire.boundary.%08x%08x", arc4random(), arc4random())
    }

    // 將String類型的邊界播聪，根據(jù)邊界的類型轉(zhuǎn)化成Data
    static func boundaryData(forBoundaryType boundaryType: BoundaryType, boundary: String) -> Data {
        let boundaryText: String

        switch boundaryType {
        case .initial:
            boundaryText = "--\(boundary)\(EncodingCharacters.crlf)"
        case .encapsulated:
            boundaryText = "\(EncodingCharacters.crlf)--\(boundary)\(EncodingCharacters.crlf)"
        case .final:
            boundaryText = "\(EncodingCharacters.crlf)--\(boundary)--\(EncodingCharacters.crlf)"
        }

        return boundaryText.data(using: String.Encoding.utf8, allowLossyConversion: false)!
    }
}

3. BodyPart

表示多表單內(nèi)部的一個表單：

class BodyPart {
    let headers: HTTPHeaders // [String: String]
    let bodyStream: InputStream // 數(shù)據(jù)輸入流
    let bodyContentLength: UInt64 // 此表單的數(shù)據(jù)大小
    var hasInitialBoundary = false // 是否包含開始邊界
    var hasFinalBoundary = false // 是否包含結(jié)束邊界

    init(headers: HTTPHeaders, bodyStream: InputStream, bodyContentLength: UInt64) {
        self.headers = headers
        self.bodyStream = bodyStream
        self.bodyContentLength = bodyContentLength
    }
}

二朽基、MultipartFormData類

1. 屬性

/// 包含邊界的`Content-Type`
open lazy var contentType: String = "multipart/form-data; boundary=\(self.boundary)"

/// 整個多表單的數(shù)據(jù)大小布隔，不包括邊界
public var contentLength: UInt64 { return bodyParts.reduce(0) { $0 + $1.bodyContentLength } }

/// 多表單的邊界
public let boundary: String

private var bodyParts: [BodyPart] // 整個多表單內(nèi)部的表單數(shù)組
private var bodyPartError: AFError? // 表單拼接過程中可能出現(xiàn)的錯誤
private let streamBufferSize: Int // 流的緩存大小，默認(rèn)是1024個字節(jié)稼虎，也就是1kb

這部分用到了一個高階函數(shù)reduce衅檀，這是一個Swift內(nèi)置的集合類型的函數(shù)，通過傳入一個closure來合并這個集合霎俩。bodyParts.reduce(0) { $0 + $1.bodyContentLength }的意思是求bodyParts數(shù)組中每個bodyPart的bodyContentLength的和哀军。他這個是一種簡寫的方式，其實完整的寫法是：

public var contentLength: UInt64 {
    return bodyParts.reduce(0, { (sum, bodyPart) -> UInt64 in
        return sum + bodyPart.bodyContentLength
    })
}

上面這種方式就容易理解多了吧茸苇。不懂的話排苍，我們再看一個簡單的例子：

let numbers = [1, 2, 3, 4]
let numberSum = numbers.reduce(0, { sum, number in
    return sum + number
})
// numberSum == 10

上面這個例子是求numbers元素的和，本質(zhì)上跟我們源碼是一個意思学密。當(dāng)numbers.reduce在運行的時候淘衙，最開始的求和結(jié)果是我們傳入的0，然后用第一個元素1放到closure運行腻暮，這時sum是0彤守，number就是第一個元素1，所以結(jié)果就是0 + 1哭靖；然后用第二個元素2放到closure運行具垫，這時sum就是上次的運算結(jié)果1，number就是第二個元素2试幽，結(jié)果就是1 + 2筝蚕；以此類推，最后結(jié)果是10铺坞。

Swift還內(nèi)置了很多類似這樣的函數(shù)起宽，例如map、flatMap济榨、filter等等坯沪，大家可以自己去了解下。

2. 初始化方法

我們看到這個self.bodyParts = []擒滑，[]數(shù)組初始化的簡寫方式腐晾，代碼更簡潔，而不需要寫成這樣[BodyPart]()丐一。在Swift開發(fā)過程中藻糖，在不失去代碼可讀性的情況下，代碼能簡潔盡量簡潔库车。關(guān)于代碼風(fēng)格問題颖御，我們可以使用Swiftlint來幫助我們，可以看看我寫的這篇文章【iOS開發(fā)】Swift代碼風(fēng)格檢查庫 —— SwiftLint。

public init() {
    self.boundary = BoundaryGenerator.randomBoundary()
    self.bodyParts = []
    self.streamBufferSize = 1024
}

3. Body Parts

// MARK: - 這三個方法可以讓我們通過傳入數(shù)據(jù)類型潘拱，然后通過流的形式把數(shù)據(jù)拼接到多表單；
// 這三個方法大同小異拧略，只是請求頭不同

public func append(_ data: Data, withName name: String) {
    let headers = contentHeaders(withName: name)
    let stream = InputStream(data: data)
    let length = UInt64(data.count)

    append(stream, withLength: length, headers: headers)
}

public func append(_ data: Data, withName name: String, mimeType: String) {
    let headers = contentHeaders(withName: name, mimeType: mimeType)
    let stream = InputStream(data: data)
    let length = UInt64(data.count)

    append(stream, withLength: length, headers: headers)
}

public func append(_ data: Data, withName name: String, fileName: String, mimeType: String) {
    let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)
    let stream = InputStream(data: data)
    let length = UInt64(data.count)

    append(stream, withLength: length, headers: headers)
}

// MARK: - 這兩個方法可以讓我們傳文件的url芦岂，然后通過流的形式把文件拼接到多表單中

public func append(_ fileURL: URL, withName name: String) {
    let fileName = fileURL.lastPathComponent
    let pathExtension = fileURL.pathExtension

    if !fileName.isEmpty && !pathExtension.isEmpty {
        let mime = mimeType(forPathExtension: pathExtension)
        append(fileURL, withName: name, fileName: fileName, mimeType: mime)
    } else {
        setBodyPartError(withReason: .bodyPartFilenameInvalid(in: fileURL))
    }
}

public func append(_ fileURL: URL, withName name: String, fileName: String, mimeType: String) {
    // 其實這個headers，不應(yīng)該放在這里定義垫蛆，而是放在這個方法里最后一行代碼上面禽最；
    // 因為這個headers只有在最后一行代碼那里才被用到，我們應(yīng)該遵循一個原則：用到的時候才創(chuàng)建袱饭。
    let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)

    //============================================================
    //                 檢查 1 - 是否是文件路徑川无？
    //============================================================

    guard fileURL.isFileURL else {
        setBodyPartError(withReason: .bodyPartURLInvalid(url: fileURL))
        return
    }

    //============================================================
    //                檢查 2 - 文件路徑能否訪問?
    //============================================================

    do {
        let isReachable = try fileURL.checkPromisedItemIsReachable()
        guard isReachable else {
            setBodyPartError(withReason: .bodyPartFileNotReachable(at: fileURL))
            return
        }
    } catch {
        setBodyPartError(withReason: .bodyPartFileNotReachableWithError(atURL: fileURL, error: error))
        return
    }

    //============================================================
    //             檢查 3 - 文件路徑是否是一個文件夾？
    //============================================================

    var isDirectory: ObjCBool = false
    let path = fileURL.path

    guard FileManager.default.fileExists(atPath: path, isDirectory: &isDirectory) && !isDirectory.boolValue else {
        setBodyPartError(withReason: .bodyPartFileIsDirectory(at: fileURL))
        return
    }

    //============================================================
    //               檢查 4 - 是否能獲得文件的大小?
    //============================================================

    let bodyContentLength: UInt64

    do {
        guard let fileSize = try FileManager.default.attributesOfItem(atPath: path)[.size] as? NSNumber else {
            setBodyPartError(withReason: .bodyPartFileSizeNotAvailable(at: fileURL))
            return
        }

        bodyContentLength = fileSize.uint64Value
    }
    catch {
        setBodyPartError(withReason: .bodyPartFileSizeQueryFailedWithError(forURL: fileURL, error: error))
        return
    }

    //============================================================
    //          檢查 5 - 是否能通過文件路徑創(chuàng)建一個流?
    //============================================================

    guard let stream = InputStream(url: fileURL) else {
        setBodyPartError(withReason: .bodyPartInputStreamCreationFailed(for: fileURL))
        return
    }

    append(stream, withLength: bodyContentLength, headers: headers)
}


// MARK: - 這兩個方法可以讓我們傳一個流虑乖，然后拼接到多表單中

public func append(
    _ stream: InputStream,
    withLength length: UInt64,
    name: String,
    fileName: String,
    mimeType: String)
{
    let headers = contentHeaders(withName: name, fileName: fileName, mimeType: mimeType)
    append(stream, withLength: length, headers: headers)
}

public func append(_ stream: InputStream, withLength length: UInt64, headers: HTTPHeaders) {
    let bodyPart = BodyPart(headers: headers, bodyStream: stream, bodyContentLength: length)
    bodyParts.append(bodyPart)
}

// MARK: - 數(shù)據(jù)編碼

// 一次性把所有body parts編碼到一個Data中懦趋，只適用于小文件；
// 對于大文件疹味，應(yīng)該使用 `writeEncodedData(to:)`
public func encode() throws -> Data {
}

// 把數(shù)據(jù)寫到一個文件中仅叫，適用于大文件
public func writeEncodedData(to fileURL: URL) throws {
    if let bodyPartError = bodyPartError {
        throw bodyPartError
    }

    if FileManager.default.fileExists(atPath: fileURL.path) {
        throw AFError.multipartEncodingFailed(reason: .outputStreamFileAlreadyExists(at: fileURL))
    } else if !fileURL.isFileURL {
        throw AFError.multipartEncodingFailed(reason: .outputStreamURLInvalid(url: fileURL))
    }

    guard let outputStream = OutputStream(url: fileURL, append: false) else {
        throw AFError.multipartEncodingFailed(reason: .outputStreamCreationFailed(for: fileURL))
    }

    // 打開了一個流，用完之后必須關(guān)閉
    // 很好地利用了Swift的defer特性糙捺，把打開和關(guān)閉寫在一起
    outputStream.open()
    defer { outputStream.close() }

    self.bodyParts.first?.hasInitialBoundary = true
    self.bodyParts.last?.hasFinalBoundary = true

    for bodyPart in self.bodyParts {
        try write(bodyPart, to: outputStream)
    }
}

// MARK: - 私有的Body Part相關(guān)方法（不對外暴露的方法诫咱，我們應(yīng)該加上private）

// 編碼Body Part
private func encode(_ bodyPart: BodyPart) throws -> Data {
    var encoded = Data()

    let initialData = bodyPart.hasInitialBoundary ? initialBoundaryData() : encapsulatedBoundaryData()
    encoded.append(initialData)

    let headerData = encodeHeaders(for: bodyPart)
    encoded.append(headerData)

    let bodyStreamData = try encodeBodyStream(for: bodyPart)
    encoded.append(bodyStreamData)

    if bodyPart.hasFinalBoundary {
        encoded.append(finalBoundaryData())
    }

    return encoded
}

// 編碼Header
private func encodeHeaders(for bodyPart: BodyPart) -> Data {
    var headerText = ""

    for (key, value) in bodyPart.headers {
        headerText += "\(key): \(value)\(EncodingCharacters.crlf)"
    }
    headerText += EncodingCharacters.crlf

    return headerText.data(using: String.Encoding.utf8, allowLossyConversion: false)!
}

// 編碼body stream
private func encodeBodyStream(for bodyPart: BodyPart) throws -> Data {
    let inputStream = bodyPart.bodyStream
    inputStream.open()
    defer { inputStream.close() }

    var encoded = Data()

    while inputStream.hasBytesAvailable {
        var buffer = [UInt8](repeating: 0, count: streamBufferSize)
        let bytesRead = inputStream.read(&buffer, maxLength: streamBufferSize)

        if let error = inputStream.streamError {
            throw AFError.multipartEncodingFailed(reason: .inputStreamReadFailed(error: error))
        }

        if bytesRead > 0 {
            encoded.append(buffer, count: bytesRead)
        } else {
            break
        }
    }

    return encoded
}

// MARK: - 把Body Part寫入到OutputStream的相關(guān)方法

private func write(_ bodyPart: BodyPart, to outputStream: OutputStream) throws {
    try writeInitialBoundaryData(for: bodyPart, to: outputStream)
    try writeHeaderData(for: bodyPart, to: outputStream)
    try writeBodyStream(for: bodyPart, to: outputStream)
    try writeFinalBoundaryData(for: bodyPart, to: outputStream)
}

private func writeInitialBoundaryData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
    let initialData = bodyPart.hasInitialBoundary ? initialBoundaryData() : encapsulatedBoundaryData()
    return try write(initialData, to: outputStream)
}

private func writeHeaderData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
    let headerData = encodeHeaders(for: bodyPart)
    return try write(headerData, to: outputStream)
}

private func writeBodyStream(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
    let inputStream = bodyPart.bodyStream

    inputStream.open()
    defer { inputStream.close() }

    while inputStream.hasBytesAvailable {
        var buffer = [UInt8](repeating: 0, count: streamBufferSize)
        let bytesRead = inputStream.read(&buffer, maxLength: streamBufferSize)

        if let streamError = inputStream.streamError {
            throw AFError.multipartEncodingFailed(reason: .inputStreamReadFailed(error: streamError))
        }

        if bytesRead > 0 {
            if buffer.count != bytesRead {
                buffer = Array(buffer[0..<bytesRead])
            }

            try write(&buffer, to: outputStream)
        } else {
            break
        }
    }
}

private func writeFinalBoundaryData(for bodyPart: BodyPart, to outputStream: OutputStream) throws {
    if bodyPart.hasFinalBoundary {
        return try write(finalBoundaryData(), to: outputStream)
    }
}

// MARK: - 把已經(jīng)緩存的數(shù)據(jù)寫入到OutputStream的相關(guān)方法

private func write(_ data: Data, to outputStream: OutputStream) throws {
    var buffer = [UInt8](repeating: 0, count: data.count)
    data.copyBytes(to: &buffer, count: data.count)

    return try write(&buffer, to: outputStream)
}

private func write(_ buffer: inout [UInt8], to outputStream: OutputStream) throws {
    var bytesToWrite = buffer.count

    while bytesToWrite > 0, outputStream.hasSpaceAvailable {
        let bytesWritten = outputStream.write(buffer, maxLength: bytesToWrite)

        if let error = outputStream.streamError {
            throw AFError.multipartEncodingFailed(reason: .outputStreamWriteFailed(error: error))
        }

        bytesToWrite -= bytesWritten

        if bytesToWrite > 0 {
            buffer = Array(buffer[bytesWritten..<buffer.count])
        }
    }
}

// MARK: - 根據(jù)文件的擴展名獲取Mime Type

private func mimeType(forPathExtension pathExtension: String) -> String {
    if
        let id = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as CFString, nil)?.takeRetainedValue(),
        let contentType = UTTypeCopyPreferredTagWithClass(id, kUTTagClassMIMEType)?.takeRetainedValue()
    {
        return contentType as String
    }

    return "application/octet-stream"
}

// MARK: - 生成Content Headers

private func contentHeaders(withName name: String, fileName: String? = nil, mimeType: String? = nil) -> [String: String] {
    var disposition = "form-data; name=\"\(name)\""
    if let fileName = fileName { disposition += "; filename=\"\(fileName)\"" }

    var headers = ["Content-Disposition": disposition]
    if let mimeType = mimeType { headers["Content-Type"] = mimeType }

    return headers
}

// MARK: - 把邊界編碼為數(shù)據(jù)

private func initialBoundaryData() -> Data {
    return BoundaryGenerator.boundaryData(forBoundaryType: .initial, boundary: boundary)
}

private func encapsulatedBoundaryData() -> Data {
    return BoundaryGenerator.boundaryData(forBoundaryType: .encapsulated, boundary: boundary)
}

private func finalBoundaryData() -> Data {
    return BoundaryGenerator.boundaryData(forBoundaryType: .final, boundary: boundary)
}

// MARK: - 設(shè)置bodyPartError

private func setBodyPartError(withReason reason: AFError.MultipartEncodingFailureReason) {
    guard bodyPartError == nil else { return }
    bodyPartError = AFError.multipartEncodingFailed(reason: reason)
}

在這一部分中，重點提一下Swift的defer特性洪灯。對于某些操作坎缭，需要放到一個作用域內(nèi)最后面、并且必須要執(zhí)行的代碼签钩，我們可以用defer掏呼。例如上面的例子，打開了一個流边臼，用完之后必須關(guān)閉哄尔，所以用defer把關(guān)閉代碼封裝起來，并且跟打開操作放在一起柠并，這樣可以很有效的減少漏寫的幾率岭接。不管后面的代碼發(fā)生了什么，defer里面的代碼總會在最后一行代碼執(zhí)行完成后執(zhí)行臼予。

有任何問題鸣戴，歡迎大家留言！

歡迎加入我管理的Swift開發(fā)群：536353151粘拾，本群只討論Swift相關(guān)內(nèi)容窄锅。

原創(chuàng)文章，轉(zhuǎn)載請注明出處缰雇。謝謝入偷！