Alamofire के साथ शुरू हो रहा है

अपने आईओएस परियोजना में अल्मोफायर को एकीकृत करने के लिए, आप Swift पैकेज मैनेजर, कोकोआपोड्स, या कैथेज का उपयोग करके लाइब्रेरी जोड़ सकते हैं। स्विफ्ट पैकेज मैनेजर अनुशंसित दृष्टिकोण है क्योंकि यह Xcode में बनाया गया है। File[[[FLT1]] → ]]Ad Packages]]]] और repository URL ]]] में प्रवेश करने के लिए अल्मोफायर पैकेज जोड़ें। संस्करण 5.0.0 या बाद में निर्दिष्ट करें। वैकल्पिक रूप से, यदि आप CocoaPods का उपयोग करते हैं, तो आप किसी भी फ़ाइल चलाने की आवश्यकता है।

import Alamofire

Alamofire's alias सभी आम HTTP आपरेशनों के लिए एक सुविधाजनक प्रवेश बिंदु प्रदान करता है। हुड के तहत, यह एप्पल के का उपयोग करता है, लेकिन दूर बॉयलरप्लेट जैसे कतार प्रबंधन, पैरामीटर एन्कोडिंग, और प्रतिक्रिया सत्यापन को अमूर्त करता है। यह आपको नेटवर्किंग प्लंबिंग के बजाय व्यावसायिक तर्क पर ध्यान केंद्रित करने की अनुमति देता है। अंतर्निहित नेटवर्किंग परत पर आगे के विवरण के लिए, Apple के URLSession प्रलेखन का उल्लेख करें।

GET अनुरोध करना

एक RESTful समापन बिंदु से डेटा को आकर्षित करना सबसे आम ऑपरेशन है। Alamofire GET अनुरोधों को संक्षिप्त और पठनीय बनाता है। निम्नलिखित उदाहरण एक hypothetical API से उपयोगकर्ताओं की एक सूची को पुनर्प्राप्त करता है:

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)")
 }
 }

का उपयोग नोटिस, जो स्विफ्ट के प्रोटोकॉल को स्वचालित रूप से मॉडल ऑब्जेक्ट्स में JSON को पार करने के लिए ले जाता है। struct को परिभाषित करें जो [[FLT: 10]] (या [[FLT: 11]]]]]) के अनुरूप है। यह दृष्टिकोण मैनुअल JSON सीरियलाइजेशन को समाप्त करता है और प्रकार की सुरक्षा में सुधार करता है।

Query पैरामीटर्स और हेडर जोड़ना

कई REST APIs को क्वेरी पैरामीटर या कस्टम HTTP हेडर की आवश्यकता होती है। Alamofire एक शब्दकोश के रूप में मापदंडों को स्वीकार करता है और स्वचालित रूप से GET अनुरोधों के लिए एन्कोडिंग करता है (parameters URL के लिए appended हैं)। हेडर को पैरामीटर के माध्यम से जोड़ा जाता है:

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 स्वचालित रूप से पैरामीटर को URL-encodes करता है और उन्हें अनुरोध URL पर संलग्न करता है। कस्टम एन्कोडिंग के लिए, आप एक स्पष्ट उदाहरण निर्दिष्ट कर सकते हैं, जैसे ]।

प्रतिक्रिया सत्यापन

] विधि स्वचालित रूप से 200-299 रेंज में HTTP स्टेटस कोड के लिए जांच करती है और एक गैर-समायोज्य सामग्री प्रकार के साथ प्रतिक्रियाओं को अस्वीकार करती है। आप कस्टम सत्यापन मानदंड भी जोड़ सकते हैं। उदाहरण के लिए, केवल 200 और 201 स्टेटस कोड स्वीकार करने के लिए:

.validate(statusCode: [200, 201])

