एपीआई अनुरोधों के लिए कोडेबल और कोड को क्रम में कैसे रखा जाए

नमस्कार, हेब्र!

स्विफ्ट 4 के साथ शुरू, हमारे पास नए कोडेबल प्रोटोकॉल तक पहुंच है, जो मॉडल को एनकोड / डिकोड करना आसान बनाता है। मेरी परियोजनाओं में एपीआई कॉल के लिए बहुत सारे कोड हैं, और पिछले साल मैंने कोड के इस विशाल सरणी को दोहराने, कोड को मारने और मल्टीपार्ट अनुरोधों और url मापदंडों के लिए भी कोडेबल का उपयोग करके बहुत हल्के, संक्षिप्त और सरल में बहुत से काम करने के लिए किया है। सर्वर से अनुरोध और पार्सिंग प्रतिक्रियाएं भेजने के लिए मेरी राय में यह कई उत्कृष्ट कक्षाएं थीं। साथ ही एक सुविधाजनक फ़ाइल संरचना, जो अनुरोधों के प्रत्येक समूह के लिए नियंत्रक है, जिसे मैंने बैकेंड पर वाष्प 3 का उपयोग करते समय रूट किया था। कुछ दिनों पहले, मैंने अपने सभी घटनाक्रमों को एक अलग पुस्तकालय को आवंटित किया और इसे कोडीफायर नाम दिया। मैं इस लेख में उसके बारे में बात करना चाहूंगा।

त्याग

कोडीफायर अलमोफायर पर आधारित है, लेकिन यह आलमोफायर पर सिर्फ एक आवरण से अधिक है, यह आईओएस के लिए रीस्ट एपीआई के साथ काम करने के लिए एक पूरी प्रणाली दृष्टिकोण है। यही कारण है कि मुझे चिंता नहीं है कि अल्मोफायर पांचवें संस्करण को देख रहा है जिसमें कोडेबल समर्थन होगा, क्योंकि यह मेरी रचना को नहीं मारेगा।

प्रारंभ

आइए, थोड़ी दूर से शुरू करें, अर्थात् हमारे पास अक्सर तीन सर्वर होते हैं:

देव - विकास के लिए, जो हम Xcode से शुरू करते हैं
स्टेज - रिलीज से पहले परीक्षण के लिए, आमतौर पर टेस्टफलाइट या इनहाउस में
ठेस - उत्पादन, AppStore के लिए

और कई आईओएस डेवलपर्स, निश्चित रूप से, पर्यावरण चर और Xcode में स्टार्टअप योजनाओं के अस्तित्व के बारे में जानते हैं, लेकिन मेरे (8+ वर्ष) के अभ्यास से, 90% डेवलपर्स मैन्युअल रूप से परीक्षण करते समय, या विधानसभा से पहले कुछ सर्वर में सही सर्वर लिखते हैं, और यह मैं इसे सही कैसे करना है, इसका एक अच्छा उदाहरण दिखा कर ठीक करना चाहूंगा।

डिफ़ॉल्ट रूप से कोडीयर स्वचालित रूप से यह निर्धारित करता है कि वर्तमान में किस वातावरण में एप्लिकेशन चल रहा है, यह इसे बहुत सरल बनाता है:

#if DEBUG //DEV environment #else if Bundle.main.appStoreReceiptURL?.lastPathComponent == "sandboxReceipt" { //TESTFLIGHT environment } else { //APPSTORE environment } #endif 

यह निश्चित रूप से हुड के तहत है, और ऐपडेलगेट में परियोजना में आपको केवल तीन URL पंजीकृत करने की आवश्यकता है

 import CodyFire @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { let dev = CodyFireEnvironment(baseURL: "http://localhost:8080") let testFlight = CodyFireEnvironment(baseURL: "https://stage.myapi.com") let appStore = CodyFireEnvironment(baseURL: "https://api.myapi.com") CodyFire.shared.configureEnvironments(dev: dev, testFlight: testFlight, appStore: appStore) return true } } 

और किसी को सिर्फ इस बारे में खुशी हो सकती है और कुछ नहीं।

