web-dev-qa-db-fra.com

Requête HTTP en Kotlin

Je suis complètement nouveau à Kotlin. Je souhaite effectuer une validation de connexion à l'aide de la méthode POST et obtenir des informations à l'aide de la méthode GET. J'ai déjà l'URL, le nom d'utilisateur et le mot de passe du serveur de mon projet précédent. Je n'ai trouvé aucun exemple de projet approprié utilisant cette chose. N'importe qui s'il vous plaît me suggérer n'importe quel exemple de travail où je peux utiliser les méthodes GET et POST dans une requête HTTP

androidkotlin
12
Rajkumar K

Pour Android, Volley est un bon endroit pour commencer.

Cependant, vous pouvez utiliser les bibliothèques standard que vous utiliseriez en Java. Par exemple, HttpURLConnection:

private fun sendGet() {
    val url = "http://www.google.com/"
    val obj = URL(url)

    with(obj.openConnection() as HttpURLConnection) {
        // optional default is GET
        requestMethod = "GET"


        println("\nSending 'GET' request to URL : $url")
        println("Response Code : $responseCode")

        BufferedReader(InputStreamReader(inputStream)).use {
            val response = StringBuffer()

            var inputLine = it.readLine()
            while (inputLine != null) {
                response.append(inputLine)
                inputLine = it.readLine()
            }
            println(response.toString())
        }
    }
}

Vous pouvez ainsi envoyer de simples requêtes HTTP à un serveur. Je suggère Apache HttpComponents ou le cadre que vous souhaitez utiliser pour les tâches complexes.

8
s1m0nw1

Peut-être le plus simple GET

Pour tout le monde coincé avec NetworkOnMainThreadException pour les autres solutions: utilisez AsyncTask ou, même plus courte, (encore expérimentale) Coroutines:

launch {

    val jsonStr = URL("url").readText()

}

Si vous avez besoin de tester avec http simple, n'oubliez pas d'ajouter à votre manifeste: Android:usesCleartextTraffic="true"

Pour les Coroutines expérimentales, vous devez ajouter à build.gradle à partir du 10/10/2018:

kotlin {
    experimental {
        coroutines 'enable'
    }
}
dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.24.0"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-Android:0.24.0"
    ...
5
ollie

Envoyer une requête HTTP POST/GET avec des paramètres utilisant HttpURLConnection:

POST avec les paramètres: 

fun sendPostRequest(userName:String, password:String) {

    var reqParam = URLEncoder.encode("username", "UTF-8") + "=" + URLEncoder.encode(userName, "UTF-8")
    reqParam += "&" + URLEncoder.encode("password", "UTF-8") + "=" + URLEncoder.encode(password, "UTF-8")
    val mURL = URL("<Your API Link>")

    with(mURL.openConnection() as HttpURLConnection) {
        // optional default is GET
        requestMethod = "POST"

        val wr = OutputStreamWriter(getOutputStream());
        wr.write(reqParam);
        wr.flush();

        println("URL : $url")
        println("Response Code : $responseCode")

        BufferedReader(InputStreamReader(inputStream)).use {
            val response = StringBuffer()

            var inputLine = it.readLine()
            while (inputLine != null) {
                response.append(inputLine)
                inputLine = it.readLine()
            }
            it.close()
            println("Response : $response")
        }
    }
}

GET avec paramètres: 

fun sendGetRequest(userName:String, password:String) {

        var reqParam = URLEncoder.encode("username", "UTF-8") + "=" + URLEncoder.encode(userName, "UTF-8")
        reqParam += "&" + URLEncoder.encode("password", "UTF-8") + "=" + URLEncoder.encode(password, "UTF-8")

        val mURL = URL("<Yout API Link>?"+reqParam)

        with(mURL.openConnection() as HttpURLConnection) {
            // optional default is GET
            requestMethod = "GET"

            println("URL : $url")
            println("Response Code : $responseCode")

            BufferedReader(InputStreamReader(inputStream)).use {
                val response = StringBuffer()

                var inputLine = it.readLine()
                while (inputLine != null) {
                    response.append(inputLine)
                    inputLine = it.readLine()
                }
                it.close()
                println("Response : $response")
            }
        }
    }
4
Deven

Vous pouvez utiliser kohttp library. C'est un client HTTP Kotlin DSL. Il prend en charge les fonctionnalités de square.okhttp et leur fournit une connexion DSL claire. Les appels asynchrones KoHttp sont alimentés par des coroutines. 

httpGet fonction d'extension

val response: Response = "https://google.com/search?q=iphone".httpGet()

vous pouvez également utiliser l'appel asynchrone avec des coroutines

val response: Deferred<Response> = "https://google.com/search?q=iphone".asyncHttpGet()

ou fonction DSL pour des requêtes plus complexes