सत्यापन विफलताओं को प्रतिक्रिया हैंडलर में त्रुटियों के रूप में रिपोर्ट किया जाता है, जिससे आप अपने आवेदन के दौरान लगातार त्रुटि हैंडलिंग को लागू कर सकते हैं।

POST Data

संसाधनों को बनाने या अद्यतन करने के लिए आम तौर पर एक अनुरोध निकाय के साथ POST अनुरोध की आवश्यकता होती है। Alamofire एकाधिक एन्कोडिंग रणनीतियों का समर्थन करता है, साथ ही REST APIs के लिए सबसे आम है। निम्नलिखित उदाहरण सर्वर को एक नया उपयोगकर्ता ऑब्जेक्ट भेजता है:

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)")
 }
 }

यदि API URL-encoded form data (जैसे OAuth टोकन एक्सचेंज के लिए) की उम्मीद करता है, तो इसके बजाय का उपयोग करें। फ़ाइल अपलोड या मिश्रित डेटा के लिए, Alamofire प्रदान करता है जो एक बहुपक्ष अनुरोध का निर्माण करता है। उदाहरण:

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
 }

अन्य HTTP तरीकों के साथ काम करना

RESTful APIs अक्सर PUT (पूर्ण अद्यतन), PATCH (आंशिक अद्यतन) और DELETE (हटाने वाला) संचालन की आवश्यकता होती है। Alamofire इन को उसी विधि के साथ संभालती है; बस ] पैरामीटर को बदल देती है।

पुटी और पैच

मौजूदा संसाधन को अद्यतन करने के लिए, या ] का उपयोग करें। अनुरोध निकाय में अद्यतन फ़ील्ड शामिल हैं:

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
 }

डीलैट

एक संसाधन को हटाने के लिए आम तौर पर कोई अनुरोध निकाय की आवश्यकता नहीं होती है। प्रतिक्रिया खाली हो सकती है या एक पुष्टिकरण संदेश वापस कर सकती है:

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")
 }
 }

हमेशा अपेक्षित स्टेटस कोड (जैसे 204 No Content) के लिए API डॉक्यूमेंटेशन की जांच करें।

उन्नत त्रुटि हैंडलिंग और नेटवर्क मॉनिटरिंग

रॉबस्ट त्रुटि हैंडलिंग एक सहज उपयोगकर्ता अनुभव के लिए महत्वपूर्ण है। Alamofire ने [[FLT: 29]] प्रकार के माध्यम से त्रुटियों की रिपोर्ट की, जो नेटवर्क त्रुटियों (टाइमआउट, कोई कनेक्शन नहीं), सर्वर त्रुटियों (बाद का स्टेटस कोड) और सीरियलाइजेशन विफलताओं (invalid 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)")
 }
 }
}

नेटवर्क पहुंच

अनुरोध करने से पहले, आप नेटवर्क उपलब्धता की जांच कर सकते हैं। Alamofire के की निगरानी कनेक्टिविटी में बदलाव। अपने ऐप लाइफसाइकिल में जल्दी निगरानी शुरू करें:

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")
 }
}

उपयोगकर्ता या पोस्टपोन अनुरोध को सूचित करने के लिए इसका उपयोग करें। अधिक उन्नत पैटर्न के लिए, एक पुनः प्रयास तंत्र के साथ पहुंच को जोड़ने पर विचार करें, जैसे कि कनेक्टिविटी बहाल होने पर असफल अनुरोधों को फिर से बहाल करना।

उत्पादन-Ready नेटवर्किंग के लिए सर्वश्रेष्ठ अभ्यास

निम्नलिखित स्थापित पैटर्न आपके नेटवर्किंग परत को बनाए रखने योग्य, सुरक्षित और प्रदर्शनकारी बनाए रखेगा।

1. कोडाबल मॉडल को अपनाने