लेकिन वास्तविक जीवन में, हमें अक्सर एक्सकोड में देव, मंच और ठेस सर्वर का परीक्षण करने की आवश्यकता होती है, और इसके लिए मैं आपसे स्टार्टअप योजनाओं का उपयोग करने का आग्रह करता हूं।

युक्ति: योजनाओं को प्रबंधित करें अनुभाग में, प्रत्येक योजना के लिए 'साझा किए गए' चेकबॉक्स की जांच करना न भूलें ताकि वे परियोजना के सभी डेवलपर्स के लिए उपलब्ध हों।

प्रत्येक योजना में, आपको पर्यावरण चर को लिखना होगा `env` जो तीन मान ले सकता है: dev, testFlight, appStore।



और कोडीफायर के साथ काम करने के लिए इन योजनाओं के लिए, आपको कोडीफ़ायर को शुरू करने के बाद AppDelegate.didFinishLaunchingWithOptions पर निम्न कोड जोड़ना होगा।

 CodyFire.shared.setupEnvByProjectScheme() 

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

 CodyFire.shared.environmentMode = .appStore 

एप्लिकेशन के पुनरारंभ होने तक यह काम करेगा, और यदि आप चाहते हैं कि लॉन्च के बाद इसे सहेजा जाए, तो UserDefaults में मान को सहेजें , जब AppDelegate में एप्लिकेशन शुरू होता है और पर्यावरण को आवश्यक एक पर स्विच करें।

मैंने इस महत्वपूर्ण बिंदु को बताया, मुझे उम्मीद है कि अधिक परियोजनाएं होंगी जिनमें पर्यावरण को सुंदर तरीके से बदलना होगा। और एक ही समय में, हमने पहले से ही पुस्तकालय को शुरू कर दिया है।

फ़ाइल संरचना और नियंत्रक

अब आप सभी API कॉल के लिए फ़ाइल संरचना के बारे में मेरी दृष्टि के बारे में बात कर सकते हैं, इसे कोडीफायर की विचारधारा कहा जा सकता है।

आइए देखें कि यह परियोजना में आखिर कैसा दिखता है



अब फाइल लिस्टिंग पर नजर डालते हैं, चलिए API.swift से शुरुआत करते हैं।

 class API { typealias auth = AuthController typealias post = PostController } 

सभी नियंत्रकों के लिंक यहां सूचीबद्ध हैं ताकि उन्हें आसानी से `API.controller.method` के माध्यम से बुलाया जा सके।

 class AuthController {} 

API + Login.swift

 extension AuthController { struct LoginResponse: Codable { var token: String } static func login(email: String, password: String) -> APIRequest<LoginResponse> { return APIRequest("login").method(.post) .basicAuth(email: email, password: password) .addCustomError(.notFound, "User not found") } } 

इस डेकोरेटर में, हम अपने एपीआई को कॉल करने के लिए एक फ़ंक्शन की घोषणा करते हैं:

- समापन बिंदु निर्दिष्ट करें
- HTTP POST विधि
- मूल स्थिति के लिए आवरण का उपयोग करें
- सर्वर से एक विशिष्ट प्रतिक्रिया के लिए वांछित पाठ घोषित करें (यह सुविधाजनक है)
- और उस मॉडल को इंगित करें जिसके द्वारा डेटा डिकोड किया जाएगा

क्या छिपा रहता है?

- पूर्ण सर्वर URL को निर्दिष्ट करने की आवश्यकता नहीं है, क्योंकि यह पहले से ही विश्व स्तर पर स्थापित है
- यह इंगित करने के लिए नहीं था कि अगर सब कुछ ठीक है तो हमें 200 ओके मिलने की उम्मीद है

200 OK सभी अनुरोधों के लिए कोडीफायर द्वारा अपेक्षित डिफ़ॉल्ट स्थिति कोड है, जिसमें डेटा को डिकोड किया जाता है और कॉलबैक कहा जाता है, कि सब कुछ ठीक है, यहां आपका डेटा है।

