Client HTTP pour Swift (iOS/macOS) : top bibliothèques |…

Meilleurs clients HTTP pour Swift (iOS/macOS) : guide complet

Lors du développement d'applications pour iOS et macOS, le travail en réseau est l'une des tâches clés. Le choix du bon client HTTP peut considérablement simplifier le code, améliorer les performances et la sécurité. Dans cet article, nous examinons les meilleures bibliothèques pour travailler avec les requêtes HTTP en Swift, leurs caractéristiques, des exemples d'utilisation et des recommandations de choix.

1. URLSession — le standard intégré

URLSession est le framework natif d'Apple, disponible sur toutes les plateformes (iOS, macOS, tvOS, watchOS). Il fournit une API puissante pour effectuer des requêtes réseau, télécharger des fichiers et gérer des sessions.

Avantages :

Ne nécessite pas l'installation de dépendances supplémentaires
Prise en charge complète du Swift moderne (async/await, Combine)
Configuration flexible de la mise en cache, des délais d'attente, des certificats
Faible surcharge — idéal pour les projets simples

Exemple d'utilisation avec async/await (Swift 5.5+) :

import Foundation

struct User: Codable {    let id: Int    let name: String    let email: String}

func fetchUser() async throws {    let url = URL(string: "https://jsonplaceholder.typicode.com/users/1")!    let (data, response) = try await URLSession.shared.data(from: url)        guard let httpResponse = response as? HTTPURLResponse,          (200...299).contains(httpResponse.statusCode) else {        throw URLError(.badServerResponse)    }        let user = try JSONDecoder().decode(User.self, from: data)    print("User: \\(user.name), email: \\(user.email)")}

URLSession est idéal pour les projets où une gestion complexe des erreurs ou une interception des requêtes n'est pas nécessaire. Cependant, pour les grandes applications avec de nombreux points de terminaison, il peut être trop verbeux.

2. Alamofire — puissant et populaire

Alamofire est la bibliothèque tierce la plus connue pour travailler avec HTTP en Swift. Elle est construite au-dessus d'URLSession, mais offre une API beaucoup plus pratique et déclarative.

Fonctionnalités clés :

Chaînage de requêtes et gestion des erreurs
Sérialisation/désérialisation JSON automatique
Prise en charge du téléchargement et de l'upload de fichiers avec progression
Intégration avec Combine et async/await
Architecture extensible via des intercepteurs

Exemple de requête POST avec Alamofire :

import Alamofire

struct LoginRequest: Encodable {    let username: String    let password: String}

struct LoginResponse: Decodable {    let token: String    let userId: Int}

func login(username: String, password: String) {    let parameters = LoginRequest(username: username, password: password)        AF.request("https://api.example.com/login",               method: .post,               parameters: parameters,               encoder: JSONParameterEncoder.default)    .validate()    .responseDecodable(of: LoginResponse.self) { response in        switch response.result {        case .success(let loginResponse):            print("Token: \\(loginResponse.token)")        case .failure(let error):            print("Error: \\(error.localizedDescription)")        }    }}

Alamofire est un excellent choix pour les projets de taille moyenne et grande, où la flexibilité, la commodité et la communauté sont nécessaires. Cependant, la bibliothèque ajoute environ 1 à 2 Mo à la taille de l'application.

3. Moya — abstraction au-dessus d'Alamofire

Moya est un autre niveau d'abstraction qui fonctionne au-dessus d'Alamofire. Son idée principale est de décrire tous les points de terminaison sous forme d'enum, ce qui rend le code plus sûr et plus prévisible.