val response: Response = httpGet {
    Host = "google.com"
    path = "/search"
    param {
       "q" to "iphone"
       "safe" to "off"
   }
}

Vous pouvez trouver plus de détails dans docs

Pour l'obtenir avec l'utilisation de Gradle 

compile 'io.github.rybalkinsd:kohttp:0.7.1'
2
Sergey Rybalkin
import Java.io.IOException
import Java.net.URL

fun main(vararg args: String) {
    val response = try {
        URL("http://seznam.cz")
                .openStream()
                .bufferedReader()
                .use { it.readText() }
    } catch (e: IOException) {
        "Error with ${e.message}."
    }
    println(response)
}
1
Pavel Hanpari

Sans ajouter de dépendances supplémentaires, cela fonctionne. Vous n'avez pas besoin de Volley pour ça. Cela fonctionne avec la version actuelle de Kotlin à compter de décembre 2018: Kotlin 1.3.10

Si vous utilisez Android Studio, vous devez ajouter cette déclaration dans votre AndroidManifest.xml:

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

Vous devez déclarer manuellement les importations ici. L'outil d'importation automatique m'a causé beaucoup de conflits:

import Android.os.AsyncTask
import Java.io.BufferedReader
import Java.io.InputStreamReader
import Java.io.OutputStream
import Java.io.OutputStreamWriter
import Java.net.URL
import Java.net.URLEncoder
import javax.net.ssl.HttpsURLConnection

Vous ne pouvez pas effectuer de requêtes réseau sur un thread en arrière-plan. Vous devez sous-classe AsyncTask.

Pour appeler la méthode:

NetworkTask().execute(requestURL, queryString)

Déclaration:

private class NetworkTask : AsyncTask<String, Int, Long>() {
    override fun doInBackground(vararg parts: String): Long? {
        val requestURL = parts.first()
        val queryString = parts.last()

        // Set up request
        val connection: HttpsURLConnection = URL(requestURL).openConnection() as HttpsURLConnection
        // Default is GET so you must override this for post
        connection.requestMethod = "POST"
        // To send a post body, output must be true
        connection.doOutput = true
        // Create the stream
        val outputStream: OutputStream = connection.outputStream
        // Create a writer container to pass the output over the stream
        val outputWriter = OutputStreamWriter(outputStream)
        // Add the string to the writer container
        outputWriter.write(queryString)
        // Send the data
        outputWriter.flush()

        // Create an input stream to read the response
        val inputStream = BufferedReader(InputStreamReader(connection.inputStream)).use {
            // Container for input stream data
            val response = StringBuffer()
            var inputLine = it.readLine()
            // Add each line to the response container
            while (inputLine != null) {
                response.append(inputLine)
                inputLine = it.readLine()
            }
            it.close()
            // TODO: Add main thread callback to parse response
            println(">>>> Response: $response")
        }
        connection.disconnect()

        return 0
    }

    protected fun onProgressUpdate(vararg progress: Int) {
    }

    override fun onPostExecute(result: Long?) {
    }
}
1
jungledev

Si vous utilisez Kotlin, vous pouvez également garder votre code aussi succinct que possible. La méthode run transforme le destinataire en this et renvoie la valeur du bloc .this as HttpURLConnection crée une distribution intelligente. bufferedReader().readText() évite un tas de code passe-partout.

return URL(url).run {
        openConnection().run {
            this as HttpURLConnection
            inputStream.bufferedReader().readText()
        }
}

Vous pouvez également envelopper cela dans une fonction d'extension.

fun URL.getText(): String {
    return openConnection().run {
                this as HttpURLConnection
                inputStream.bufferedReader().readText()
            }
}

Et appelle ça comme ça

return URL(url).getText()

Enfin, si vous êtes très paresseux, vous pouvez plutôt étendre la classe String.

fun String.getUrlText(): String {
    return URL(this).run {
            openConnection().run {
                this as HttpURLConnection
                inputStream.bufferedReader().readText()
            }
    }
}

Et appelle ça comme ça

return "http://somewhere.com".getUrlText()
1
Steven Spungin

Regardez Carburant bibliothèque, un exemple de demande GET

"https://httpbin.org/get"
  .httpGet()
  .responseString { request, response, result ->
    when (result) {
      is Result.Failure -> {
        val ex = result.getException()
      }
      is Result.Success -> {
        val data = result.get()
      }
    }
  }

// You can also use Fuel.get("https://httpbin.org/get").responseString { ... }
// You can also use FuelManager.instance.get("...").responseString { ... }

Un exemple de demande POST

Fuel.post("https://httpbin.org/post")
    .jsonBody("{ \"foo\" : \"bar\" }")
    .also { println(it) }
    .response { result -> }

Leur documentation peut être trouvée ici : https://fuel.gitbook.io/documentation/core/fuel

0
lssilva