前言

Alamofire 是 Swift 语言的 HTTP 网络开发工具包，相当于 Swift 实现 AFNetworking 版本。当然，AFNetworking 非常稳定，在 Mac OSX 与 iOS 中也能像其他 Objective-C 代码一样用 Swift 编写。不过 Alamofire 更适合 Swift 语言风格习惯（Alamofire 与 AFNetworking 可以共存一个项目中，互不影响）。Alamofire 取名来源于 Alamo Fire flower。
Alamofire 的核心主要是试图简化 iOS 中 HTTP 网络连接，它通过使用 NSURLSession 以及 Foundation URL Loading System 来创建一个 Swift 本地的网络访问接口，从而实现令人难以置信效率的任务。

1、Alamofire

Alamofire 功能：
- Chainable Request / Response methods
- URL / JSON / plist Parameter Encoding
- Upload File / Data / Stream
- Download using Request or Resume data
- Authentication with NSURLCredential
- Progress Closure & NSProgress
- cURL Debug Output

Alamofire 系统需求：

Alamofire Version	Minimum iOS Target	Target Notes
3.4.x	iOS 8.0+	Xcode 7.3+ is required.
3.1.4 -> 3.3.1	iOS 8.0+	Xcode 7.2+ is required.
3.1.0 -> 3.1.3	iOS 8.0+	Xcode 7.1+ is required.
2.0.0 -> 3.0.1	iOS 8.0+	Xcode 7.0+ is required.
1.3.0 -> 1.3.1	iOS 7.0+	Xcode 6.4 is required.
1.2.1 -> 1.2.3	iOS 7.0+	Xcode 6.3 is required.
1.1.0 -> 1.2.0	iOS 7.0+	Xcode 6.1 is required.
1.0.0 -> 1.0.1	iOS 7.0+	Xcode 6.0 is required. For Xcode 6.1, use the xcode-6.1 branch.

Alamofire 有许多让程序猿信服去使用它的理由。在 iOS 开发中，使用 NURLSession 是 HTTP 网络的未来趋势, 相比 NSURLConnection 来说，它的功能更加丰富：
- 后台上传和下载
- 暂停以及重新开始网络操作的能力
- 可配置的容器(Container)
- 子类和私有存储
- 改进的认证处理
- 对每个基础连接进行身份验证
- 多种代理模式 -- NSURLConnection 拥有异步代码块的基本方法, 但是不能用它们的代理，NSURLSession 具有一种混合型的方法。
对 AFNetworking 能做而 Alamofire 不能做的有以下几点：
- UIKit 扩展
- TLS 验证
- NSOperation/NSURLConnection/AFURLConnectionOperation 调用
- 多重 HTTP 网络请求构架

2、Alamofire 的添加

Github 网址：https://github.com/Alamofire/Alamofire
Alamofire 使用 ARC

Swift

    // 将第三方库文件复制到工程目录下
    Alamofire       

    // 将第三方库文件中的 xcodeproj 添加到工程中
    Alamofire.xcodeproj

    // 在 TARGETS -> General -> Embedded Binaries 下添加静态库文件(添加上边的)
    Alamofire.framework

    // 添加头文件
    import Alamofire

3、Alamofire 的设置

Swift

请求超时时间设置

    // 必须设置为全局的
    var alamofireManager: Manager!

    let config = NSURLSessionConfiguration.defaultSessionConfiguration()
    config.timeoutIntervalForRequest = 5     // 秒

    self.alamofireManager = Manager(configuration: config)
    self.alamofireManager.request(.GET, "http://120.25.226.186:32812/video?type=JSON")

HTTP 方法（Medthods）

    Alamofire.Method enum 列表出在 RFC 2616 中定义的 HTTP 方法：

        public enum Method: String {

            case OPTIONS = "OPTIONS"
            case GET = "GET"
            case HEAD = "HEAD"
            case POST = "POST"
            case PUT = "PUT"
            case PATCH = "PATCH"
            case DELETE = "DELETE"
            case TRACE = "TRACE"
            case CONNECT = "CONNECT"
        }

    这些值可以作为 Alamofire.request 请求的第一个参数。

    Alamofire.request(.POST, "https://httpbin.org/post")

    Alamofire.request(.PUT, "https://httpbin.org/put")

    Alamofire.request(.DELETE, "https://httpbin.org/delete")

