Gerenciar API REST em Kotlin com Okhttp3, Retrofit2, Gson e Rxjava2

Tempo de leitura: 3 minutes

O Android tem várias maneiras de gerenciar a API REST de gerenciamento. Usar algumas bibliotecas incríveis está tornando-o mais eficiente e incrível. Leia o artigo completo e o código-fonte completo do aplicativo disponível no Github.

Os tópicos que aprenderemos são:

  1. Okhttp3
  2. Retrofit2
  3. RxJava
  4. RxAndroid
  5. Gson

 

Adicionar bibliotecas dependentes e permissão

Agora, para usar Okhttp3, Retrofit2, RxJava, RxAndroid e Gson, você precisará adicionar a biblioteca ao seu gradle. Adicione o seguinte ao seu build.gradle (Módulo: app)

//https://github.com/google/gson
implementation 'com.google.code.gson:gson:2.8.5'
//https://github.com/square/okhttp
implementation 'com.squareup.okhttp3:okhttp:3.10.0'
implementation 'com.squareup.okhttp3:logging-interceptor:3.9.0'
// https://github.com/square/retrofit
implementation 'com.squareup.retrofit2:retrofit:2.3.0'
implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
implementation 'com.squareup.retrofit2:converter-scalars:2.3.0'
// https://github.com/ReactiveX/RxAndroid
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'io.reactivex.rxjava2:rxjava:2.1.7'

OkHttp para fazer solicitações de rede

OkHttp oferece uma API de solicitação/resposta que torna a vida dos desenvolvedores mais fácil. Ele suporta chamadas síncronas e assíncronas. Melhor ainda, OkHttp também está disponível para projetos Java com Java 7 como um requisito. Além disso, OkHttp possui um ótimo mecanismo para gerenciar problemas comuns de conexão. E agora, ele também suporta WebSocket.

object ApiWorker {
    private var mClient: OkHttpClient? = null
    private var mGsonConverter: GsonConverterFactory? = null

    /**
    * Não se esqueça de remover os interceptores (ou alterar o nível de registro para NENHUM)
    * em produção! Caso contrário, as pessoas poderão ver sua solicitação e resposta no Log Cat.
    */
    val client: OkHttpClient
        @Throws(NoSuchAlgorithmException::class, KeyManagementException::class)
        get() {
            if (mClient == null) {
                val interceptor = HttpLoggingInterceptor()
                interceptor.level = HttpLoggingInterceptor.Level.BODY

                val httpBuilder = OkHttpClient.Builder()
                httpBuilder
                        .connectTimeout(15, TimeUnit.SECONDS)
                        .readTimeout(20, TimeUnit.SECONDS)
                        .addInterceptor(interceptor)  /// show all JSON in logCat
                mClient = httpBuilder.build()

            }
            return mClient!!
        }


   val gsonConverter: GsonConverterFactory
           get() {
               if(mGsonConverter == null){
                   mGsonConverter = GsonConverterFactory
                           .create(GsonBuilder()
                           .setLenient()
                           .disableHtmlEscaping()
                           .create())
               }
               return mGsonConverter!!
           }
}

 

Construtor de Cliente de Retrofit

Retrofit é um cliente HTTP de tipo seguro para Android. Com o Retrofit, podemos compor a conexão HTTP facilmente por meio de uma interface expressiva simples, como um documento API. Além da sintaxe elegante que fornece, também é fácil de incorporar a outras bibliotecas. O interessante é que POST e GET solicitam que o Retrofit.Builder() seja o mesmo.

object ApiService {
    private val TAG = "--ApiService"

    fun loginApiCall() = Retrofit.Builder()
            .baseUrl(Constants.API_BASE_PATH)
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .addConverterFactory(ApiWorker.gsonConverter)
            .client(ApiWorker.client)
            .build()
            .create(LoginApiService::class.java)!!
}

Solicitação POST

Crie uma classe de interface em que a anotação @POST(“”) defina o tipo de solicitação e o parâmetro interno seja o sufixo da URL de solicitação. A anotação @QUERY() é um cabeçalho de solicitação para que você possa usá-la para autenticação. A anotação @BODY é o corpo dos dados. O uso da classe de dados GSON será convertido no formato JSON.

interface LoginApiService {
    @Headers("Content-Type: application/json")
    @POST("login")
    fun doLogin(
            //@Query("Authorization") authorizationKey: String, // cabeçalho de autenticação
            @Body loginPostData: LoginPostData): Observable<LoginResponse> // dados do corpo
}

data class LoginPostData(
        @SerializedName("UserId") var userID: String,
        @SerializedName("Password") var userPassword: String
)

 

Solicitação GET

Crie uma classe de interface em que a anotação @GET(“”) defina o tipo de solicitação. E @QUERY(“”) é vincular os dados da solicitação ao seu URL.

interface UserApiService {
    @Headers("Content-Type: application/json")
    @GET("user")
    fun getUser(
            @Query("Authorization") authorizationKey: String, // cabeçalho de autenticação
            @Query("UserID") userID: String 
    )
}

Analisar JSON para classe de dados usando GSON

Usamos a biblioteca Google GSON para analisar JSON para a classe de dados Kotlin. Anotação @SerializedName(“”). Isso é usado quando o nome da propriedade na classe Kotlin não corresponde ao nome do campo em JSON. Na API real, alguns objetos são opcionais. @Expose(deserialize = false) para tornar um campo opcional.

data class LoginResponse(
        @SerializedName("status") val status: Int = 0,
        @SerializedName("error") val error: String = "",
        @SerializedName("error_type") val errorType: String = "",

        @Expose(deserialize = false) // desserializar neste campo não é necessário
        @SerializedName("message") val message: String = ""
)

Inscreva-se no Observable

Com as expressões lambda em Kotlin, é uma maneira super fácil e limpa de se inscrever e obter os dados ou lidar com o erro. Se quisermos seguir o padrão onNext(), onError() e onComplete() do Assinante, podemos usar o RxKotlin, que é uma extensão do RxJava. Retrofit.Builder é o gerenciamento de processo lento observável com ele. Em .subscribe é retornar a classe de dados do resultado.

@SuppressLint("CheckResult")
    private fun loginApiCall(userID: String, userPassword: String){
        if(UtilMethods.isConnectedToInternet(mContext)){
            UtilMethods.showLoading(mContext)
            val observable = ApiService.loginApiCall().doLogin(LoginPostData(userID, userPassword))
            observable.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe({ loginResponse ->
                        UtilMethods.hideLoading()

                        /** loginResponse is response data class*/

                    }, { error ->
                        UtilMethods.hideLoading()
                        UtilMethods.showLongToast(mContext, error.message.toString())
                    }
                    )
        }else{
            UtilMethods.showLongToast(mContext, "No Internet Connection!")
        }
    }

 

Espera que você aprenda algo, seja um pouco Okhttp3, Retrofit2, Gson e Rxjava2. Ah, sim, você pode obter o código do github. *** (Autor)

 

Ref: (Autor)

Visits: 2 Visits: 1199510