安装

• CocoaPods和Carthage都很方便安装
  安装完，如果出现加载不到Alamofire，可以查看Cannot load underlying module for 'Alamofire' #441，问题应该可以解决。
• 手动安装
  • 下载Alamofire
  • 将Alamofire.xcodeproj拖进到项目中
    
    
    
  • 在"Embedded Binaries中添加
    
    
    
  • command + B 编译后就可以使用

关于 https://httpbin.org/ 网站

https://httpbin.org/ 网站可用来做http的各种请求测试使用，不过遗憾的是没有POST等提交类型请求的测试

基本使用

一个简单的请求：

import Alamofire

Alamofire.request("https://httpbin.org/get")

http中有请求(Request) 和 响应(Response)两个重要概念。大部分http框架，都会使用request和response作为方法名。
看看Alamofire的request方法的详细参数：

  public func request(
      _ url: URLConvertible,
      method: HTTPMethod = .get,
      parameters: Parameters? = nil,
      encoding: ParameterEncoding = URLEncoding.default,
      headers: HTTPHeaders? = nil)
      -> DataRequest
  {

有url,method,parameters,encoding,headers五个参数，与http是相互对应的。其中只有url是必须的，其它都有默认值。

请求后的响应处理

向http发送请求后，就需对响应结果进行处理。** Alamofire采用链式调用的方式处理响应，这种链式调用的方式最初应该是起源jQuery**。
响应处理的一般形式如下，response就是响应结果。

Alamofire.request("https://httpbin.org/get").responseJSON { response in

}

Alamofire 提供了五种不同的响应处理：

  // Response Handler - Unserialized Response
  func response(
      queue: DispatchQueue?,
      completionHandler: @escaping (DefaultDataResponse) -> Void)
      -> Self

  // Response Data Handler - Serialized into Data
  func responseData(
      queue: DispatchQueue?,
      completionHandler: @escaping (DataResponse<Data>) -> Void)
      -> Self

  // Response String Handler - Serialized into String
  func responseString(
      queue: DispatchQueue?,
      encoding: String.Encoding?,
      completionHandler: @escaping (DataResponse<String>) -> Void)
      -> Self

  // Response JSON Handler - Serialized into Any
  func responseJSON(
      queue: DispatchQueue?,
      completionHandler: @escaping (DataResponse<Any>) -> Void)
      -> Self

  // Response PropertyList (plist) Handler - Serialized into Any
  func responsePropertyList(
      queue: DispatchQueue?,
      completionHandler: @escaping (DataResponse<Any>) -> Void))
      -> Self