请求参数编码方式设置

    Alamofire 使用 Alamofire.ParameterEncoding 可以支持 URL query/URI form，JSON，PropertyList 方式编码参数。

    enum ParameterEncoding {

        case URL
        case URLEncodedInURL
        case JSON
        case PropertyList(NSPropertyListFormat, NSPropertyListWriteOptions)
        case Custom((URLRequestConvertible, [String : AnyObject]?) -> (NSMutableURLRequest, NSError?))

        public func encode(URLRequest: URLRequestConvertible, parameters: [String : AnyObject]?) -> (NSMutableURLRequest, NSError?)
        public func queryComponents(key: String, _ value: AnyObject) -> [(String, String)]
        public func escape(string: String) -> String
    }

    // URL 形式参数编码

        // 发送以下 HttpBody 内容: foo=bar&baz[]=a&baz[]=1&qux[x]=1&qux[y]=2&qux[z]=3

        let urlStr:URLStringConvertible = "https://httpbin.org/post"
        let parameters:[String: AnyObject]? = ["foo":"bar", "baz":["a", 1], "qux":["x":1, "y":2, "z":3]]

        Alamofire.request(.POST, urlStr, parameters: parameters)        // 默认编码方式是 URL

        Alamofire.request(.POST, urlStr, parameters: parameters, encoding: .URL)

    // JSON 形式参数编码

        // 发送以下 HttpBody 内容: {"foo":"bar", "baz":["a", 1], "qux":{"x":1, "y":2, "z":3}}

        let urlStr:URLStringConvertible = "https://httpbin.org/post"
        let parameters:[String: AnyObject]? = ["foo":"bar", "baz":["a", 1], "qux":["x":1, "y":2, "z":3]]

        Alamofire.request(.POST, urlStr, parameters: parameters, encoding:.JSON)                        

    // URLRequest 请求编码

        let url = NSURL(string: "https://httpbin.org/get")!
        var urlRequest = NSMutableURLRequest(URL: url)

        let param = ["foo": "bar"]
        let encoding = Alamofire.ParameterEncoding.URL

        (urlRequest, _) = encoding.encode(urlRequest, parameters: param)

请求头设置

    let headers = ["User-Agent":"iPhone 6s Plus"]

    Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON", headers: headers)

    // 不设置时为默认值
    Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

请求数据响应格式设置

    Built-in Response Methods：

        response()
        responseData()
        responseString(encoding:NSStringEncoding)
        responseJSON(options:NSJSONReadingOptions)
        responsePropertyList(options:NSPropertyListReadOptions)

    可以同时响应多种格式数据。

    // 响应 NSData 格式数据

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

            .response { (request:NSURLRequest?, response:NSHTTPURLResponse?, responseData:NSData?, error:NSError?) in

                /*
                    网络请求结束，成功时 error == nil。请求返回的数据存在 responseData 中，为 NSData 格式。
                */  
            }

    // 响应 String 格式数据

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

            .responseString { (response:Response<String, NSError>) in

                /*
                        网络请求结束，成功时 response.result.error == nil。请求返回的数据存在 response.result.value 中，为 String 格式。
                    或者成功时 response.result 的值为 .Success，失败时 response.result 的值为 .Failure。
                */  

                response.request     // original URL request
                response.response    // URL response
                response.data        // server data
                response.result      // result of response serialization

                // 获取并判断结果值

                if let string = response.result.value {

                } else {

                }

                // 判断结果值

                if response.result.error == nil {

                } else {

                }

                // 判断结果值

                switch response.result {

                    case.Success(let value):
                    case.Failure(let error):
                }
            }

    // 响应 JSON 格式数据

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

            .responseJSON { (response:Response<AnyObject, NSError>) in

                /*
                    网络请求结束，成功时 response.result.error == nil。请求返回的数据存在 response.result.value 中，为 JSON 格式。
                    或者成功时 response.result 的值为 .Success，失败时 response.result 的值为 .Failure。
                */  
            }

    // 响应 PList 格式数据

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

            .responsePropertyList { (response:Response<AnyObject, NSError>) in

                /*
                    网络请求结束，成功时 response.result.error == nil。请求返回的数据存在 response.result.value 中，为 PList 格式。
                    或者成功时 response.result 的值为 .Success，失败时 response.result 的值为 .Failure。
                */  
            }

    // 响应 多种格式 数据

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

            // 参数不使用时可以省略
            .response { (_, _, responseData:NSData?, error:NSError?) in

            }

            .responseJSON { (response:Response<AnyObject, NSError>) in

            }

Request 请求创建方式

    // Manager 方式

        // 必须设置为全局的
        var alamofireManager: Manager!

        self.alamofireManager = Manager(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

        self.alamofireManager.request(.GET, "http://120.25.226.186:32812/video?type=JSON")

    // Alamofire 方式，接收返回值

        let request = Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

    // 不接收返回值，request 不带参数

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

    // request 带参数

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video", parameters: ["type": "JSON"])

    // request 带参数及参数编码方式

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video", parameters: ["type": "JSON"], encoding: .URL)

    // request 带参数及请求头

        Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video", parameters: ["type": "JSON"], 
                                                                               encoding: .URL, 
                                                                                headers: ["User-Agent":"iPhone 6s"])

