Comienzo con Alamofire

Para comenzar a integrar Alamofire en su proyecto iOS, puede agregar la biblioteca usando Swift Package Manager, CocoaPods, o Carthage. Swift Package Manager es el enfoque recomendado como se construye en Xcode. Agregue el paquete Alamofire navegando a File → 

import Alamofire

El alias de Alamofire proporciona un punto de entrada conveniente para todas las operaciones HTTP comunes. Bajo la capucha, utiliza la placa de caldera de Apple pero abstrae como la gestión de colas, la codificación de parámetros y la validación de respuestas. Esto le permite centrarse en la lógica empresarial en lugar de la plomería de redes.

Realizar las solicitudes de GET

El acceso a datos de un punto final RESTful es la operación más común. Alamofire hace que las solicitudes GET sean concisas y legibles. El siguiente ejemplo recupera una lista de usuarios de una API hipotética:

AF.request("https://api.example.com/users")
 .validate()
 .responseDecodable(of: [User].self) { response in
 switch response.result {
 case .success(let users):
 print("Fetched \(users.count) users")
 case .failure(let error):
 print("Request failed with error: \(error)")
 }
 }

Observe el uso de , que aprovecha el protocolo de Swift para integrar automáticamente JSON en objetos modelo. Define una estructura que se ajusta a ] (o ).Este enfoque elimina la serialización manual de JSON y mejora la seguridad tipo.

Agregar parámetros de consulta y encabezados

Muchas API REST requieren parámetros de consulta o encabezados HTTP personalizados. Alamofire acepta parámetros como diccionario y maneja la codificación automáticamente para las solicitudes de GET (los parámetros se adjuntan a la URL). Los encabezados se agregan a través del parámetro :

let parameters: Parameters = ["page": 1, "limit": 20]
let headers: HTTPHeaders = [
 "Authorization": "Bearer YOUR_TOKEN",
 "Accept": "application/json"
]

AF.request("https://api.example.com/users",
 parameters: parameters,
 headers: headers)
 .validate()
 .responseDecodable(of: [User].self) { response in
 // handle response
 }

Alamofire automáticamente URL-codifica los parámetros y los adjunta a la URL de solicitud. Para la codificación personalizada, puede especificar una instancia explícita , como .

Validación de la respuesta

El método verifica automáticamente los códigos de estado HTTP en la gama 200–299 y rechaza las respuestas con un tipo de contenido no aceptable. También puede añadir criterios de validación personalizados. Por ejemplo, para aceptar sólo 200 y 201 códigos de estado:

.validate(statusCode: [200, 201])

Los fallos de validación se reportan como errores en el manejador de respuesta, lo que le permite implementar un manejo de errores consistente a lo largo de su aplicación.

Envío de datos de POST

Crear o actualizar recursos normalmente requiere una solicitud de POST con un cuerpo de solicitud. Alamofire soporta múltiples estrategias de codificación, siendo más común para las API de REST. El siguiente ejemplo envía un nuevo objeto de usuario al servidor:

let newUser: [String: Any] = [
 "name": "Jane Doe",
 "email": "[email protected]"
]

AF.request("https://api.example.com/users",
 method: .post,
 parameters: newUser,
 encoding: JSONEncoding.default)
 .validate()
 .responseDecodable(of: User.self) { response in
 switch response.result {
 case .success(let createdUser):
 print("User created: \(createdUser)")
 case .failure(let error):
 print("Error creating user: \(error)")
 }
 }

Si la API espera datos de formularios cifrados por URL (por ejemplo, para el intercambio de datos de OAuth), use . Para cargar archivos o datos mixtos, Alamofire proporciona que construye una solicitud de varias partes. Ejemplo:

AF.upload(multipartFormData: { multipartFormData in
 multipartFormData.append(Data("Jane Doe".utf8), withName: "name")
 multipartFormData.append(imageData, withName: "avatar", fileName: "avatar.jpg", mimeType: "image/jpeg")
}, to: "https://api.example.com/users")
 .validate()
 .responseDecodable(of: User.self) { response in
 // handle response
 }

Trabajando con otros métodos HTTP

Las API RESTful a menudo requieren PUT (actualización completa), PATCH (actualización parcial), y las operaciones DELETE (removalación). Alamofire maneja estos con el mismo método ; simplemente cambiar el parámetro .

PUT y PATCH

Para actualizar un recurso existente, utilice o . El cuerpo de solicitud contiene los campos actualizados:

let updatedFields: [String: Any] = ["name": "Jane Smith"]
AF.request("https://api.example.com/users/123",
 method: .patch,
 parameters: updatedFields,
 encoding: JSONEncoding.default)
 .validate()
 .responseDecodable(of: User.self) { response in
 // handle updated user
 }

DELETE

Eliminar un recurso normalmente no requiere un órgano de solicitud. La respuesta podría estar vacía o devolver un mensaje de confirmación:

AF.request("https://api.example.com/users/123",
 method: .delete)
 .validate()
 .response { response in
 if let error = response.error {
 print("Delete failed: \(error)")
 } else {
 print("User deleted successfully")
 }
 }

Compruebe siempre la documentación de la API para los códigos de estado esperados (por ejemplo, 204 No Contenido).