हमेशा स्विफ्ट प्रकार को परिभाषित करते हैं जो (या ]]) के अनुरूप प्रतिक्रिया के लिए पार्सिंग। यह मैनुअल JSON हेरफेर को समाप्त करता है और बग को कम करता है। का प्रयोग करें या निम्न स्तर ]]] यदि आपको गतिशील सामग्री की आवश्यकता है। Apple's ]Codable गाइड कस्टम कुंजी के साथ उन्नत मानचित्रण को कवर करता है।

2. सुरक्षित प्रमाणीकरण और टोकन प्रबंधन

कभी हार्डकोड एपीआई कुंजी या टोकन नहीं। कीचेन में संवेदनशील मूल्यों को स्टोर करें और उन्हें [[FLT: 37]]] हेडर के माध्यम से अनुरोध करने के लिए संलग्न करें। ओएथ प्रवाह के लिए, एक टोकन रिफ्रेश इंटरसेप्टर को लागू करें। अल्मोफायर के [[FLT: 38]] प्रोटोकॉल आपको एक नया टोकन प्राप्त करने के बाद स्वचालित रूप से अनुरोधों को पुनः प्राप्त करने की अनुमति देता है। नमूना कंकाल:

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. async/await के साथ concurrency

Alamofire 5 पूरी तरह से स्विफ्ट के परंपरागत मॉडल का समर्थन करता है। क्लीनर, रैखिक कोड लिखने के लिए अनुरोध विधियों के संस्करण का उपयोग करें:

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

इसे कई अनुरोधों का प्रबंधन करने और कॉलबैक हेल से बचने के लिए संरचित समवर्ती (टस्क समूह, अभिनेता) के साथ मिलाएं।

4. Caching लागू करें

नेटवर्क कॉल को कम करने और ऑफ़लाइन समर्थन में सुधार करने के लिए, कैशिंग नीतियों को कॉन्फ़िगर करें। Alamofire (जैसे, ]]]]]] का सम्मान करता है। आप एक उचित डिस्क क्षमता के साथ एक कस्टम ] का भी उपयोग कर सकते हैं:

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. अपने नेटवर्किंग परत का परीक्षण

अपने एपीआई ग्राहकों के लिए नकली डेटा का उपयोग करने के लिए यूनिट परीक्षण लिखें। Alamofire के को नकली प्रोटोकॉल के साथ इंजेक्शन दिया जा सकता है जो पूर्व-परिभाषित प्रतिक्रियाओं को वापस ले जाता है। लाइक पुस्तकालयों का उपयोग करने पर विचार करें या निर्मित ]] अमूर्तता। परीक्षण वास्तविक समापन बिंदुओं को हिट किए बिना आपकी त्रुटि हैंडलिंग और तर्क को पार करने के लिए सही है।

6. एक केंद्रीय नेटवर्किंग प्रबंधक का उपयोग करें

एक एकल वर्ग है कि एक ]] के आधार यूआरएल, हेडर, इंटरसेप्टर और एक साझा कैश के साथ उदाहरण को कॉन्फ़िगर करता है। यह दोहराव को रोकता है और नीतियों को स्वैप करने या पूरी परत का मजाक करने में आसान बनाता है। उदाहरण:

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
 }
}

नेटवर्किंग पैटर्न की व्यापक समझ के लिए, ]Alamofire उन्नत उपयोग प्रलेखन को संदर्भित करें। इसके अतिरिक्त, ]REST API ट्यूटोरियल on restfulapi.net] मजबूत एपीआई डिजाइन करने में मूल्यवान अंतर्दृष्टि प्रदान करता है।

इन दिशानिर्देशों का पालन करके और अल्मोफायर के अभिव्यक्तिपूर्ण एपीआई का लाभ उठाकर, आप एक नेटवर्किंग परत बना सकते हैं जो दोनों शक्तिशाली और बनाए रखने में आसान है। पुस्तकालय यूआरएल लोडिंग के कई टेढ़े पहलुओं को दूर करता है जबकि आपको इसकी आवश्यकता होने पर पूर्ण नियंत्रण देता है।