请求任务创建方式

    // 数据请求 request (GET/POST)

        // Alamofire GET 方式

            let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video?type=XML"

            Alamofire.request(.GET, urlStr)

        // Alamofire POST 方式

            let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video"

            Alamofire.request(.GET, urlStr, parameters: ["type": "XML"])

        // Manager GET 方式

            // 必须设置为全局的
            var alamofireManager: Manager!

            let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video?type=XML"

            self.alamofireManager = Manager(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

            self.alamofireManager.request(.GET, urlStr)

        // Manager POST 方式

            // 必须设置为全局的
            var alamofireManager: Manager!

            let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video"

            self.alamofireManager = Manager(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

            self.alamofireManager.request(.GET, urlStr, parameters: ["type": "XML"])

    // 文件下载 download

        // 指定文件路径方式

            Alamofire.download(.GET, "http://120.25.226.186:32812/resources/videos/minion_01.mp4") 
                      { (temporaryURL:NSURL, response:NSHTTPURLResponse) -> NSURL in

                /*
                        设置文件下载路径，temporaryURL 是沙盒下的文件临时存储路径，下载完成后会被自动删除。response.suggestedFilename 
                    为服务器端文件名。此 block 在子线程中执行。
                */

                return documentsDirUrl
            }

                .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                    /*
                        监听文件下载进度，此 block 在子线程中执行。
                    */
                }

                .response { (_, _, _, error:NSError?) in

                    /*
                        网络请求结束，成功时 error == nil。在 Swift 中文件已经存在时，再次相同路径写入会失败。
                    */
                }

        // 使用默认提供的下载路径方式

            Alamofire.download(.GET, "http://120.25.226.186:32812/resources/videos/minion_01.mp4", destination: destination)

                .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                    /*
                        监听文件下载进度，此 block 在子线程中执行。
                    */
                }

                .response { (_, _, _, error:NSError?) in

                    /*
                        网络请求结束，成功时 error == nil。在 Swift 中文件已经存在时，再次相同路径写入会失败。
                    */
                }

        // 断点续传下载方式

            let downloadRequest:Request = Alamofire.download(resumeData: resumeData, 
                                                            destination: { (temporaryURL:NSURL, 
                                                                                response:NSHTTPURLResponse) -> NSURL in

                /*
                        设置文件下载路径，temporaryURL 是沙盒下的文件临时存储路径，下载完成后会被自动删除。response.suggestedFilename 
                    为服务器端文件名。此 block 在子线程中执行。
                */

                return documentsDirUrl
            })

                .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                    /*
                        监听文件下载进度，此 block 在子线程中执行。
                    */
                }

                .response { (_, _, data:NSData?, error:NSError?) in

                    /*
                        网络请求结束，成功时 error == nil。在 Swift 中文件已经存在时，再次相同路径写入会失败。
                    */
                }

    // 文件上传 upload

        // Data 形式上传

            Alamofire.upload(.POST, "http://192.168.88.200:8080/MJServer/upload", headers: headers, data: formBody)

                .progress { (bytesLoad:Int64, totalBytesLoad:Int64, totalBytesExpectedToLoad:Int64) in

                    /*
                        监听文件上传进度，此 block 在子线程中执行。
                    */
                }

                .response { (_, _, responseData:NSData?, error:NSError?) in

                    /*
                        网络请求结束。
                    */
                }

        // MultipartFormData 形式上传

            Alamofire.upload(.POST, "http://192.168.88.200:8080/MJServer/upload", 
                                     multipartFormData: { (formData:MultipartFormData) in

                /*
                    添加参数。第一个参数是需要添加的参数内容值，第二个是后台规定的参数名。
                    设置上传的文件。第一个参数是需要上传的文件路径，第二个是后台规定的参数名，第三个是上传后服务器端文件名称，第四个是文件类型。
                */

            }) { (encodingResult:Manager.MultipartFormDataEncodingResult) in

                /*
                    数据编码完成。
                */

                switch encodingResult {

                // 编码成功
                case .Success(let uploadRequest, _, _):                                                                 

                    uploadRequest

                        .progress { (bytesLoad:Int64, totalBytesLoad:Int64, totalBytesExpectedToLoad:Int64) in

                            /*
                                监听文件上传进度，此 block 在子线程中执行。
                            */
                        }

                        .response { (_, _, responseData:NSData?, error:NSError?) in

                            /*
                                网络请求结束。
                            */
                        }

                // 编码失败
                case .Failure(let error):                                                                               

                    print(error)
                }
            }