Control avanzado de la gestión de errores y la red

El manejo de errores robusto es crítico para una experiencia de usuario sin problemas. Los errores de Alamofire reportan errores a través del tipo , que diferencia entre errores de red (timeout, no conexión), errores de servidor (código de estado de riesgo), y fallos de serialización (invalido JSON).

switch response.result {
case .success(let value):
 // handle success
case .failure(let error):
 if let afError = error.asAFError {
 switch afError {
 case .sessionTaskFailed(let sessionError):
 print("Network issue: \(sessionError.localizedDescription)")
 case .responseValidationFailed(let reason):
 print("Validation failed: \(reason)")
 default:
 print("Other Alamofire error: \(afError.localizedDescription)")
 }
 }
}

Capacidad de la red

Antes de hacer solicitudes, es posible que desee comprobar la disponibilidad de la red. Los controles de conectividad de Alamofire comienzan a monitorizarse temprano en su ciclo de vida de la aplicación:

let reachabilityManager = NetworkReachabilityManager()
reachabilityManager?.startListening { status in
 switch status {
 case .notReachable:
 print("Network is not reachable")
 case .reachable(.cellular):
 print("Connected via cellular")
 case .reachable(.ethernetOrWiFi):
 print("Connected via WiFi")
 case .unknown:
 print("Unknown status")
 }
}

Utilice esto para informar al usuario o aplazar solicitudes. Para patrones más avanzados, considere combinar la posibilidad de llegar a un mecanismo de reingreso, como la retrigación de solicitudes fallidas cuando se restablezca la conectividad.

Mejores prácticas para la creación de redes de lectura

Siguiendo los patrones establecidos mantendrá su capa de red mantenible, segura y performant.

1. Adoptar modelos de codificación

Definir siempre los tipos de Swift que se conforman con (o ]) para el análisis de respuestas. Esto elimina la manipulación manual de JSON y reduce los errores. Uso o el nivel inferior si necesita contenido dinámico. Guía de Apple

2. Autenticación más segura y gestión de token

Nunca codificar las teclas o fichas de API. Almacene valores sensibles en la cadena de llaves y adjuntelas a las solicitudes a través del encabezado . Para los flujos OAuth, implemente un interceptor de refresco de token. El protocolo Alamofire le permite reintentar automáticamente las solicitudes después de obtener un nuevo token.

class AuthInterceptor: RequestInterceptor {
 func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
 var request = urlRequest
 request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
 completion(.success(request))
 }

 func retry(_ request: Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void) {
 // Check if error is 401, refresh token, then retry
 completion(.retryWithDelay(1.0))
 }
}

3. Concurrencia con la asinc/await

Alamofire 5 admite completamente el modelo de concurrencia de Swift. Utilice las versiones de los métodos de solicitud para escribir más limpio, código lineal:

do {
 let users = try await AF.request("https://api.example.com/users")
 .serializingDecodable([User].self)
 .value
 print("Users: \(users)")
} catch {
 print("Error: \(error)")
}

Combina esto con la concurrencia estructurada (grupos de tareas, actores) para gestionar múltiples solicitudes y evitar el infierno de llamada.

4. Implementar el caché

Para reducir las llamadas de red y mejorar el soporte offline, configura las políticas de caché. Alamofire respeta la (por ejemplo, ). También puede utilizar una medida con una capacidad de disco adecuada:

let cache = URLCache(memoryCapacity: 10 * 1024 * 1024,
 diskCapacity: 50 * 1024 * 1024,
 diskPath: "networking_cache")
let session = Session(configuration: URLSessionConfiguration.default)
session.sessionConfiguration.urlCache = cache

5. Prueba tu capa de red

Escribe pruebas unitarias para tus clientes de API usando datos de mock. La de Alamofire puede inyectarse con un protocolo de mock que devuelve respuestas predefinidas. Considera usar bibliotecas como o la abstracción incorporada . El análisis asegura que tu manejo de errores y la lógica de parsing son correctas sin golpear puntos de extremo reales.

6. Use un Administrador de Redes Centralizado

Crear una única clase que configura una instancia con URL base, encabezados, interceptores y una caché compartida. Esto evita la duplicación y hace que sea fácil cambiar políticas o burlar toda la capa. Ejemplo:

class APIClient {
 static let shared = APIClient()
 private let session: Session

 private init() {
 let config = URLSessionConfiguration.default
 config.timeoutIntervalForRequest = 30
 config.urlCache = URLCache.shared
 session = Session(configuration: config, interceptor: AuthInterceptor())
 }

 func fetchUsers() async throws -> [User] {
 return try await session.request("\(baseURL)/users")
 .serializingDecodable([User].self)
 .value
 }
}

Para una comprensión completa de los patrones de networking, consulte la Alamofire Advanced Usage documentation. Además, el tutorial de API de RET en restfulapi.net ofrece valiosas ideas sobre la elaboración de APIs robustas.

Siguiendo estas directrices y aprovechando la API expresiva de Alamofire, puede crear una capa de red que sea potente y fácil de mantener. La biblioteca abstrae muchos de los aspectos tediosos de la carga de URL mientras le da pleno control cuando lo necesita.