URLSession — définition, API réseau et fonctionnement dans iOS

Qu'est-ce que URLSession ?

URLSession est une API pour les opérations réseau présentée par Apple dans iOS 7 et macOS 10.9. Elle a remplacé NSURLConnection et a fourni un modèle plus flexible et plus puissant pour travailler avec le réseau. La bibliothèque prend en charge HTTP/1.1, HTTP/2, HTTP/3 et WebSocket, ainsi que les sessions en arrière-plan pour le chargement de données.

Le principal avantage d'URLSession par rapport à l'ancien NSURLConnection est la prise en charge de plusieurs connexions simultanées via une seule session, des configurations personnalisables et la possibilité de mettre en pause et de reprendre les téléchargements. Une session regroupe un ensemble de tâches réseau avec des paramètres partagés : cache, politique de cookies, timeouts, certificats TLS.

Sous iOS, URLSession fonctionne avec le cache DNS système, la gestion de l'alimentation et les processus en arrière-plan. Lorsque l'application est minimisée, le système peut continuer à charger des données via une session en arrière-plan et, à la fin, notifier l'application via un gestionnaire d'achèvement. Les sessions en arrière-plan sont particulièrement utiles pour télécharger des fichiers volumineux, mettre à jour du contenu et synchroniser des données dans les applications de documents et de médias. Pour travailler avec des sessions en arrière-plan, vous devez implémenter URLSessionDelegate et passer un identifiant de configuration lors de la création de la session — le système utilise cet identifiant pour restaurer la session après un redémarrage de l'application.

Un avantage important d'URLSession est la prise en charge de HTTP/2 et HTTP/3. Le multiplexage HTTP/2 permet d'envoyer plusieurs requêtes sur une seule connexion TCP, réduisant ainsi la latence et la charge du serveur. HTTP/3, basé sur le protocole QUIC sur UDP, offre un établissement de connexion encore plus rapide en éliminant la poignée de main TCP.

Architecture d'URLSession

L'architecture d'URLSession se compose de trois composants clés : la configuration de session, la session elle-même et les tâches. Chaque composant est responsable d'un aspect de l'interaction réseau, et leur combinaison détermine le comportement de l'application lors du travail avec le réseau.

URLSessionConfiguration

La configuration définit les paramètres de la session — des timeouts aux politiques de cache. Il existe trois types : .default (standard avec cache disque), .ephemeral (sans sauvegarde du cache ni des cookies) et .background (pour les téléchargements en arrière-plan). Dans la configuration, vous pouvez spécifier le nombre maximum de connexions par hôte, le timeout de requête et de ressource, la politique TLS et les paramètres de proxy.

Types de URLSessionTask

URLSessionTask est la classe de base pour toutes les opérations réseau. Les principales sous-classes sont : URLSessionDataTask pour les requêtes GET et POST retournant des données en mémoire, URLSessionDownloadTask pour télécharger des fichiers sur le disque, URLSessionUploadTask pour envoyer des fichiers vers le serveur et URLSessionWebSocketTask pour travailler avec WebSocket depuis iOS 13.

Délégués d'URLSession

Le délégué de session reçoit des événements sur la progression des tâches : réception de données, achèvement du téléchargement, erreurs d'authentification, redirections. URLSessionDelegate et ses sous-protocoles permettent d'intercepter les certificats TLS lors de l'authentification, de gérer le cache des réponses via URLCache et de surveiller la progression du téléchargement des fichiers volumineux. Alternativement, des closures (gestionnaires d'achèvement) peuvent être utilisées pour les cas simples où le traitement d'événements intermédiaires n'est pas nécessaire.

Comment effectuer des requêtes avec URLSession

Le flux de travail de base avec URLSession est le suivant : créer une configuration, créer une session basée sur celle-ci, puis créer une tâche avec une requête URL via la session, et démarrer la tâche. Examinons un exemple de requête GET avec une closure. Ce modèle est utilisé dans la plupart des applications iOS pour récupérer des données depuis des API REST, charger des images et interagir avec des services cloud.