请求任务设置

    // 继续请求任务
    downloadRequest.resume()

    // 暂停请求任务
    downloadRequest.suspend()

    // 取消请求任务
    downloadRequest.cancel()

文件下载设置

    // 设置文件下载路径

        let documentsDirUrl:NSURL = NSFileManager.defaultManager()
                                                 .URLsForDirectory( .DocumentDirectory, inDomains: .UserDomainMask)[0]
                                                 .URLByAppendingPathComponent(response.suggestedFilename!)

        if NSFileManager.defaultManager().fileExistsAtPath(documentsDirUrl.path!) {

            // 移除已经存在的文件，在 Swift 中文件已经存在时，再次相同路径写入会失败
            try! NSFileManager.defaultManager().removeItemAtURL(documentsDirUrl)
        }

    // 设置文件默认下载路径

        let destination = Alamofire.Request.suggestedDownloadDestination(directory: .DocumentDirectory, domain: .UserDomainMask)

    // 监听文件下载进度

        bytesWrite                  // 本次写入的大小
        totalBytesWrite             // 已经写入的大小
        totalBytesExpectedToWrite   // 总大小

        // 设置下载进度条
        let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesWrite)/Double(totalBytesExpectedToWrite)))
        self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), withObject: progressNum, waitUntilDone: true)

文件上传设置

    // Data 形式上传

        let boundary = "myBoundary"

        // 设置请求头
        /*
            upload task 不会在请求头里添加 content-type (上传数据类型)字段，@"myBoundary" 为请求体边界，参数可以随便设置，但需一致
        */
        let headers = ["Content-Type":"multipart/form-data; charset=utf-8; boundary=\(boundary)"]

        // 设置请求文件参数

            let formBody = NSMutableData()

            // 参数开始分割线
            /*
                每个参数开始前都需要加
            */
            formBody.appendData("--\(boundary)".dataUsingEncoding(NSUTF8StringEncoding)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // 参数
            formBody.appendData("Content-Disposition: form-data; name=\"\("username")\"\r\n\r\n\("jhq")"
                    .dataUsingEncoding(NSUTF8StringEncoding)!)

            // username 是后台规定的参数名，jhq 是需要添加的参数内容值
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // 文件开始分割线
            /*
                每个文件开始前都需要加
            */
            formBody.appendData("--\(boundary)".dataUsingEncoding(NSUTF8StringEncoding)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // 文件参数名
            formBody.appendData("Content-Disposition: form-data; name=\"\("file")\"; filename=\"\("test.mp4")\""
                    .dataUsingEncoding(NSUTF8StringEncoding)!)

            // file 是后台规定的参数名，test.mp4 为上传后服务器端文件名称
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)                            

            // 文件的类型
            formBody.appendData("Content-Type: mp4".dataUsingEncoding(NSUTF8StringEncoding)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // 待上传文件数据
            /*
                本地待上传的文件路径
            */
            formBody.appendData(NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("minion", ofType: "mp4")!)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // 结束分割线标记
            formBody.appendData("--\(boundary)--".dataUsingEncoding(NSUTF8StringEncoding)!)
            formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

    // 指定文件路径形式上传
    /*
        public func appendBodyPart(fileURL fileURL: NSURL, name: String, fileName: String, mimeType: String);

        第一个参数是需要上传的文件路径，第二个是后台规定的参数名，第三个是上传后服务器端文件名称，第四个是文件类型。
    */
    let fileUrl = NSBundle.mainBundle().URLForResource("HQ_0005", withExtension: "jpg")!
    formData.appendBodyPart(fileURL: fileUrl, name: "file", fileName: "test.png", mimeType: "image/jpeg")

    // 指定文件数据形式上传
    /*
        public func appendBodyPart(data data: NSData, name: String, fileName: String, mimeType: String);

        第一个参数是需要上传的文件数据，第二个是后台规定的参数名，第三个是上传后服务器端文件名称，第四个是文件类型。
    */
    let fileData = NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("minion", ofType: "mp4")!)
    formData.appendBodyPart(data: fileData!, name: "file", fileName: "test.mp4", mimeType: "mp4")

    // 添加参数
    /*
        public func appendBodyPart(data data: NSData, name: String);

        第一个参数是需要添加的参数内容值，第二个是后台规定的参数名。
    */
    formData.appendBodyPart(data: "jhq".dataUsingEncoding(NSUTF8StringEncoding)!, name: "username")

    // 监听文件上传进度

    bytesLoad                   // 本次写入的大小
    totalBytesLoad              // 已经写入的大小
    totalBytesExpectedToLoad    // 总大小

    let progressNum1:NSNumber = NSNumber(float: Float(Double(totalBytesLoad)/Double(totalBytesExpectedToLoad)))
    self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), withObject: progressNum1, waitUntilDone: true)

