Android के लिए HTTP क्लाइंट के रूप में Ktor

मुझे Android डेवलपर के रूप में Retrofit2 पसंद है, लेकिन Ktor HTTP क्लाइंट की गुणवत्ता प्राप्त करने के लिए क्या करना है? मेरी राय में, एंड्रॉइड के विकास के लिए यह कोई भी बदतर और बेहतर नहीं है, बस एक विकल्प है, हालांकि यदि आप सब कुछ थोड़ा लपेटते हैं, तो यह बहुत अच्छी तरह से बदल सकता है। मैं उन बुनियादी विशेषताओं पर विचार करूंगा जिनके साथ Ktor को HTTP क्लाइंट के रूप में उपयोग करना शुरू करना संभव होगा - विभिन्न प्रकार के अनुरोध बनाना, पाठ के रूप में कच्ची प्रतिक्रियाएं और उत्तर प्राप्त करना, कन्वर्टर्स के माध्यम से कक्षाओं में डसनरलाइज़ करना, और लॉगिंग।



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

Ktor ने कोटलिन 1.3 के कॉरआउट्स का उपयोग किया है, उपलब्ध कलाकृतियों की एक सूची यहां पाई जा सकती है , वर्तमान संस्करण 1.0.1 ।
प्रश्नों के लिए, मैं HttpBin का उपयोग करूंगा ।

सरल उपयोग

आरंभ करने के लिए, आपको एंड्रॉइड क्लाइंट के लिए बुनियादी निर्भरता की आवश्यकता होगी:

 implementation "io.ktor:ktor-client-core:1.0.1" implementation "io.ktor:ktor-client-android:1.0.1" 

मेनिफेस्ट में जानकारी जोड़ने के लिए मत भूलना कि आप इंटरनेट का उपयोग करते हैं।

 <uses-permission android:name="android.permission.INTERNET"/> 

चलो एक स्ट्रिंग के रूप में सर्वर प्रतिक्रिया प्राप्त करने का प्रयास करें, क्या आसान हो सकता है?

 private const val BASE_URL = "https://httpbin.org" private const val GET_UUID = "$BASE_URL/uuid" fun simpleCase() { val client = HttpClient() GlobalScope.launch(Dispatchers.IO) { val data = client.get<String>(GET_UUID) Log.i("$BASE_TAG Simple case ", data) } } 

आप मापदंडों के बिना एक ग्राहक बना सकते हैं, बस HttpClient() का एक उदाहरण बनाएं। इस स्थिति में, Ktor वांछित इंजन का चयन करेगा और इसे डिफ़ॉल्ट सेटिंग्स के साथ उपयोग करेगा (हमारे पास एक इंजन जुड़ा हुआ है - Android, लेकिन अन्य हैं, उदाहरण के लिए, OkHttp)।
कोरटाइन क्यों? क्योंकि get() एक suspend फंक्शन है।

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

हमें एक कच्चा जवाब मिलता है

कभी-कभी एक स्ट्रिंग के बजाय बाइट्स का एक सेट प्राप्त करना आवश्यक हो सकता है। इसी समय, अतुल्यकालिक के साथ प्रयोग करें।

 fun performAllCases() { GlobalScope.launch(Dispatchers.IO) { simpleCase() bytesCase() } } suspend fun simpleCase() { val client = HttpClient() val data = client.get<String>(GET_UUID) Log.i("$BASE_TAG Simple case", data) } suspend fun bytesCase() { val client = HttpClient() val data = client.call(GET_UUID).response.readBytes() Log.i("$BASE_TAG Bytes case", data.joinToString(" ", "[", "]") { it.toString(16).toUpperCase() }) } 

उन स्थानों पर जहां HttpClient विधियों को call() HttpClient , जैसे call() और get() , await() को हुड के नीचे बुलाया जाएगा। तो इस स्थिति में simpleCase() और bytesCase() लिए कॉल हमेशा अनुक्रमिक होंगे। आपको इसे समानांतर में चाहिए - बस प्रत्येक कॉल को एक अलग कोरटाइन में लपेटें। इस उदाहरण में, नए तरीके दिखाई दिए हैं। कॉलिंग call(GET_UUID) एक ऐसी वस्तु लौटाएगा जिससे हम अनुरोध, उसके कॉन्फ़िगरेशन, प्रतिक्रिया और क्लाइंट के बारे में जानकारी प्राप्त कर सकते हैं। ऑब्जेक्ट में बहुत सारी उपयोगी जानकारी होती है - एक ही बाइट्स के साथ चैनल के लिए प्रतिक्रिया कोड और प्रोटोकॉल संस्करण से।

क्या आपको इसे किसी तरह से बंद करने की आवश्यकता है?

डेवलपर्स इंगित करते हैं कि HTTP इंजन को सही ढंग से बंद करने के लिए, आपको क्लाइंट पर close() विधि को कॉल करना होगा। यदि आपको एक कॉल करने और तुरंत क्लाइंट को बंद करने की आवश्यकता है, तो आप उपयोग कर सकते use{} विधि, चूंकि HttpClient Closable इंटरफ़ेस को लागू करता है।

 suspend fun closableSimpleCase() { HttpClient().use { val data: String = it.get(GET_UUID) Log.i("$BASE_TAG Closable case", data) } } 

