Kotlin okhttp get request

How to make an api request in kotlin?

Making API requests in Android using Kotlin is a common task when building mobile applications. There are various libraries and methods available to perform these requests, each with their own advantages and disadvantages. In this guide, we will discuss the different ways to make API requests in Kotlin, including using the built-in libraries and popular third-party libraries.

Method 1: Using the built-in HttpURLConnection class

To make an API request in Kotlin using the built-in HttpURLConnection class, you can follow these steps:

val url = URL("https://api.example.com/data")

val connection = url.openConnection() as HttpURLConnection

connection.requestMethod = "GET"

connection.setRequestProperty("Authorization", "Bearer token")

val inputStream = connection.inputStream val response = inputStream.bufferedReader().use  it.readText() >

val url = URL("https://api.example.com/data") val connection = url.openConnection() as HttpURLConnection connection.requestMethod = "GET" connection.setRequestProperty("Authorization", "Bearer token") val inputStream = connection.inputStream val response = inputStream.bufferedReader().use  it.readText() > connection.disconnect()

You can modify the code for POST, PUT, DELETE methods by changing the requestMethod property. You can also set request body by writing to the connection’s outputStream property.

Method 2: Using the popular OkHttp library

Making API Requests in Kotlin with OkHttp Library

Step 1: Add OkHttp Library to your Project

To use OkHttp library, you need to add it to your project. You can add it to your project by adding the following line to your app-level build.gradle file:

implementation 'com.squareup.okhttp3:okhttp:4.9.0'

Step 2: Create an OkHttp Client

To make API requests with OkHttp, you need to create an instance of OkHttpClient. You can create an instance of OkHttpClient using the following code:

Step 3: Create a Request

To make an API request, you need to create an instance of Request. You can create an instance of Request using the following code:

val request = Request.Builder() .url("https://api.example.com/data") .build()

In this example, we are making a GET request to https://api.example.com/data.

Step 4: Make the API Request

To make the API request, you can use the client instance and the request instance created in the previous steps. You can make the API request using the following code:

client.newCall(request).enqueue(object : Callback  override fun onFailure(call: Call, e: IOException)  // Handle error > override fun onResponse(call: Call, response: Response)  val responseBody = response.body?.string() // Handle response > >)

In this example, we are making an asynchronous API request using the enqueue method. The onResponse method will be called when the API request is successful, and the onFailure method will be called when the API request fails.

Step 5: Handle the API Response

In the onResponse method, you can get the response body using the response.body?.string() method. You can then handle the response data as per your requirements.

override fun onResponse(call: Call, response: Response)  val responseBody = response.body?.string() // Handle response >

Step 6: Handle API Request Errors

In the onFailure method, you can handle API request errors. For example, you can log the error message or show an error message to the user.

override fun onFailure(call: Call, e: IOException)  // Handle error >

That’s it! You have successfully made an API request in Kotlin using the OkHttp library.

Method 3: Using Retrofit with OkHttp

Here’s a step-by-step guide on how to make API requests in Kotlin using Retrofit with OkHttp.

Step 1: Add dependencies to Gradle

Add the following dependencies to your build.gradle file:

dependencies  implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'com.squareup.okhttp3:okhttp:4.9.1' >

Step 2: Create a Retrofit instance

Create a Retrofit instance by passing in a BaseUrl and a OkHttpClient object:

val retrofit = Retrofit.Builder() .baseUrl("https://api.example.com/") .client(OkHttpClient()) .addConverterFactory(GsonConverterFactory.create()) .build()

Step 3: Define an interface for the API

Define an interface that describes the API endpoints:

interface ApiService  @GET("users/") suspend fun getUser(@Path("userId") userId: String): User >

Step 4: Create an instance of the API interface

Create an instance of the ApiService interface using the Retrofit instance:

val apiService = retrofit.create(ApiService::class.java)

Step 5: Make API requests

Use the ApiService instance to make API requests:

val user = apiService.getUser("123")

That’s it! You’ve now successfully made an API request in Kotlin using Retrofit with OkHttp.

Note: The above code examples are just for demonstration purposes. You will need to modify them to fit your specific use case.

Method 4: Using the Fuel library

Making an API request in Kotlin using the Fuel library

Step 1: Add Fuel dependency to your project

Add the following to your app-level build.gradle file:

Step 2: Make an API request

// import required classes import com.github.kittinunf.fuel.Fuel import com.github.kittinunf.fuel.core.extensions.jsonBody import com.github.kittinunf.fuel.core.isSuccessful import com.github.kittinunf.result.Result // make the API request val url = "https://jsonplaceholder.typicode.com/posts" Fuel.get(url).response  request, response, result -> when (result)  is Result.Success ->  val data = result.value // response data val statusCode = response.statusCode // status code val isSuccess = response.isSuccessful // check if request was successful // handle successful response > is Result.Failure ->  val error = result.error // error message // handle failed response > > >

Step 3: Make a POST request with JSON body

// create JSON body val json = """""" // make the POST request Fuel.post(url).jsonBody(json).response  request, response, result -> when (result)  is Result.Success ->  val data = result.value // response data val statusCode = response.statusCode // status code val isSuccess = response.isSuccessful // check if request was successful // handle successful response > is Result.Failure ->  val error = result.error // error message // handle failed response > > >

Step 4: Add headers to the request

// create headers val headers = mapOf("Authorization" to "Bearer token") // make the API request with headers Fuel.get(url).header(headers).response  request, response, result -> // handle response >

Step 5: Add query parameters to the request

// create query parameters val params = listOf("userId" to "1", "id" to "2") // make the API request with query parameters Fuel.get(url, params).response  request, response, result -> // handle response >

Источник