4、Alamofire HTTP 认证

支持以下几种认证：
- HTTP Basic
- HTTP Digest
- Kerberos
- NTLM

Swift

    // Http basic 方式认证

        let user = "user"
        let password = "password"

        Alamofire.request(.GET, "https://httpbin.org/basic-auth/\(user)/\(password)")

            .authenticate(user: user, password: password)

    // NSURLCredential 方式认证

        let user = "user"
        let password = "password"

        let credential = NSURLCredential(user: user, password: password, persistence: .ForSession)

        Alamofire.request(.GET, "https://httpbin.org/basic-auth/\(user)/\(password)")

            .authenticate(usingCredential: credential)

    // headers 方式认证

        let user = "user"
        let password = "password"

        let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)!
        let base64Credentials = credentialData.base64EncodedStringWithOptions([])

        let headers = ["Authorization": "Basic \(base64Credentials)"]

        Alamofire.request(.GET, "https://httpbin.org/basic-auth/user/password", headers: headers)

5、Alamofire HTTP 响应状态信息识别

Swift

手动识别

    /*
            Alamofire 还提供了 HTTP 响应状态的判断识别，通过 validate 方法，对于在我们期望之外的 HTTP 响应状态信息，
        Alamofire 会提供报错信息：
    */

    Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])

        .validate(statusCode: 200..<300)

        .validate(contentType: ["application/json"])

自动识别

    // validate 方法还提供自动识别机制，我们调用 validate 方法时不传入任何参数，则会自动认为 200…299 的状态吗为正常：

    Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])

        .validate()

6、Alamofire Timeline

Swift

    /*
            Alamofire collects timings throughout the lifecycle of a Request and creates a Timeline object 
        exposed as a property on a Response.
    */

    Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video", parameters: ["type": "JSON"])

        .validate()

        .responseJSON { response in

        print(response.timeline)
    }

    The above reports the following Timeline info:

        Latency: 0.428 seconds
        Request Duration: 0.428 seconds
        Serialization Duration: 0.001 seconds
        Total Duration: 0.429 seconds

7、Alamofire 调试打印

Swift

    // GET print

        let request = Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

        print(request)

        // 打印输出 GET http://192.168.88.200:8080/MJServer/video?type=JSON

    // POST print

        let request = Alamofire.request(.POST, "http://192.168.88.200:8080/MJServer/video", parameters: ["type":"JSON"])

        print(request)

        // 打印输出 POST http://192.168.88.200:8080/MJServer/video

    // GET debugprint

        let request = Alamofire.request(.GET, "http://192.168.88.200:8080/MJServer/video?type=JSON")

        debugPrint(request)

        // 打印输出 curl 信息

        $ curl -i \
            -H "User-Agent: SwiftAlamofire/com.qianqianstudio.SwiftAlamofire (1; OS Version 9.3 (Build 13E230))" \
            -H "Accept-Language: zh-Hans-US;q=1.0, en-US;q=0.9" \
            -H "Accept-Encoding: gzip;q=1.0, compress;q=0.5" \
                "http://192.168.88.200:8080/MJServer/video?type=JSON"

8、Alamofire 网络连接状态检查

Swift

    网络连接状态：

        public enum NetworkReachabilityStatus {
            case Unknown            网络状态未知
            case NotReachable       无网络连接
            case Reachable(Alamofire.NetworkReachabilityManager.ConnectionType)
        }

        public enum ConnectionType {
            case EthernetOrWiFi     WiFi 网络
            case WWAN               无线网络（蜂窝移动网络）
        }

    let manager = NetworkReachabilityManager()

    // 监听网络状态闭包
    manager?.listener = { status in

        /*
            开启网络状态监听后，只要网络状态发生改变就会调用该闭包代码段。
        */

        print("Network Status Changed: \(status)")
    }

    // 开启监听网络状态
    manager?.startListening()

    // 关闭网络状态监听
    manager?.stopListening()

    // 获取网络连接状态
    let status = manager?.networkReachabilityStatus

    // 判断网络是否连接
    let isReachable:Bool? = manager?.isReachable

    // 判断 WiFi 是否连接
    let isReachableOnEthernetOrWiFi:Bool? = manager?.isReachableOnEthernetOrWiFi

    // 判断 无线网络 是否连接
    let isReachableOnWWAN:Bool? = manager?.isReachableOnWWAN

9、Alamofire 异步 GET 数据请求

