Alamofire是一个用Swift编写的HTTP网络库。
为了使Alamofire专注于核心网络实现，Alamofire软件基金会创建了一些额外的组件库，以向Alamofire生态系统引入更多功能。
UIImage和UIImageView扩展、自定义图片过滤器、自动清理内存缓存和基于优先级的图片下载系统的图片库。NSURLSession实例。内嵌框架需要iOS 8或OS X Mavericks (10.9)的最小部署目标。
由于框架不支持，Alamofire 已经不再支持 iOS 7。没有框架，对 iOS 7 运行 Travis-CI 将需要第二个重复的测试目标。单独的测试套件需要导入所有 Swift 文件，并且测试需要重复编写。这样的分割难以维护，无法确保 Alamofire 生态系统的最高质量。
如果您不希望使用上述任何依赖管理器，您可以将 Alamofire 手动整合到您的项目中。
cd 命令进入您的顶级项目目录，如果您没有将项目初始化为 git 仓库，请运行以下命令$ git init$ git submodule add https://github.com/Alamofire/Alamofire.git打开新的 Alamofire 文件夹，将 Alamofire.xcodeproj 拖到应用程序 Xcode 项目的“项目导航器”中。
它应该嵌套在您应用程序的蓝色项目图标下方。无论它是在所有其他 Xcode 组之上还是之下都无关紧要。
在项目导航器中，选择 Alamofire.xcodeproj 并验证部署目标是否与应用程序目标匹配。
+ 按钮。您将看到两个不同的 Alamofire.xcodeproj 文件夹，每个文件夹内都嵌套着两个不同版本的 Alamofire.framework，这位于“Products”文件夹中。
您可以选择哪一个
Products文件夹并不重要，但您选择的 <>Alamofire.framework 的上下文很重要。
对于 iOS 选中顶部的 Alamofire.framework，对于 OS X 则选中底部的。
您可以通过检查项目构建日志来验证您选择了哪一个。构建目标将列出为
Alamofire iOS或Alamofire OSX。
如此就是全部内容！
Alamofire.framework在构建阶段会自动添加为目标依赖项、链接框架和内嵌框架，这可以满足在模拟器和实际设备上构建的需求。
import Alamofire
Alamofire.request(.GET, "https://httpbin.org/get")Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.responseJSON { response in
print(response.request) // original URL request
print(response.response) // URL response
print(response.data) // server data
print(response.result) // result of response serialization
if let JSON = response.result.value {
print("JSON: \(JSON)")
}
}Alamofire 中的联网操作是 异步的。对于初学者来说，异步编程可能是一个令人沮丧的概念源头，但这样做有 一些非常好的理由。
与调用服务器响应并阻塞执行不同，我们指定一个回调以处理一旦接收到的响应。请求的结果仅在响应处理程序的作用域内可用。任何依赖于响应或从服务器收到的数据执行的代码必须在处理程序内部完成。
内置的响应方法
response()responseData()responseString(encoding: NSStringEncoding)responseJSON(options: NSJSONReadingOptions)responsePropertyList(options: NSPropertyListReadOptions)Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.response { request, response, data, error in
print(request)
print(response)
print(data)
print(error)
}
response序列化器不会评估任何响应数据。它仅将所有信息直接从URL会话代理传递。我们强烈建议您利用其他响应序列化器，利用Response和Result类型。
Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.responseData { response in
print(response.request)
print(response.response)
print(response.result)
}Alamofire.request(.GET, "https://httpbin.org/get")
.responseString { response in
print("Success: \(response.result.isSuccess)")
print("Response String: \(response.result.value)")
}Alamofire.request(.GET, "https://httpbin.org/get")
.responseJSON { response in
debugPrint(response)
}响应处理器甚至可以进行链式操作
Alamofire.request(.GET, "https://httpbin.org/get")
.responseString { response in
print("Response String: \(response.result.value)")
}
.responseJSON { response in
print("Response JSON: \(response.result.value)")
}Alamofire.Method 列出了在 RFC 7231 §4.3 中定义的 HTTP 方法
public enum Method: String {
case OPTIONS, GET, HEAD, POST, PUT, PATCH, DELETE, TRACE, 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.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
// https://httpbin.org/get?foo=barlet parameters = [
"foo": "bar",
"baz": ["a", 1],
"qux": [
"x": 1,
"y": 2,
"z": 3
]
]
Alamofire.request(.POST, "https://httpbin.org/post", parameters: parameters)
// HTTP body: foo=bar&baz[]=a&baz[]=1&qux[x]=1&qux[y]=2&qux[z]=3参数也可以使用 ParameterEncoding 枚举进行编码，如 JSON、属性列表或任何自定义格式
enum ParameterEncoding {
case URL
case URLEncodedInURL
case JSON
case PropertyList(format: NSPropertyListFormat, options: NSPropertyListWriteOptions)
case Custom((URLRequestConvertible, [String: AnyObject]?) -> (NSMutableURLRequest, NSError?))
func encode(request: NSURLRequest, parameters: [String: AnyObject]?) -> (NSURLRequest, NSError?)
{ ... }
}URL：用于 GET、HEAD 和 DELETE 请求的查询字符串，或设置为请求（除这些之外的任何 HTTP 方法）的正体。对具有 HTTP 体的编码请求的 Content-Type HTTP 标头字段设置为 application/x-www-form-urlencoded。由于尚未发布有关如何编码集合类型的规范，Alamofire 遵循在数组值键后附加 [] 的约定（如 foo[]=1&foo[]=2），以及将键括在方括号中以设置嵌套字典值（如 foo[bar]=baz）。URLEncodedInURL：创建或附加到现有 URL 查询的查询字符串。与 .URL 情况使用相同的实现，但始终将编码结果应用于 URL。JSON：使用 NSJSONSerialization 创建参数对象的 JSON 表示形式，并将其设置为请求的正文。编码请求的 Content-Type HTTP 标头字段设置为 application/json。PropertyList：使用 NSPropertyListSerialization 创建参数对象的 plist 表示形式，根据关联的格式和写入选项值，将其设置为请求的正文。对编码请求的 Content-Type HTTP 标头字段设置为 application/x-plist。Custom：使用关联的闭包值构造给定现有请求和参数的新请求。let URL = NSURL(string: "https://httpbin.org/get")!
var request = NSMutableURLRequest(URL: URL)
let parameters = ["foo": "bar"]
let encoding = Alamofire.ParameterEncoding.URL
(request, _) = encoding.encode(request, parameters: parameters)let parameters = [
"foo": [1,2,3],
"bar": [
"baz": "qux"
]
]
Alamofire.request(.POST, "https://httpbin.org/post", parameters: parameters, encoding: .JSON)
// HTTP body: {"foo": [1, 2, 3], "bar": {"baz": "qux"}}直接在全局 request 方法中支持向 Request 添加自定义 HTTP 标头。这使得将 HTTP 标头附加到可能不断变化的 Request 上变得很容易。
对于不会变化的 HTTP 标头，建议在
NSURLSessionConfiguration上设置它们，以便自动应用于任何由底层的NSURLSession创建的NSURLSessionTask。
let headers = [
"Authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==",
"Content-Type": "application/x-www-form-urlencoded"
]
Alamofire.request(.GET, "https://httpbin.org/get", headers: headers)
.responseJSON { response in
debugPrint(response)
}缓存由系统框架层级上的 NSURLCache 处理。
支持的上传类型
let fileURL = NSBundle.mainBundle().URLForResource("Default", withExtension: "png")
Alamofire.upload(.POST, "https://httpbin.org/post", file: fileURL)Alamofire.upload(.POST, "https://httpbin.org/post", file: fileURL)
.progress { bytesWritten, totalBytesWritten, totalBytesExpectedToWrite in
print(totalBytesWritten)
// This closure is NOT called on the main queue for performance
// reasons. To update your ui, dispatch to the main queue.
dispatch_async(dispatch_get_main_queue()) {
print("Total bytes written on main queue: \(totalBytesWritten)")
}
}
.responseJSON { response in
debugPrint(response)
}Alamofire.upload(
.POST,
"https://httpbin.org/post",
multipartFormData: { multipartFormData in
multipartFormData.appendBodyPart(fileURL: unicornImageURL, name: "unicorn")
multipartFormData.appendBodyPart(fileURL: rainbowImageURL, name: "rainbow")
},
encodingCompletion: { encodingResult in
switch encodingResult {
case .Success(let upload, _, _):
upload.responseJSON { response in
debugPrint(response)
}
case .Failure(let encodingError):
print(encodingError)
}
}
)支持的下载类型
Alamofire.download(.GET, "https://httpbin.org/stream/100") { temporaryURL, response in
let fileManager = NSFileManager.defaultManager()
let directoryURL = fileManager.URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0]
let pathComponent = response.suggestedFilename
return directoryURL.URLByAppendingPathComponent(pathComponent!)
}let destination = Alamofire.Request.suggestedDownloadDestination(directory: .DocumentDirectory, domain: .UserDomainMask)
Alamofire.download(.GET, "https://httpbin.org/stream/100", destination: destination)Alamofire.download(.GET, "https://httpbin.org/stream/100", destination: destination)
.progress { bytesRead, totalBytesRead, totalBytesExpectedToRead in
print(totalBytesRead)
// This closure is NOT called on the main queue for performance
// reasons. To update your ui, dispatch to the main queue.
dispatch_async(dispatch_get_main_queue()) {
print("Total bytes read on main queue: \(totalBytesRead)")
}
}
.response { _, _, _, error in
if let error = error {
print("Failed with error: \(error)")
} else {
print("Downloaded file successfully")
}
}Alamofire.download(.GET, "https://httpbin.org/stream/100", destination: destination)
.response { _, _, data, _ in
if let
data = data,
resumeDataString = NSString(data: data, encoding: NSUTF8StringEncoding)
{
print("Resume Data: \(resumeDataString)")
} else {
print("Resume Data was empty")
}
}如果可用，自动将
resumeData填充到data参数。
let download = Alamofire.download(.GET, "https://httpbin.org/stream/100", destination: destination)
download.response { _, _, _, _ in
if let
resumeData = download.resumeData,
resumeDataString = NSString(data: resumeData, encoding: NSUTF8StringEncoding)
{
print("Resume Data: \(resumeDataString)")
} else {
print("Resume Data was empty")
}
}认证在系统框架层级上由 NSURLCredential 和 NSURLAuthenticationChallenge 处理。
支持的认证方案
在适当的 Request 上的 authenticate 方法将自动为 NSURLAuthenticationChallenge 提供 NSURLCredential
let user = "user"
let password = "password"
Alamofire.request(.GET, "https://httpbin.org/basic-auth/\(user)/\(password)")
.authenticate(user: user, password: password)
.responseJSON { response in
debugPrint(response)
}根据您的服务器实现，用作 Authorization 的头部可能也是合适的
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)
.responseJSON { response in
debugPrint(response)
}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)
.responseJSON { response in
debugPrint(response)
}默认情况下，Alamofire 将任何完成的请求视为成功，无论响应内容如何。在响应处理程序之前调用 validate 会生成错误，如果响应有不可接受的状态码或 MIME 类型。
Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.validate(statusCode: 200..<300)
.validate(contentType: ["application/json"])
.response { response in
print(response)
}自动验证状态码在200...299范围内，并且在响应的Content-Type头和请求的Accept头匹配的情况下（如果有提供）。
Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.validate()
.responseJSON { response in
switch response.result {
case .Success:
print("Validation Successful")
case .Failure(let error):
print(error)
}
}Alamofire在Request生命周期的各个阶段收集时间信息，并创建一个Timeline对象，该对象作为Response对象的属性暴露。
Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
.validate()
.responseJSON { response in
print(response.timeline)
}以上报告了以下Timeline信息
延迟：0.428秒请求持续时间：0.428秒序列化持续时间：0.001秒总持续时间：0.429秒let request = Alamofire.request(.GET, "https://httpbin.org/ip")
print(request)
// GET https://httpbin.org/ip (200)let request = Alamofire.request(.GET, "https://httpbin.org/get", parameters: ["foo": "bar"])
debugPrint(request)$ curl -i \
-H "User-Agent: Alamofire" \
-H "Accept-Encoding: Accept-Encoding: gzip;q=1.0,compress;q=0.5" \
-H "Accept-Language: en;q=1.0,fr;q=0.9,de;q=0.8,zh-Hans;q=0.7,zh-Hant;q=0.6,ja;q=0.5" \
"https://httpbin.org/get?foo=bar"Alamofire构建在
NSURLSession和Foundation URL加载系统之上。为了充分利用此框架，建议您熟悉底层网络堆栈的概念和功能。
推荐阅读
顶级便捷方法如Alamofire.request使用共享的Alamofire.Manager实例，该实例配置了默认的NSURLSessionConfiguration。
因此，以下两个语句是等价的
Alamofire.request(.GET, "https://httpbin.org/get")let manager = Alamofire.Manager.sharedInstance
manager.request(NSURLRequest(URL: NSURL(string: "https://httpbin.org/get")!))应用程序可以创建用于后台和短暂会话的管理器，以及自定义默认会话配置的新管理者，例如对于默认头部（HTTPAdditionalHeaders）或超时间隔（timeoutIntervalForRequest）。
let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
let manager = Alamofire.Manager(configuration: configuration)let configuration = NSURLSessionConfiguration.backgroundSessionConfigurationWithIdentifier("com.example.app.background")
let manager = Alamofire.Manager(configuration: configuration)let configuration = NSURLSessionConfiguration.ephemeralSessionConfiguration()
let manager = Alamofire.Manager(configuration: configuration)var defaultHeaders = Alamofire.Manager.sharedInstance.session.configuration.HTTPAdditionalHeaders ?? [:]
defaultHeaders["DNT"] = "1 (Do Not Track Enabled)"
let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
configuration.HTTPAdditionalHeaders = defaultHeaders
let manager = Alamofire.Manager(configuration: configuration)不建议用于
Authorization或Content-Type头部。相反，应使用URLRequestConvertible和ParameterEncoding分别。
request、upload或download方法的结果是Alamofire.Request的一个实例。请求始终通过拥有管理器的构造方法创建，从不直接初始化。
如authenticate、validate和responseData一样的方法返回调用来简化链式调用。
请求可以被挂起、恢复和取消
suspend()：挂起底层任务和调度队列resume()：恢复底层任务和调度队列。如果拥有管理器没有将startRequestsImmediately设置为true，请求必须调用resume()才能开始。cancel()：取消底层任务，生成一个错误，并将其传递给任何已注册的响应处理器。Alamofire为字符串、JSON和属性列表提供内置的响应序列化，但可以在Alamofire.Request的扩展中添加其他序列化器。
例如，以下是使用Ono实现的响应处理器示例
extension Request {
public static func XMLResponseSerializer() -> ResponseSerializer<ONOXMLDocument, NSError> {
return ResponseSerializer { request, response, data, error in
guard error == nil else { return .Failure(error!) }
guard let validData = data else {
let failureReason = "Data could not be serialized. Input data was nil."
let error = Error.errorWithCode(.DataSerializationFailed, failureReason: failureReason)
return .Failure(error)
}
do {
let XML = try ONOXMLDocument(data: validData)
return .Success(XML)
} catch {
return .Failure(error as NSError)
}
}
}
public func responseXMLDocument(completionHandler: Response<ONOXMLDocument, NSError> -> Void) -> Self {
return response(responseSerializer: Request.XMLResponseSerializer(), completionHandler: completionHandler)
}
}可以使用泛型实现自动、类型安全的响应对象序列化。
public protocol ResponseObjectSerializable {
init?(response: NSHTTPURLResponse, representation: AnyObject)
}
extension Request {
public func responseObject<T: ResponseObjectSerializable>(completionHandler: Response<T, NSError> -> Void) -> Self {
let responseSerializer = ResponseSerializer<T, NSError> { request, response, data, error in
guard error == nil else { return .Failure(error!) }
let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
let result = JSONResponseSerializer.serializeResponse(request, response, data, error)
switch result {
case .Success(let value):
if let
response = response,
responseObject = T(response: response, representation: value)
{
return .Success(responseObject)
} else {
let failureReason = "JSON could not be serialized into response object: \(value)"
let error = Error.errorWithCode(.JSONSerializationFailed, failureReason: failureReason)
return .Failure(error)
}
case .Failure(let error):
return .Failure(error)
}
}
return response(responseSerializer: responseSerializer, completionHandler: completionHandler)
}
}final class User: ResponseObjectSerializable {
let username: String
let name: String
init?(response: NSHTTPURLResponse, representation: AnyObject) {
self.username = response.URL!.lastPathComponent!
self.name = representation.valueForKeyPath("name") as! String
}
}Alamofire.request(.GET, "https://example.com/users/mattt")
.responseObject { (response: Response<User, NSError>) in
debugPrint(response)
}同样，此方法也可以用来处理返回对象集合表示的结构端点
public protocol ResponseCollectionSerializable {
static func collection(response response: NSHTTPURLResponse, representation: AnyObject) -> [Self]
}
extension Alamofire.Request {
public func responseCollection<T: ResponseCollectionSerializable>(completionHandler: Response<[T], NSError> -> Void) -> Self {
let responseSerializer = ResponseSerializer<[T], NSError> { request, response, data, error in
guard error == nil else { return .Failure(error!) }
let JSONSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
let result = JSONSerializer.serializeResponse(request, response, data, error)
switch result {
case .Success(let value):
if let response = response {
return .Success(T.collection(response: response, representation: value))
} else {
let failureReason = "Response collection could not be serialized due to nil response"
let error = Error.errorWithCode(.JSONSerializationFailed, failureReason: failureReason)
return .Failure(error)
}
case .Failure(let error):
return .Failure(error)
}
}
return response(responseSerializer: responseSerializer, completionHandler: completionHandler)
}
}final class User: ResponseObjectSerializable, ResponseCollectionSerializable {
let username: String
let name: String
init?(response: NSHTTPURLResponse, representation: AnyObject) {
self.username = response.URL!.lastPathComponent!
self.name = representation.valueForKeyPath("name") as! String
}
static func collection(response response: NSHTTPURLResponse, representation: AnyObject) -> [User] {
var users: [User] = []
if let representation = representation as? [[String: AnyObject]] {
for userRepresentation in representation {
if let user = User(response: response, representation: userRepresentation) {
users.append(user)
}
}
}
return users
}
}Alamofire.request(.GET, "http://example.com/users")
.responseCollection { (response: Response<[User], NSError>) in
debugPrint(response)
}采用URLStringConvertible协议的类型可以用来构建URL字符串，这些字符串随后用于构建URL请求。NSString、NSURL、NSURLComponents和NSURLRequest默认遵循URLStringConvertible，使得它们中的任何一个都可以作为URLString参数传递给request、upload和download方法
let string = NSString(string: "https://httpbin.org/post")
Alamofire.request(.POST, string)
let URL = NSURL(string: string)!
Alamofire.request(.POST, URL)
let URLRequest = NSURLRequest(URL: URL)
Alamofire.request(.POST, URLRequest) // overrides `HTTPMethod` of `URLRequest`
let URLComponents = NSURLComponents(URL: URL, resolvingAgainstBaseURL: true)
Alamofire.request(.POST, URLComponents)鼓励与网络应用有重大交互的应用程序有自己的自定义类型遵循URLStringConvertible，作为将特定领域模型映射到服务器资源的一种方便方式。
extension User: URLStringConvertible {
static let baseURLString = "http://example.com"
var URLString: String {
return User.baseURLString + "/users/\(username)/"
}
}let user = User(username: "mattt")
Alamofire.request(.GET, user) // http://example.com/users/mattt采用URLRequestConvertible协议的类型可以用来构建URL请求。NSURLRequest默认遵循URLRequestConvertible，可以直接传递给request、upload和download方法（这是指定单个请求的自定义HTTP主体的推荐方法）
let URL = NSURL(string: "https://httpbin.org/post")!
let mutableURLRequest = NSMutableURLRequest(URL: URL)
mutableURLRequest.HTTPMethod = "POST"
let parameters = ["foo": "bar"]
do {
mutableURLRequest.HTTPBody = try NSJSONSerialization.dataWithJSONObject(parameters, options: NSJSONWritingOptions())
} catch {
// No-op
}
mutableURLRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
Alamofire.request(mutableURLRequest)鼓励与网络应用有重大交互的应用程序有自己的自定义类型遵循URLRequestConvertible，以确保请求端点的一致性。这种方法可以用来掩蔽后端不一致性，提供类型安全的路由，并管理身份验证凭据和其他状态。
enum Router: URLRequestConvertible {
static let baseURLString = "http://example.com"
static let perPage = 50
case Search(query: String, page: Int)
// MARK: URLRequestConvertible
var URLRequest: NSMutableURLRequest {
let result: (path: String, parameters: [String: AnyObject]) = {
switch self {
case .Search(let query, let page) where page > 1:
return ("/search", ["q": query, "offset": Router.perPage * page])
case .Search(let query, _):
return ("/search", ["q": query])
}
}()
let URL = NSURL(string: Router.baseURLString)!
let URLRequest = NSURLRequest(URL: URL.URLByAppendingPathComponent(result.path))
let encoding = Alamofire.ParameterEncoding.URL
return encoding.encode(URLRequest, parameters: result.parameters).0
}
}Alamofire.request(Router.Search(query: "foo bar", page: 1)) // ?q=foo%20bar&offset=50enum Router: URLRequestConvertible {
static let baseURLString = "http://example.com"
static var OAuthToken: String?
case CreateUser([String: AnyObject])
case ReadUser(String)
case UpdateUser(String, [String: AnyObject])
case DestroyUser(String)
var method: Alamofire.Method {
switch self {
case .CreateUser:
return .POST
case .ReadUser:
return .GET
case .UpdateUser:
return .PUT
case .DestroyUser:
return .DELETE
}
}
var path: String {
switch self {
case .CreateUser:
return "/users"
case .ReadUser(let username):
return "/users/\(username)"
case .UpdateUser(let username, _):
return "/users/\(username)"
case .DestroyUser(let username):
return "/users/\(username)"
}
}
// MARK: URLRequestConvertible
var URLRequest: NSMutableURLRequest {
let URL = NSURL(string: Router.baseURLString)!
let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
mutableURLRequest.HTTPMethod = method.rawValue
if let token = Router.OAuthToken {
mutableURLRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
}
switch self {
case .CreateUser(let parameters):
return Alamofire.ParameterEncoding.JSON.encode(mutableURLRequest, parameters: parameters).0
case .UpdateUser(_, let parameters):
return Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: parameters).0
default:
return mutableURLRequest
}
}
}Alamofire.request(Router.ReadUser("mattt")) // GET /users/mattt在与服务器和Web服务通信时使用安全的HTTPS连接是保护敏感数据的重要步骤。默认情况下，Alamofire将使用Security框架提供的Apple内置验证来评估由服务器提供的证书链。虽然这保证了证书链的有效性，但并不能防止中间人（MITM）攻击或其他潜在漏洞。为了减轻MITM攻击，处理敏感客户数据或财务信息的应用程序应使用ServerTrustPolicy提供的证书或公钥固定。
ServerTrustPolicy枚举评估在通过安全HTTPS连接连接到服务器时，由NSURLAuthenticationChallenge提供的服务器信任度。
let serverTrustPolicy = ServerTrustPolicy.PinCertificates(
certificates: ServerTrustPolicy.certificatesInBundle(),
validateCertificateChain: true,
validateHost: true
)有各种不同的服务器信任评估情况，让您完全控制验证过程。
PerformDefaultEvaluation：使用默认服务器信任度评估，同时允许您控制是否验证挑战提供的宿主。PinCertificates：使用已固定的证书来验证服务器信任度。如果已固定的证书之一与服务器证书之一匹配，则认为服务器信任度有效。PinPublicKeys：使用已固定的公钥来验证服务器信任度。如果已固定的公钥之一与服务器证书的公钥之一匹配，则认为服务器信任度有效。DisableEvaluation：禁用所有评估，从而始终将任何服务器信任度视为有效。CustomEvaluation：使用关联的计算闭包来评估服务器信任度的有效性，从而让您完全控制验证过程。请谨慎使用。ServerTrustPolicyManager负责存储服务器信任策略与特定宿主的内部映射。这允许Alamofire针对不同的服务器信任策略评估每个宿主。
let serverTrustPolicies: [String: ServerTrustPolicy] = [
"test.example.com": .PinCertificates(
certificates: ServerTrustPolicy.certificatesInBundle(),
validateCertificateChain: true,
validateHost: true
),
"insecure.expired-apis.com": .DisableEvaluation
]
let manager = Manager(
serverTrustPolicyManager: ServerTrustPolicyManager(policies: serverTrustPolicies)
)请确保保留对新
Manager实例的引用，否则当您的manager被销毁时，您的所有请求都将被取消。
这些服务器信任策略将导致以下行为
test.example.com将始终使用带证书链和启用的宿主验证的证书固定，因此需要满足以下标准才能成功进行TLS握手insecure.expired-apis.com永远不会评估证书链，并始终允许TLS握手成功。如果您发现自己需要更灵活的服务器信任策略匹配行为（例如，通配符域），则子类化ServerTrustPolicyManager并用您自己的自定义实现覆盖serverTrustPolicyForHost方法。
class CustomServerTrustPolicyManager: ServerTrustPolicyManager {
override func serverTrustPolicyForHost(host: String) -> ServerTrustPolicy? {
var policy: ServerTrustPolicy?
// Implement your custom domain matching behavior...
return policy
}
}所有这些服务器信任策略（.PerformDefaultEvaluation、.PinCertificates、.PinPublicKeys）均接受一个validateHost参数。将值设置为true会导致服务器信任度评估验证证书中的宿主名称是否与挑战中的宿主名称匹配。如果不匹配，评估将失败。将validateHost值设置为false将仍然评估完整的证书链，但不会验证叶子证书的宿主名称。
建议在生产环境中将
validateHost始终设置为true。
将证书和公共密钥都提供了使用validateCertificateChain参数进行证书链验证的选项。将此值设置为true时，除了对固定证书或公共密钥进行字节相等性检查之外，还会评估完整的证书链。将值设置为false将跳过证书链验证，但仍然会执行字节相等性检查。
在某些情况下禁用证书链验证是有意义的。禁用验证的最常见用例是自签名和过期的证书。在这两种情况下，评估总会失败，但字节相等性检查仍将确保您从服务器接收到预期的证书。
建议在生产环境中始终将
validateCertificateChain设置为true。
随着iOS 9中应用传输安全（ATS）的添加，使用具有多个ServerTrustPolicy对象的自定义ServerTrustPolicyManager可能不会产生作用。如果您不断看到CFNetwork SSLHandshake failed (-9806)错误，您可能遇到了这个问题。Apple的ATS系统会覆盖整个挑战系统，除非您在应用配置文件plis中配置ATS设置来禁用它，以便您的应用评估服务器信任。
如果您遇到这个问题（使用自签名证书的概率很高），您可以通过向您的Info.plist中添加以下内容来绕过这个问题。
<dict>
<key>NSAppTransportSecurity</key>
<dict>
<key>NSExceptionDomains</key>
<dict>
<key>example.com</key>
<dict>
<key>NSExceptionAllowsInsecureHTTPLoads</key>
<true/>
<key>NSExceptionRequiresForwardSecrecy</key>
<false/>
<key>NSIncludesSubdomains</key>
<true/>
<!-- Optional: Specify minimum TLS version -->
<key>NSTemporaryExceptionMinimumTLSVersion</key>
<string>TLSv1.2</string>
</dict>
</dict>
</dict>
</dict>您是否需要将NSExceptionRequiresForwardSecrecy设置为NO取决于您的TLS连接是否使用了允许的加密套件。在某些情况下，需要将其设置为NO。必须将NSExceptionAllowsInsecureHTTPLoads设置为YES，以允许SessionDelegate收到挑战回调。一旦挑战回调被调用，ServerTrustPolicyManager将接管服务器信任评估。如果您尝试连接到只支持TLS版本小于1.2的主机，还需要指定NSTemporaryExceptionMinimumTLSVersion。
建议在生产环境中始终使用有效的证书。
NetworkReachabilityManager监听WWAN和WiFi网络接口下主机和地址的可达性变化。
let manager = NetworkReachabilityManager(host: "www.apple.com")
manager?.listener = { status in
print("Network Status Changed: \(status)")
}
manager?.startListening()请确保在上面的示例中保留
manager，否则将不会报告状态变化。
在使用网络可达性确定下一步操作时要记住一些重要的事情。
建议查看WWDC 2012会议706，“网络最佳实践”以获得更多信息。
以下RDAR对Alamofire当前的实现有影响。
Alamofire 的名称来自 阿斯科莫花，这是德克萨斯州州花蓝山茏的一种杂交品种。
Alamofire 由 Alamofire 软件基金会 所拥有和维护。您可以通过 Twitter 关注他们 @AlamofireSF 以获取项目更新和发布信息。
如果您相信您已经发现了 Alamofire 的安全漏洞，请尽快通过电子邮件报告给我们 [email protected]。请勿将其发布到公共问题跟踪器。
Alamofire 是在 MIT 许可下发布的。有关详细信息，请参阅 LICENSE。