इसके अलावा, कहीं आपके LoginScreen के कोड में , आप बस कॉल कर सकते हैं

 API.auth.login(email: "test@mail.com", password: "qwerty").onError { error in switch error.code { case .notFound: print(error.description) //: User not found default: print(error.description) } }.onSuccess { token in //TODO:  auth token    print("Received auth token: "+ token) } 

onError और onSuccess केवल उन कॉलबैक का एक छोटा सा हिस्सा है जो APIRequest वापस आ सकते हैं, हम उनके बारे में बाद में बात करेंगे।

इनपुट उदाहरण में, हमने केवल विकल्प पर विचार किया जब लौटा डेटा स्वचालित रूप से डिकोड हो जाता है, लेकिन आप कह सकते हैं कि आप स्वयं इसे लागू कर सकते हैं, और आप सही होंगे। इसलिए, आइए एक उदाहरण के रूप में पंजीकरण फॉर्म का उपयोग करके मॉडल के अनुसार डेटा भेजने की संभावना पर विचार करें।

API + Signup.swift

 extension AuthController { struct SignupRequest: JSONPayload { let email, password: String let firstName, lastName, mobileNumber: String init(email: String, password: String, firstName: String, lastName: String, mobileNumber: String) { self.email = email self.password = password self.firstName = firstName self.lastName = lastName self.mobileNumber = mobileNumber } } struct SignupResponse: Codable { let token: String } static func signup(_ request: SignupRequest) -> APIRequest<SignupResponse> { return APIRequest("signup", payload: request).method(.post) .addError(.conflict, "Account already exists") } } 

लॉगिन के विपरीत, पंजीकरण के दौरान हम बड़ी मात्रा में डेटा संचारित करते हैं।

इस उदाहरण में, हमारे पास एक SignupRequest मॉडल है जो JSONPayload प्रोटोकॉल के अनुरूप है (इस प्रकार कोडीफ़ायर पेलोड प्रकार को समझता है) ताकि हमारे अनुरोध का मुख्य भाग JSON के रूप में हो। यदि आपको x-www-form-urlencoded की आवश्यकता है, तो FormURLEncodedPayload का उपयोग करें ।

नतीजतन, आपको एक सरल फ़ंक्शन मिलता है जो पेलोड मॉडल को स्वीकार करता है

 API.auth.signup(request) 

और जो सफल होने पर आपको एक विशिष्ट प्रतिक्रिया मॉडल लौटाएगा।

मुझे लगता है कि यह अच्छा है, है ना?

लेकिन क्या होगा अगर मल्टीपार्ट?

आइए एक उदाहरण देखें जब आप पोस्ट बना सकते हैं।

पोस्ट + Create.swift

 extension PostController { struct CreateRequest: MultipartPayload { var text: String var tags: [String] var images: [Attachment] var video: Data init (text: String, tags: [String], images: [Attachment], video: Data) { self.text = text self.tags = tags self.images = images self.video = video } } struct Post: Codable { let text: String let tags: [String] let linksToImages: [String] let linkToVideo: String } static func create(_ request: CreateRequest) -> APIRequest<CreateRequest> { return APIRequest("post", payload: request).method(.post) } } 

यह कोड छवि फ़ाइलों की एक सरणी और एक वीडियो के साथ एक मल्टीपार्ट फॉर्म भेजने में सक्षम होगा।
आइए देखें कि एक प्रेषण कैसे कॉल करें। यहां अटैचमेंट के बारे में सबसे दिलचस्प क्षण है।

 let videoData = FileManager.default.contents(atPath: "/path/to/video.mp4")! let imageAttachment = Attachment(data: UIImage(named: "cat")!.jpeg(.high)!, fileName: "cat.jpg", mimeType: .jpg) let payload = PostController.CreateRequest(text: "CodyFire is awesome", tags: ["codyfire", "awesome"], images: [imageAttachment], video: videoData) API.post.create(payload).onProgress { progress in print(" : \(progress)") }.onError { error in print(error.description) }.onSuccess { createdPost in print("  : \(createdPost)") } 

अटैचमेंट एक मॉडल है, जिसमें डेटा के अलावा , फ़ाइल नाम और इसके माइमाइप को भी प्रसारित किया जाता है।

यदि आपने कभी भी Alamofire या एक नग्न URLRequest का उपयोग करते हुए स्विफ्ट से एक मल्टीपार्ट फॉर्म जमा किया है , तो मुझे यकीन है कि आप CodyFire की सादगी की सराहना करेंगे।

अब सरल लेकिन GET कॉल का कोई कम शांत उदाहरण नहीं है।

पोस्ट + Get.swift

 extension PostController { struct ListQuery: Codable { let offset, limit: Int init (offset: Int, limit: Int) { self.offset = offset self.limit = limit } } static func get(_ query: ListQuery? = nil) -> APIRequest<[Post]> { return APIRequest("post").query(query) } static func get(id: UUID) -> APIRequest<Post> { return APIRequest("post/" + id.uuidString) } } 

सबसे सरल उदाहरण है

 API.post.get(id:) 

जो onSuccess में पोस्ट मॉडल आपको लौटा देगा।

यहाँ एक और दिलचस्प उदाहरण है।

 API.post.get(PostController.ListQuery(offset: 0, limit: 100)) 

जो इनपुट के रूप में एक सूचिबद्ध मॉडल लेता है,
जो APIRequest अंततः फ़ॉर्म के URL पथ में परिवर्तित हो जाता है

 post?limit=0&offset=100 

और onSuccess में [पोस्ट] सरणी लौटाएगा।

बेशक, आप पुराने तरीके से URL पथ लिख सकते हैं, लेकिन अब आप जानते हैं कि आप पूरी तरह से कोडेबल हो सकते हैं।

अंतिम उदाहरण अनुरोध DELETE होगा

पोस्ट + Delete.swift

 extension PostController { static func delete(id: UUID) -> APIRequest<Nothing> { return APIRequest("post/" + id.uuidString) .method(.delete) .desiredStatusCode(.noContent) } } 

दो दिलचस्प बिंदु हैं।

- रिटर्न प्रकार APIRequest है, यह जेनेरिक प्रकार कुछ नहीं निर्दिष्ट करता है, जो एक खाली कोडेबल मॉडल है।
- हमने स्पष्ट रूप से संकेत दिया था कि हम 204 NO CONTENT प्राप्त करने की उम्मीद करते हैं, और कोडीफायर केवल इस मामले में असफल कॉल करेगा।

आप पहले से ही अपने ViewController से इस समापन बिंदु कॉल करने के लिए कैसे पता है।

लेकिन दो विकल्प हैं, पहला onSuccess के साथ, और दूसरा बिना। हम उसे देखेंगे

 API.post.delete(id:).execute() 

यही है, अगर यह आपके लिए मायने नहीं रखता है कि क्या अनुरोध बाहर काम करता है, तो आप बस इस पर .execute () कॉल कर सकते हैं और यह है, अन्यथा यह हैंडलर की असफल घोषणा के बाद शुरू होगा।

उपलब्ध कार्य

प्रत्येक अनुरोध का प्राधिकरण

किसी भी http-हेडर के साथ प्रत्येक अनुरोध एपीआई पर हस्ताक्षर करने के लिए, एक वैश्विक हैंडलर का उपयोग किया जाता है, जिसे आप ऐपडेलेगेट में कहीं सेट कर सकते हैं । इसके अलावा, आप क्लासिक [स्ट्रिंग: स्ट्रिंग] या कोडेबल मॉडल का उपयोग कर सकते हैं।

प्राधिकरण बियरर के लिए उदाहरण।

1. कोडेबल (अनुशंसित)

 CodyFire.shared.fillCodableHeaders = { struct Headers: Codable { //NOTE:  nil,     headers var Authorization: String? var anythingElse: String } return Headers(Authorization: nil, anythingElse: "hello") } 

2. क्लासिक [स्ट्रिंग: स्ट्रिंग]

 CodyFire.shared.fillHeaders = { guard let apiToken = LocalAuthStorage.savedToken else { return [:] } return ["Authorization": "Bearer \(apiToken)"] } 

अनुरोध पर कुछ http-headers जोड़ें

यह किया जा सकता है जब APIRequest बनाते हैं, उदाहरण के लिए:

 APIRequest("some/endpoint").headers(["someKey": "someValue"]) 

अनधिकृत अनुरोधों को संभालना

आप उन्हें विश्व स्तर पर संसाधित कर सकते हैं, उदाहरण के लिए AppDelegate में

 CodyFire.shared.unauthorizedHandler = { //   WelcomeScreen } 

या स्थानीय रूप से प्रत्येक अनुरोध में

 API.post.create(request).onNotAuthorized { //   } 

यदि नेटवर्क उपलब्ध नहीं है

 API.post.create(request). onNetworkUnavailable { //   ,  ,     } 

अन्यथा onrrror में आपको एक त्रुटि मिलती है ।_notConnectedToInternet

अनुरोध शुरू होने से पहले कुछ शुरू करना

आप .onRequestStarted को सेट कर सकते हैं और दिखाना शुरू कर सकते हैं, उदाहरण के लिए, इसमें लोडर।
यह एक सुविधाजनक जगह है, क्योंकि इसे इंटरनेट की कमी के मामले में नहीं कहा जाता है, और आपको लोडर प्रदर्शित करने के लिए व्यर्थ नहीं दिखाना होगा, उदाहरण के लिए।

विश्व स्तर पर लॉग आउटपुट को अक्षम / सक्षम कैसे करें

 CodyFire.shared.logLevel = .debug CodyFire.shared.logLevel = .error CodyFire.shared.logLevel = .info CodyFire.shared.logLevel = .off 

किसी एकल अनुरोध के लिए लॉग आउटपुट को अक्षम कैसे करें

 .avoidLogError() 

प्रक्रिया अपने तरीके से लॉग करती है

 CodyFire.shared.logHandler = { level, text in print("  CodyFire: " + text) } 

सर्वर का अपेक्षित http प्रतिक्रिया कोड कैसे सेट करें

जैसा कि मैंने ऊपर कहा था, डिफ़ॉल्ट रूप से, कोडीफायर को 200 ओके प्राप्त होने की उम्मीद है , और यदि ऐसा होता है, तो यह डेटा को पार्स करना शुरू कर देता है और ऑनस्काउट को कॉल करता है।

लेकिन अपेक्षित कोड को सुविधाजनक एनुम के रूप में सेट किया जा सकता है, उदाहरण के लिए, 201 के लिए

 .desiredStatusCode(.created) 

या आप कस्टम अपेक्षित कोड भी सेट कर सकते हैं

 .desiredStatusCode(.custom(777)) 

अनुरोध रद्द करें

 .cancel() 

और आप पता लगा सकते हैं कि .onCancellation हैंडलर घोषित करके अनुरोध रद्द कर दिया गया था

 .onCancellation { //   } 

अन्यथा ऑनरर को उठाया जाएगा

एक अनुरोध के लिए एक समय सीमा निर्धारित करना

 .responseTimeout(30) //   30  

हैंडलर को टाइमआउट इवेंट में भी लटका दिया जा सकता है

 . onTimeout { //    } 

अन्यथा ऑनरर को उठाया जाएगा

इंटरएक्टिव एक्स्ट्रा टाइमआउट सेट करना

यह मेरी पसंदीदा विशेषता है। यूएसए के एक ग्राहक ने एक बार मुझसे उसके बारे में पूछा था, क्योंकि उन्हें यह पसंद नहीं था कि लॉगिन फ़ॉर्म बहुत तेज़ी से काम करता है, उनकी राय में यह स्वाभाविक नहीं लगता, जैसे कि यह एक नकली था, प्राधिकरण नहीं।

विचार यह है कि वह ईमेल / पासवर्ड की जांच पिछले 2 सेकंड या अधिक समय तक करना चाहता था। और अगर यह केवल 0.5 सेकंड तक रहता है, तो आपको एक और 1.5 फेंकने की आवश्यकता है और उसके बाद ही ऑनस्क्यू को कॉल करें। और अगर इसमें ठीक 2 या 2.5 सेकंड का समय लगता है, तो तुरंत onSuccess पर कॉल करें।

 .additionalTimeout(2) // 2     

कस्टम दिनांक एनकोडर / डिकोडर

CodyFire की अपनी DateCodingStrategy एनम है, जिसमें तीन मान हैं

- secondsSince1970
- मिलीसेकंडसंस 1970
- स्वरूपित (_ customDateFormatter: DateFormatter)

DateCodingStrategy को तीन तरीकों से और अलग से डिकोडिंग और एन्कोडिंग के लिए सेट किया जा सकता है
- विश्व स्तर पर AppDelegate में

 CodyFire.shared.dateEncodingStrategy = .secondsSince1970 let customDateFormatter = DateFormatter() CodyFire.shared.dateDecodingStrategy = .formatted(customDateFormatter) 

- एक अनुरोध के लिए

 APIRequest("some/endpoint") .dateDecodingStrategy(.millisecondsSince1970) .dateEncodingStrategy(.secondsSince1970) 

- या यहां तक ​​कि प्रत्येक मॉडल के लिए अलग से, आपको बस CustomDateEncodingStrategy और / या CustomDateDecodingStrategy से मिलान करने के लिए मॉडल की आवश्यकता है।

 struct SomePayload: JSONPayload, CustomDateEncodingStrategy, CustomDateDecodingStrategy { var dateEncodingStrategy: DateCodingStrategy var dateDecodingStrategy: DateCodingStrategy } 

प्रोजेक्ट में कैसे जोड़ें

पुस्तकालय MIT लाइसेंस के तहत GitHub पर उपलब्ध है।

इंस्टॉलेशन वर्तमान में केवल CocoaPods के माध्यम से उपलब्ध है

 pod 'CodyFire' 

मुझे वास्तव में उम्मीद है कि कोडीफायर अन्य आईओएस डेवलपर्स के लिए उपयोगी होगा, यह उनके लिए विकास को सरल करेगा, और सामान्य तौर पर दुनिया को थोड़ा बेहतर और लोगों को दयालु बना देगा।

यह सब, आपके समय के लिए धन्यवाद।

UPD: ReactiveCocoa और RxSwift का समर्थन जोड़ा गया

 pod 'ReactiveCodyFire' # ReactiveCocoa pod 'RxCodyFire' # RxSwift #      'CodyFire',     

ReactiveCoca के लिए सबसे अच्छा होगा .signalProducer , और RxSwwobservable के लिए।

UPD2: अब आप कई अनुरोध चला सकते हैं
यदि आपके लिए प्रत्येक प्रश्न का परिणाम प्राप्त करना महत्वपूर्ण है, तो .and () का उपयोग करें
इस मोड में अधिकतम, आप 10 अनुरोध तक चला सकते हैं, उन्हें एक के बाद एक सख्ती से निष्पादित किया जाएगा।

 API.employee.all() .and(API.office.all()) .and(API.car.all()) .and(API.event.all()) .and(API.post.all()) .onError { error in print(error.description) }.onSuccess { employees, offices, cars, events, posts in //    !!! } 

onRequestStarted, onNetworkUnavailable, onCancellation, onNotAuthorized, onTimeout भी उपलब्ध हैं।
onProgress - अभी भी विकास में

यदि आप अपने प्रश्नों के परिणामों की परवाह नहीं करते हैं, तो आप .flatten () का उपयोग कर सकते हैं

 [API.employee.all(), API.office.all(), API.car.all()].flatten().onError { print(error.description) }.onSuccess { print("flatten finished!") } 

उन्हें एक ही समय में चलाने के लिए बस .concurrent (द्वारा: 3) यह तीन अनुरोधों को एक साथ निष्पादित करने की अनुमति देगा, किसी भी संख्या को निर्दिष्ट किया जा सकता है।
असफल क्वेरी त्रुटियों को छोड़ने के लिए .avoidCancelOnError ()
प्रगति पाने के लिए, .onProgress जोड़ें

UPD3: अब आप प्रत्येक अनुरोध के लिए एक अलग सर्वर सेट कर सकते हैं
कहीं आवश्यक सर्वर पते बनाने के लिए आवश्यक है, उदाहरण के लिए

 let server1 = ServerURL(base: "https://server1.com", path: "v1") let server2 = ServerURL(base: "https://server2.com", path: "v1") let server3 = ServerURL(base: "https://server3.com") 

और अब आप एंडपॉइंट को निर्दिष्ट करने से पहले अनुरोध के प्रारंभ में उनका सही उपयोग कर सकते हैं

 APIRequest(server1, "endpoint", payload: payloadObject) APIRequest(server2, "endpoint", payload: payloadObject) APIRequest(server3, "endpoint", payload: payloadObject) 

या आप अनुरोध को शुरू करने के बाद सर्वर को निर्दिष्ट कर सकते हैं

 APIRequest("endpoint", payload: payloadObject).serverURL(server1)