जीईटी के अलावा उदाहरण

मेरे काम में, दूसरा सबसे लोकप्रिय तरीका POST । मापदंडों, शीर्षकों और अनुरोध निकाय की स्थापना के उदाहरण पर विचार करें।

 suspend fun postHeadersCase(client: HttpClient) { val data: String = client.post(POST_TEST) { fillHeadersCaseParameters() } Log.i("$BASE_TAG Post case", data) } private fun HttpRequestBuilder.fillHeadersCaseParameters() { parameter("name", "Andrei") // +     url.parameters.appendAll( parametersOf( "ducks" to listOf("White duck", "Grey duck"), // +      "fish" to listOf("Goldfish") // +     ) ) header("Ktor", "https://ktor.io") // +  headers /*       */ { append("Kotlin", "https://kotl.in") } headers.append("Planet", "Mars") // +  headers.appendMissing("Planet", listOf("Mars", "Earth")) // +   , "Mars"   headers.appendAll("Pilot", listOf("Starman")) //     body = FormDataContent( //  ,     form Parameters.build { append("Low-level", "C") append("High-level", "Java") } ) } 

वास्तव में, post() के अंतिम पैरामीटर post() फ़ंक्शन में, आपके पास HttpRequestBuilder तक पहुंच है, जिसके साथ आप कोई भी अनुरोध बना सकते हैं।
post() विधि बस स्ट्रिंग को पार्स करती है, इसे URL में परिवर्तित करती है, स्पष्ट रूप से विधि का प्रकार सेट करती है, और एक अनुरोध करती है।

 suspend fun rawPostHeadersCase(client: HttpClient) { val data: String = client.call { url.takeFrom(POST_TEST) method = HttpMethod.Post fillHeadersCaseParameters() } .response .readText() Log.i("$BASE_TAG Raw post case", data) } 

यदि आप अंतिम दो विधियों से कोड निष्पादित करते हैं, तो परिणाम समान होगा। अंतर बहुत अच्छा नहीं है, लेकिन रैपर का उपयोग करना अधिक सुविधाजनक है। स्थिति put() , delete() , patch() , head() और options() , इसलिए हम उन पर विचार नहीं करेंगे।

हालांकि, अगर आप बारीकी से देखते हैं, तो आप देख सकते हैं कि टाइपिंग में अंतर है। जब आप कॉल call() तो आपको निम्न-स्तरीय उत्तर मिलता है और आपको स्वयं डेटा पढ़ना चाहिए, लेकिन स्वचालित टाइपिंग के बारे में क्या? आखिरकार, हम सभी को रेट्रोफिट 2 में एक कनवर्टर (जैसे Gson ) से जोड़ने और रिटर्न प्रकार को एक विशिष्ट वर्ग के रूप में इंगित करने के लिए उपयोग किया जाता है। हम बाद में कक्षाओं में परिवर्तित करने के बारे में बात करेंगे, लेकिन request विधि एक विशिष्ट HTTP विधि के लिए बाध्य किए बिना परिणाम को टाइप करने में मदद करेगी।

 suspend fun typedRawPostHeadersCase(client: HttpClient) { val data = client.request<String>() { url.takeFrom(POST_TEST) method = HttpMethod.Post fillHeadersCaseParameters() } Log.i("$BASE_TAG Typed raw post", data) } 

फॉर्म डेटा जमा करें

आमतौर पर आपको क्वेरी स्ट्रिंग या बॉडी में मापदंडों को पास करने की आवश्यकता होती है। ऊपर के उदाहरण में, हम पहले से ही जांच कर चुके हैं कि HttpRequestBuilder का उपयोग करके यह कैसे करें। लेकिन यह आसान हो सकता है।

submitForm फ़ंक्शन url को एक स्ट्रिंग के रूप में स्वीकार करता है, अनुरोध के लिए पैरामीटर और एक बूलियन ध्वज जो बताता है कि कैसे मापदंडों को पास करना है - अनुरोध पंक्ति में या प्रपत्र में जोड़े के रूप में।

 suspend fun submitFormCase(client: HttpClient) { val params = Parameters.build { append("Star", "Sun") append("Planet", "Mercury") } val getData: String = client.submitForm(GET_TEST, params, encodeInQuery = true) //     val postData: String = client.submitForm(POST_TEST, params, encodeInQuery = false) //   form Log.i("$BASE_TAG Submit form get", getData) Log.i("$BASE_TAG Submit form post", postData) } 

लेकिन मल्टीपार्ट / फॉर्म-डेटा का क्या?

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

 suspend fun submitFormBinaryCase(client: HttpClient) { val inputStream = ByteArrayInputStream(byteArrayOf(77, 78, 79)) val formData = formData { append("String value", "My name is") //   append("Number value", 179) //  append("Bytes value", byteArrayOf(12, 74, 98)) //   append("Input value", inputStream.asInput(), headersOf("Stream header", "Stream header value")) //    } val data: String = client.submitFormWithBinaryData(POST_TEST, formData) Log.i("$BASE_TAG Submit binary case", data) } 

जैसा कि आपने देखा होगा - आप प्रत्येक पैरामीटर में हेडर का एक सेट भी संलग्न कर सकते हैं।

कक्षा के उत्तर का वर्णन करें

आपको अनुरोध से कुछ डेटा प्राप्त करने की आवश्यकता है, न कि एक स्ट्रिंग या बाइट्स के रूप में, बल्कि तुरंत एक वर्ग में बदल दिया जाता है। दस्तावेज़ के साथ शुरू करने के लिए, हम सलाह देते हैं कि हम json के साथ काम करने के लिए एक सुविधा को जोड़ने की सलाह दें, लेकिन मैं एक आरक्षण बनाना चाहता हूं कि jvm को एक विशिष्ट निर्भरता की आवश्यकता होती है और kotlinx-serialization के बिना यह सब दूर नहीं होगा। मैं एक कनवर्टर के रूप में Gson का उपयोग करने का सुझाव देता हूं (प्रलेखन में अन्य समर्थित पुस्तकालयों के लिंक हैं, प्रलेखन के लिंक लेख के अंत में होंगे)।

बिल्ड.ग्रेड प्रोजेक्ट स्तर:

 buildscript { dependencies { classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version" } } allprojects { repositories { maven { url "https://kotlin.bintray.com/kotlinx" } } } 

build.gradle आवेदन स्तर:

 apply plugin: 'kotlinx-serialization' dependencies { implementation "io.ktor:ktor-client-json-jvm:1.0.1" implementation "io.ktor:ktor-client-gson:1.0.1" } 

अब अनुरोध पर अमल करें। नए से, क्लाइंट बनाते समय केवल Json के साथ काम करने की सुविधा का एक कनेक्शन होगा। मैं खुले मौसम एपीआई का उपयोग करूंगा। पूर्णता के लिए, मैं डेटा मॉडल दिखाऊंगा।

 data class Weather( val consolidated_weather: List<ConsolidatedWeather>, val time: String, val sun_rise: String, val sun_set: String, val timezone_name: String, val parent: Parent, val sources: List<Source>, val title: String, val location_type: String, val woeid: Int, val latt_long: String, val timezone: String ) data class Source( val title: String, val slug: String, val url: String, val crawl_rate: Int ) data class ConsolidatedWeather( val id: Long, val weather_state_name: String, val weather_state_abbr: String, val wind_direction_compass: String, val created: String, val applicable_date: String, val min_temp: Double, val max_temp: Double, val the_temp: Double, val wind_speed: Double, val wind_direction: Double, val air_pressure: Double, val humidity: Int, val visibility: Double, val predictability: Int ) data class Parent( val title: String, val location_type: String, val woeid: Int, val latt_long: String ) private const val SF_WEATHER_URL = "https://www.metaweather.com/api/location/2487956/" suspend fun getAndPrintWeather() { val client = HttpClient(Android) { install(JsonFeature) { serializer = GsonSerializer() } } val weather: Weather = client.get(SF_WEATHER_URL) Log.i("$BASE_TAG Serialization", weather.toString()) } 

और क्या कर सकते हैं

उदाहरण के लिए, सर्वर एक त्रुटि देता है, और आपके पास पिछले उदाहरण के रूप में कोड है। इस स्थिति में, आपको एक क्रमांकन त्रुटि प्राप्त होगी, लेकिन आप क्लाइंट को कॉन्फ़िगर कर सकते हैं ताकि प्रतिक्रिया कोड <300 होने पर BadResponseStatus त्रुटि को फेंक दिया जाए। क्लाइंट के निर्माण के दौरान यह expectSuccess लिए पर्याप्त है।

  val client = HttpClient(Android) { install(JsonFeature) { serializer = GsonSerializer() } expectSuccess = true } 

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

 implementation "io.ktor:ktor-client-logging-jvm:1.0.1" 

  val client = HttpClient(Android) { install(Logging) { logger = Logger.DEFAULT level = LogLevel.ALL } } 

हम DEFAULT लकड़हारे को निर्दिष्ट करते हैं और सब कुछ LogCat पर चला जाएगा, लेकिन यदि आप चाहें तो आप इंटरफ़ेस को फिर से परिभाषित कर सकते हैं और अपना खुद का लकड़हारा बना सकते हैं (हालांकि मुझे वहाँ कोई महान अवसर नहीं दिख रहा है, इनपुट पर केवल एक संदेश है, लेकिन कोई लॉग स्तर नहीं है)। हम लॉग के स्तर को भी दर्शाते हैं जिसे प्रतिबिंबित करने की आवश्यकता है।

संदर्भ:

• प्रलेखन
• ग्राहक कार्यान्वयन दस्तावेज़

क्या नहीं माना जाता है:

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