let url = URL(string: "https://api.example.com/users")!
let session = URLSession.shared
let task = session.dataTask(with: url) { data, response, error in
    guard let data = data, error == nil else {
        print("Error: \(error!.localizedDescription)")
        return
    }
    if let json = try? JSONSerialization.jsonObject(with: data) {
        print("JSON: \(json)")
    }
}
task.resume()

L'exemple utilise URLSession.shared — un singleton avec configuration .default pour les requêtes simples. dataTask crée une opération asynchrone mais ne la démarre pas — vous devez appeler resume(). La closure s'exécute après l'achèvement de la requête et retourne data, response ou error. Pour une session personnalisée avec votre propre configuration, utilisez l'initialiseur URLSession(configuration:), qui permet de définir les politiques de cache, les timeouts, les connexions maximales, les en-têtes HTTP par défaut et les paramètres de proxy pour toutes les tâches de la session. Cette approche vous donne un contrôle total sur le comportement réseau de votre application.

Téléchargement de fichiers via URLSession

URLSession prend en charge les téléchargements de fichiers avec possibilité de pause et de reprise, ainsi que les téléchargements en arrière-plan. DownloadTask enregistre le fichier dans un répertoire temporaire, et dans la closure d'achèvement, vous devez le déplacer vers un emplacement permanent.

let url = URL(string: "https://example.com/file.zip")!
let session = URLSession(configuration: .default)
let task = session.downloadTask(with: url) { location, _, _ in
    guard let location = location else { return }
    let destination = FileManager.default.temporaryDirectory
        .appendingPathComponent("file.zip")
    try? FileManager.default.moveItem(at: location, to: destination)
}
task.resume()

Le paramètre location dans la closure pointe vers un fichier temporaire qui doit être déplacé, sinon le système le supprimera après la sortie de la closure. Pour suivre la progression, utilisez le délégué URLSessionDownloadDelegate avec la méthode didWriteData, qui transmet le nombre d'octets écrits et la taille totale du fichier — ces données peuvent être utilisées pour afficher une barre de progression dans l'interface utilisateur. Les sessions en arrière-plan avec downloadTask permettent de continuer le téléchargement même après la minimisation de l'application, et à la fin, le système appelle le gestionnaire dans AppDelegate.

URLSession vs Alamofire

Alamofire est une bibliothèque Swift construite au-dessus d'URLSession qui offre une interface plus déclarative. Le choix entre l'API native et Alamofire dépend de la complexité du projet et des préférences de l'équipe.

Pour les projets simples, URLSession est suffisante et n'ajoute aucune dépendance. Alamofire se justifie dans les projets comportant de nombreuses requêtes réseau, une gestion complexe des erreurs et un besoin de syntaxe concise. Les deux technologies partagent la même base URLSessionConfiguration et sont compatibles entre elles. Lors du choix, considérez qu'URLSession est entièrement contrôlée par Apple et mise à jour avec iOS, tandis qu'Alamofire nécessite que les développeurs de la bibliothèque maintiennent la compatibilité avec les nouvelles versions du système d'exploitation.

Exemples de code URLSession

Swift moderne prend en charge async/await, ce qui rend les requêtes réseau plus lisibles par rapport aux closures. Regardons la même requête GET en utilisant la syntaxe asynchrone.

func fetchUsers() async throws -> [User] {
    let url = URL(string: "https://api.example.com/users")!
    let (data, _) = try await URLSession.shared.data(from: url)
    let users = try JSONDecoder().decode([User].self, from: data)
    return users
}

La méthode data(from:) est disponible depuis iOS 15 et macOS 12. Elle retourne un tuple (Data, URLResponse) et lance une erreur en cas de problème réseau. JSONDecoder avec un modèle Codable désérialise automatiquement la réponse — cela remplace le fastidieux JSONSerialization de l'exemple précédent.

Requête POST avec corps JSON

Pour les requêtes POST avec un corps JSON, on utilise URLRequest, où l'on configure la méthode, les en-têtes Content-Type et le corps de la requête en tant que Data. Async/await rend ce processus concis et clair, et la gestion des erreurs est simple via un bloc do-catch.

func createUser(name: String) async throws -> User {
    var request = URLRequest(url: URL(string: "https://api.example.com/users")!)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    let body = try JSONEncoder().encode(["name": name])
    request.httpBody = body
    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONDecoder().decode(User.self, from: data)
}