Swift

    // Alamofire 方式

        let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video?type=XML"

        Alamofire.request(.GET, urlStr)

            .response { (request:NSURLRequest?, response:NSHTTPURLResponse?, responseData:NSData?, error:NSError?) in

                /*
                    网络请求结束，成功时 error == nil。请求返回的数据存在 responseData 中，为 NSData 格式。
                */
            }

    // Manager 方式

        // 必须设置为全局的
        var alamofireManager: Manager!

        let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video?type=XML"

        self.alamofireManager = Manager(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

        self.alamofireManager.request(.GET, urlStr)

            .response { (request:NSURLRequest?, response:NSHTTPURLResponse?, responseData:NSData?, error:NSError?) in

                /*
                    网络请求结束，成功时 error == nil。请求返回的数据存在 responseData 中，为 NSData 格式。
                */
            }

10、Alamofire 文件下载

支持的类型:
- Request
- Resume Data
默认支持后台方式下载

Swift

指定文件路径方式

    // 目标路径闭包展开

    Alamofire.download(.GET, "http://120.25.226.186:32812/resources/videos/minion_01.mp4") 
                      { (temporaryURL:NSURL, response:NSHTTPURLResponse) -> NSURL in

        /*
                设置文件下载路径，temporaryURL 是沙盒下的文件临时存储路径，下载完成后会被自动删除。response.suggestedFilename 
            为服务器端文件名。此 block 在子线程中执行。
        */

        let documentsDirUrl:NSURL = NSFileManager.defaultManager()
                                                 .URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0]
                                                 .URLByAppendingPathComponent(response.suggestedFilename!)

        if NSFileManager.defaultManager().fileExistsAtPath(documentsDirUrl.path!) {

            // 移除已经存在的文件，在 Swift 中文件已经存在时，再次相同路径写入会失败
            try! NSFileManager.defaultManager().removeItemAtURL(documentsDirUrl)                
        }   

        return documentsDirUrl
    }

        .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

            /*
                监听文件下载进度，此 block 在子线程中执行。
            */

            // 设置下载进度条 
            let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesWrite)/Double(totalBytesExpectedToWrite)))
            self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), withObject: progressNum, waitUntilDone: true)
        }

        .response { (_, _, _, error:NSError?) in

            /*
                网络请求结束，成功时 error == nil。在 Swift 中文件已经存在时，再次相同路径写入会失败。
            */  
        }

使用默认提供的下载路径方式

    // 目标路径闭包

        // 设置文件的默认下载路径
        let destination = Alamofire.Request.suggestedDownloadDestination(directory: .DocumentDirectory, domain: .UserDomainMask)

        Alamofire.download(.GET, "http://120.25.226.186:32812/resources/videos/minion_01.mp4", destination: destination)

            .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                /*
                    监听文件下载进度，此 block 在子线程中执行。
                */

                // 设置下载进度条
                let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesWrite)/Double(totalBytesExpectedToWrite)))
                self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), 
                                      withObject: progressNum, 
                                   waitUntilDone: true)
            }

            .response { (_, _, _, error:NSError?) in

                /*
                    网络请求结束，成功时 error == nil。在 Swift 中文件已经存在时，再次相同路径写入会失败。
                */
            }