五种方法的参数不同，但最后一参数都是一个回调的闭包，都可以写成尾随闭包形式。除了response方法的回调参数是DefaultDataResponse，其它都是DataResponse:

   public struct DataResponse<Value> {
       /// The URL request sent to the server.
       public let request: URLRequest?

       /// The server's response to the URL request.
       public let response: HTTPURLResponse?

       /// The data returned by the server.
       public let data: Data?

       /// The result of response serialization.
       public let result: Result<Value>

       /// The timeline of the complete lifecycle of the request.
       public let timeline: Timeline

       /// Returns the associated value of the result if it is a success, `nil` otherwise.
       public var value: Value? { return result.value }

       /// Returns the associated error value if the result if it is a failure, `nil` otherwise.
       public var error: Error? { return result.error }

       var _metrics: AnyObject?

DataResponse与DefaultDataResponse最大的不同就是多了两个属性result和value，value值就是格式化的不同类型。

响应处理的一些例子

• response

      Alamofire.request("https://httpbin.org/get").response { response in
          print("Request: \(response.request)")
          print("Response: \(response.response)")
          print("Error: \(response.error)")
          
          if let data = response.data, let utf8Text = String(data: data, encoding: .utf8) {
              print("Data: \(utf8Text)")
          }
      }
  

  response方法的响应结果response是DefaultDataResponse，没有进行过格式化处理。
• responseData

      Alamofire.request("https://httpbin.org/get").responseData { response in
          debugPrint("All Response Info: \(response)")
          
          if let data = response.result.value, let utf8Text = String(data: data, encoding: .utf8) {
              print("Data: \(utf8Text)")
          }
      }
  

  responseData方法对响应结果进行了处理，response.result.value就是我们属性的Data类型。
• 链式调用

    Alamofire.request("https://httpbin.org/get")
    .responseString { response in
            print("Response String: \(response.result.value)")
    }
    .responseJSON { response in
        print("Response JSON: \(response.result.value)")
    }
  

响应验证

http响应结果中的不同状态码(100..<600)表示不同结果。

• 手动验证

  Alamofire.request("https://httpbin.org/get")
   .validate(statusCode: 200..<300)
   .validate(contentType: ["application/json"])
   .responseData { response in
       switch response.result {
       case .success:
           print("Validation Successful")
       case .failure(let error):
           print(error)
       }
   }
  

• 自动验证
  状态码在200..<300的为正确，其它为错误。

  Alamofire.request("https://httpbin.org/get").validate().responseJSON { response in
    switch response.result {
    case .success:
        print("Validation Successful")
    case .failure(let error):
        print(error)
    }
  }
  

HTTP不同请求方式

request方法的method参数表示不同的方法。

Alamofire.request("https://httpbin.org/get") // method defaults to `.get`

Alamofire.request("https://httpbin.org/post", method: .post)
Alamofire.request("https://httpbin.org/put", method: .put)
Alamofire.request("https://httpbin.org/delete", method: .delete)

请求参数编码

GET的参数按照固定格式写到URL中，其他类型则按照不同格式写到请求body中。

• GET参数编码

        let parameters: Parameters = ["foo": "bar"]
        
        // All three of these calls are equivalent
        Alamofire.request("https://httpbin.org/get", parameters: parameters) // encoding defaults to `URLEncoding.default`
        Alamofire.request("https://httpbin.org/get", parameters: parameters, encoding: URLEncoding.default)
        Alamofire.request("https://httpbin.org/get", parameters: parameters, encoding: URLEncoding(destination: .methodDependent))
        
        // https://httpbin.org/get?foo=bar
  

• POST参数编码

        let parameters: Parameters = [
            "foo": "bar",
            "baz": ["a", 1],
            "qux": [
                "x": 1,
                "y": 2,
                "z": 3
            ]
        ]
        
        // All three of these calls are equivalent
        Alamofire.request("https://httpbin.org/post", method: .post, parameters: parameters)
        Alamofire.request("https://httpbin.org/post", method: .post, parameters: parameters, encoding: URLEncoding.default)
        Alamofire.request("https://httpbin.org/post", method: .post, parameters: parameters, encoding: URLEncoding.httpBody)
        
        // HTTP body: foo=bar&baz[]=a&baz[]=1&qux[x]=1&qux[y]=2&qux[z]=3
  

• JSON编码

        let parameters: Parameters = [
            "foo": [1,2,3],
            "bar": [
                "baz": "qux"
            ]
        ]
        
        // Both calls are equivalent
        Alamofire.request("https://httpbin.org/post", method: .post, parameters: parameters, encoding: JSONEncoding.default)
        Alamofire.request("https://httpbin.org/post", method: .post, parameters: parameters, encoding: JSONEncoding(options: []))
        
        // HTTP body: {"foo": [1, 2, 3], "bar": {"baz": "qux"}}
  

添加请求HTTP头部

let headers: HTTPHeaders = [
  "Authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
  "Accept": "application/json"
]

Alamofire.request("https://httpbin.org/headers", headers: headers).responseJSON { response in
  debugPrint(response)
}

HTTP认证

      let user = "user"
      let password = "password"
      
      Alamofire.request("https://httpbin.org/basic-auth/\(user)/\(password)")
          .authenticate(user: user, password: password)
          .responseJSON { response in
              debugPrint(response)
      }

下载文件

        Alamofire.download("https://httpbin.org/image/png").responseData { response in
            if let data = response.result.value {
                let image = UIImage(data: data)
            }
        }

另外可以下文件保存在本地：

        let destination: DownloadRequest.DownloadFileDestination = { _, _ in
            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
            let fileURL = documentsURL.appendingPathComponent("pig.png")
            
            return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
        }
        
        Alamofire.download("https://httpbin.org/image/png", to: destination).response { response in
            print(response)
            
            if response.error == nil, let imagePath = response.destinationURL?.path {
                let image = UIImage(contentsOfFile: imagePath)
                self.imageView.image = image
                self.tableView.reloadData()
            }
        }

上传

• 上传 Data

        let imageData = UIImagePNGRepresentation(image!)!
        
        Alamofire.upload(imageData, to: "https://httpbin.org/post").responseJSON { response in
            debugPrint(response)
        }
  

• 上传文件

        let fileURL = Bundle.main.url(forResource: "video", withExtension: "mov")
        
        Alamofire.upload(fileURL!, to: "https://httpbin.org/post").responseJSON { response in
            debugPrint(response)
        }
  

• 上传Multipart Form Data（表单提交）

        Alamofire.upload(
            multipartFormData: { multipartFormData in
                multipartFormData.append(unicornImageURL, withName: "unicorn")
                multipartFormData.append(rainbowImageURL, withName: "rainbow")
        },
            to: "https://httpbin.org/post",
            encodingCompletion: { encodingResult in
                switch encodingResult {
                case .success(let upload, _, _):
                    upload.responseJSON { response in
                        debugPrint(response)
                    }
                case .failure(let encodingError):
                    print(encodingError)
                }
        }
        )
  

请求中花费的各种时间

Alamofire.request("https://httpbin.org/get").responseJSON { response in
    print(response.timeline)
}

结果：

Timeline: { "Latency": 1.527 secs, "Request Duration": 1.528 secs, "Serialization Duration": 0.001 secs, "Total Duration": 1.529 secs }