HTTP-Anfragen in Swift im Jahr 2025: Vom Anfänger zum Profi in 20 Minuten

Einleitung: Warum googeln Swift-Entwickler immer noch HTTP-Anfragen?

Wenn Sie jemals eine Swift-App geschrieben haben, die mit einem Server kommuniziert, sind Sie definitiv auf diese Frage gestoßen. Es scheint doch einfach, oder? Anfrage gesendet, Antwort erhalten. Aber in der Praxis öffnet jeder zweite Entwickler (selbst mit Erfahrung) Stack Overflow und sucht: "How to make HTTP request in Swift?". Und das ist völlig normal.

Warum? Weil sich das Swift-Ökosystem verändert. Gestern haben noch alle Closures und Delegates geschrieben. Heute ist es async/await. Und morgen kommt vielleicht etwas Neues. Im Jahr 2025 haben sich die Ansätze für Netzwerkanfragen etabliert, aber der Teufel steckt wie immer im Detail: Thread-Management, Fehlerbehandlung, Anfragen abbrechen, Testen.

In diesem Artikel behandeln wir die echten Best Practices für HTTP-Anfragen in Swift – von der grundlegenden URLSession bis hin zu fortgeschrittenen Techniken mit async/await und Bibliotheken. Sie erfahren, wie Sie sauberen, sicheren und leistungsfähigen Netzwerkcode schreiben. Los geht's!

1. URLSession: Das Fundament, das jeder kennen sollte

Beginnen wir mit dem Wichtigsten. Die Swift-Standardbibliothek (Foundation) enthält alles Notwendige für die Arbeit mit HTTP – die Klasse URLSession. Merken Sie sich: Für 90% der Aufgaben benötigen Sie keine Drittanbieter-Bibliotheken. URLSession ist ein mächtiges, flexibles und natives Werkzeug.

1.1. Einfache GET-Anfrage (alter Stil)

Erinnern wir uns, wie das früher gemacht wurde. Diesen Code können Sie immer noch in Legacy-Projekten finden:

let url = URL(string: "https://api.pythonlib.ru/users")!\nlet task = URLSession.shared.dataTask(with: url) { data, response, error in\n    if let error = error {\n        print("Fehler: \\(error.localizedDescription)")\n        return\n    }\n    guard let data = data else {\n        print("Keine Daten")\n        return\n    }\n    // Arbeiten mit data\n    print("Bytes empfangen: \\(data.count)")\n}\ntask.resume()

Dieser Code funktioniert. Aber er hat Nachteile:

\n
• Callback-Hölle – wenn eine Kette von Anfragen nötig ist, wird der Code unlesbar.
\n
• Speicherlecks – man vergisst leicht weak self im Closure.
\n
• Schwer abzubrechen – man muss eine Referenz auf task speichern.
\n

Im Jahr 2025 schreiben wir anders.

1.2. Moderne GET-Anfrage mit async/await

Seit Swift 5.5 (iOS 15, macOS 12) haben wir Structured Concurrency. Das ändert alles:

func fetchUsers() async throws -> [User] {\n    let url = URL(string: "https://api.pythonlib.ru/users")!\n    let (data, response) = try await URLSession.shared.data(from: url)\n    \n    guard let httpResponse = response as? HTTPURLResponse,\n          (200...299).contains(httpResponse.statusCode) else {\n        throw URLError(.badServerResponse)\n    }\n    \n    return try JSONDecoder().decode([User].self, from: data)\n}

Wunderschön, oder? Keine Closures, kein resume(). Der Code liest sich wie synchron, wird aber asynchron ausgeführt. Das ist der De-facto-Standard im Jahr 2025.

2. POST-Anfrage: Daten an den Server senden

Jetzt senden wir Daten. Angenommen, wir müssen einen neuen Benutzer erstellen.

2.1. POST mit JSON-Body

func createUser(name: String, email: String) async throws -> User {\n    let url = URL(string: "https://api.pythonlib.ru/users")!\n    var request = URLRequest(url: url)\n    request.httpMethod = "POST"\n    request.setValue("application/json", forHTTPHeaderField: "Content-Type")\n    \n    let body = ["name": name, "email": email]\n    request.httpBody = try JSONSerialization.data(withJSONObject: body)\n    \n    let (data, response) = try await URLSession.shared.data(for: request)\n    // Antwort verarbeiten...\n    return try JSONDecoder().decode(User.self, from: data)\n}

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Caching in C++: Redis, Memcached und integrierte Lösungen
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Parallelität und Multithreading in Kotlin: Fortgeschrittenes Niveau
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Generics in Kotlin: warum sie wichtig sind und wie man sie in der Praxis einsetzt
                                
                            
                                            
                

                
                

                    

                        Buchempfehlungen                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Nebenläufigkeit in JavaScript (Node.js)
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Java: Tipps und Best Practices. Fortgeschrittene Techniken und Code-Refactoring
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Spieleentwicklung mit Unity
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Practical Rust Projects
                                
                            
                                            
                
            
    

  
Lesen Sie auch
  

                
                  
                 WebSocket in TypeScript: Erstellung von Echtzeit-Anwendungen
      
                
                  
                 So bestehst du das Rust-Vorstellungsgespräch: Top-Fragen
      
                
                  
                 Kotlin im Jahr 2025: Was gibt es Neues? Ein vollständiger Leitfaden für Anfänger
      
                
                  
                 Metaprogrammierung in C++: Magie der Templates und fortgeschrittene Techniken
      
                
                  
                 Server-Sent Events in C#: Reaktives Web ohne WebSocket