断点续传下载方式

    // 使用断点下载需要之前下载的临时文件存在，才能继续下载。

    var downloadRequest:Request!
    var resumeData:NSData!

    // 开始下载

        let resumeTmpPath = NSSearchPathForDirectoriesInDomains(.CachesDirectory, .UserDomainMask, true)[0] + "/resumeData.tmp"

        // 判断断点保存的文件是否存在
        if NSFileManager.defaultManager().fileExistsAtPath(resumeTmpPath) {

            // 断点开始下载

            // 读取断点保存的数据
            self.resumeData = NSData(contentsOfFile: resumeTmpPath)

            self.downloadRequest = Alamofire.download(resumeData: self.resumeData, destination: 
                                             { (temporaryURL:NSURL, response:NSHTTPURLResponse) -> NSURL in

            let documentsDirUrl:NSURL = NSFileManager.defaultManager()
                                                     .URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0]
                                                     .URLByAppendingPathComponent(response.suggestedFilename!)                   
                if NSFileManager.defaultManager().fileExistsAtPath(documentsDirUrl.path!) {

                    try! NSFileManager.defaultManager().removeItemAtURL(documentsDirUrl)
                }

                return documentsDirUrl
            })

            .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesWrite)/Double(totalBytesExpectedToWrite)))
                self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), 
                                      withObject: progressNum, 
                                   waitUntilDone: true)
                }

                .response { (_, _, data:NSData?, error:NSError?) in

                if error == nil {

                    // 删除断点下载缓存文件

                    let resumeTmpPath = NSSearchPathForDirectoriesInDomains(.CachesDirectory, 
                                                                            .UserDomainMask, 
                                                                            true)[0] 
                                                                          + "/resumeData.tmp"

                    if NSFileManager.defaultManager().fileExistsAtPath(resumeTmpPath) {
                        try! NSFileManager.defaultManager().removeItemAtPath(resumeTmpPath)
                    }

                } else {

                    // 下载的临时文件不存在处理

                    if error?.localizedFailureReason == "No such file or directory" {

                            let resumeTmpPath = NSSearchPathForDirectoriesInDomains(.CachesDirectory, 
                                                                                    .UserDomainMask, 
                                                                                    true)[0]
                                                                                  + "/resumeData.tmp"

                            if NSFileManager.defaultManager().fileExistsAtPath(resumeTmpPath) {

                                // 删除断点下载缓存文件，否则继续断点下载会报错
                                try! NSFileManager.defaultManager().removeItemAtPath(resumeTmpPath)
                            }   
                        }
                    }
                }
        } else {

            // 重新开始下载

            self.resumeData = NSData()

            self.downloadRequest = Alamofire.download(.GET, "http://120.25.226.186:32812/resources/videos/minion_01.mp4") 
                                                     { (temporaryURL:NSURL, response: NSHTTPURLResponse) -> NSURL in

                let documentsDirUrl:NSURL = NSFileManager.defaultManager()
                                                         .URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0]
                                                         .URLByAppendingPathComponent(response.suggestedFilename!)

                    if NSFileManager.defaultManager().fileExistsAtPath(documentsDirUrl.path!) {

                        try! NSFileManager.defaultManager().removeItemAtURL(documentsDirUrl)
                    }

                    return documentsDirUrl
            }

                .progress { (bytesWrite:Int64, totalBytesWrite:Int64, totalBytesExpectedToWrite:Int64) in

                    let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesWrite)/Double(totalBytesExpectedToWrite)))
                    self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), 
                                          withObject: progressNum, 
                                       waitUntilDone: true)
                }

                .response { (_, _, data:NSData?, error:NSError?) in

                    if error == nil {

                    } else {

                        // 停止下载处理

                        if error!.code == NSURLErrorCancelled {

                            if data != nil {

                                // 意外终止的话，把已下载的数据储存起来
                                self.resumeData = data

                                let resumeTmpPath = NSSearchPathForDirectoriesInDomains(.CachesDirectory, 
                                                                                        .UserDomainMask, 
                                                                                        true)[0] 
                                                                                      + "/resumeData.tmp"

                                self.resumeData.writeToFile(resumeTmpPath, atomically: true)
                            }

                        } else {

                    }
                }
            }
        }

    // 暂停下载

        self.downloadRequest.suspend()

    // 继续下载

        self.downloadRequest.resume()

    // 停止下载

        self.downloadRequest.cancel()

11、Alamofire 异步 POST 数据请求

Swift

Alamofire 方式

    let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video"
    let parameters:[String: AnyObject]? = ["type":"XML"]

    Alamofire.request(.POST, urlStr, parameters: parameters)

        .response { (request:NSURLRequest?, response:NSHTTPURLResponse?, responseData:NSData?, error:NSError?) in

            /*
                网络请求结束，成功时 error == nil。请求返回的数据存在 responseData 中，为 NSData 格式。
            */  
        }

Manager 方式

    // 必须设置为全局的
    var alamofireManager: Manager!

    let urlStr:URLStringConvertible = "http://192.168.88.200:8080/MJServer/video"
    let parameters:[String: AnyObject]? = ["type":"XML"]

    self.alamofireManager = Manager(configuration: NSURLSessionConfiguration.defaultSessionConfiguration())

    self.alamofireManager.request(.POST, urlStr, parameters: parameters)

        .response { (request:NSURLRequest?, response:NSHTTPURLResponse?, responseData:NSData?, error:NSError?) in

            /*
                网络请求结束，成功时 error == nil。请求返回的数据存在 responseData 中，为 NSData 格式。
            */  
        }

12、Alamofire 文件上传

支持的类型：
- File
- Data
- Stream
- MultipartFormData

Swift

Data 形式上传

    let boundary = "myBoundary"

    // 设置请求头
    /*
        upload task 不会在请求头里添加 content-type (上传数据类型)字段，@"myBoundary" 为请求体边界，参数可以随便设置，但需一致
    */
    let headers = ["Content-Type":"multipart/form-data; charset=utf-8; boundary=\(boundary)"]

    // 设置请求文件参数

        let formBody = NSMutableData()

        // 参数开始分割线
        /*
            每个参数开始前都需要加
        */
        formBody.appendData("--\(boundary)".dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 参数
        /*
            username 是后台规定的参数名，jhq 是需要添加的参数内容值
        */
        formBody.appendData("Content-Disposition: form-data; name=\"\("username")\"\r\n\r\n\("jhq")"
                .dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 文件开始分割线
        /*
            每个文件开始前都需要加
        */
        formBody.appendData("--\(boundary)".dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 文件参数名
        /*
            file 是后台规定的参数名，test.mp4 为上传后服务器端文件名称
        */
        formBody.appendData("Content-Disposition: form-data; name=\"\("file")\"; filename=\"\("test.mp4")\""
                .dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 文件的类型
        formBody.appendData("Content-Type: mp4".dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 待上传文件数据
        /*
            本地待上传的文件路径
        */
        formBody.appendData(NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("minion", ofType: "mp4")!)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // 结束分割线标记
        formBody.appendData("--\(boundary)--".dataUsingEncoding(NSUTF8StringEncoding)!)
        formBody.appendData("\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

    Alamofire.upload(.POST, "http://192.168.88.200:8080/MJServer/upload", headers: headers, data: formBody)

        .progress { (bytesLoad:Int64, totalBytesLoad:Int64, totalBytesExpectedToLoad:Int64) in

            /*
                监听文件上传进度，此 block 在子线程中执行。
            */

            let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesLoad)/Double(totalBytesExpectedToLoad)))
            self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), withObject: progressNum, waitUntilDone: true)
        }

        .response { (_, _, responseData:NSData?, error:NSError?) in

            /*
                网络请求结束。
            */  
        }

MultipartFormData 形式上传

    Alamofire.upload(.POST, "http://192.168.88.200:8080/MJServer/upload", 
                            multipartFormData: { (formData:MultipartFormData) in

        /*
            添加参数。第一个参数是需要添加的参数内容值，第二个是后台规定的参数名。

            设置上传的文件。第一个参数是需要上传的文件路径，第二个是后台规定的参数名，第三个是上传后服务器端文件名称，第四个是文件类型。
        */

        // 添加参数

            formData.appendBodyPart(data: "jhq".dataUsingEncoding(NSUTF8StringEncoding)!, name: "username")

        // 指定文件路径形式上传

            let fileUrl = NSBundle.mainBundle().URLForResource("HQ_0005", withExtension: "jpg")!

            formData.appendBodyPart(fileURL: fileUrl, name: "file", fileName: "test.png", mimeType: "image/jpeg")

        // 指定文件数据形式上传

            let fileData = NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("minion", ofType: "mp4")!)

            formData.appendBodyPart(data: fileData!, name: "file", fileName: "test.mp4", mimeType: "mp4")

    }) { (encodingResult:Manager.MultipartFormDataEncodingResult) in

        /*
            数据编码完成。
        */

        switch encodingResult {

            // 编码成功
            case .Success(let uploadRequest, _, _):

                uploadRequest

                    .progress { (bytesLoad:Int64, totalBytesLoad:Int64, totalBytesExpectedToLoad:Int64) in

                    /*
                        监听文件上传进度，此 block 在子线程中执行。
                    */

                    let progressNum:NSNumber = NSNumber(float: Float(Double(totalBytesLoad)/Double(totalBytesExpectedToLoad)))
                    self.performSelectorOnMainThread(#selector(ViewController.refreshProgress(_:)), 
                                          withObject: progressNum, 
                                       waitUntilDone: true)
                }

                .response { (_, _, responseData:NSData?, error:NSError?) in

                    /*
                        网络请求结束。
                    */  
                }

            // 编码失败
            case .Failure(let error):

                print(error)
        }
    }

iOS - Alamofire 网络请求

前言

1、Alamofire

2、Alamofire 的添加

3、Alamofire 的设置

4、Alamofire HTTP 认证

5、Alamofire HTTP 响应状态信息识别

6、Alamofire Timeline

7、Alamofire 调试打印

8、Alamofire 网络连接状态检查

9、Alamofire 异步 GET 数据请求

10、Alamofire 文件下载

11、Alamofire 异步 POST 数据请求

12、Alamofire 文件上传

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

iOS - Alamofire 网络请求

前言

1、Alamofire

2、Alamofire 的添加

3、Alamofire 的设置

4、Alamofire HTTP 认证

5、Alamofire HTTP 响应状态信息识别

6、Alamofire Timeline

7、Alamofire 调试打印

8、Alamofire 网络连接状态检查

9、Alamofire 异步 GET 数据请求

10、Alamofire 文件下载

11、Alamofire 异步 POST 数据请求

12、Alamofire 文件上传

热门文章

最新文章

相关课程

相关电子书

相关实验场景