Android Academy · Aula

Retrofit e APIs REST

Faça requisições HTTP com Retrofit. Defina interfaces de API, analise JSON com Gson/Moshi, trate respostas e erros e integre tudo às corrotinas.

Retrofit e APIs REST é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 de 6. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 6 aulas no total.

O que é o Retrofit?

O Retrofit é o cliente HTTP mais popular para Android, desenvolvido pela Square. Ele permite definir sua API REST como uma interface Kotlin — sem código HTTP repetitivo.

Adicione anotações aos métodos, como @GET e @POST
Converte automaticamente respostas JSON em classes de dados Kotlin
Suporte nativo a coroutines (suspend fun)

Adicionando dependências

Adicione o Retrofit e o conversor Gson ao app/build.gradle:

// app/build.gradle
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.11.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.11.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'
}

// AndroidManifest.xml — add internet permission:
// <uses-permission android:name="android.permission.INTERNET" />

Definindo a interface da API

Crie uma interface Kotlin que descreva os endpoints da sua API:

import retrofit2.http.*

data class Post(val id: Int, val title: String, val body: String, val userId: Int)

interface ApiService {

    @GET("posts")
    suspend fun getPosts(): List<Post>

    @GET("posts/{id}")
    suspend fun getPost(@Path("id") id: Int): Post

    @POST("posts")
    suspend fun createPost(@Body post: Post): Post

    @GET("posts")
    suspend fun getPostsByUser(@Query("userId") userId: Int): List<Post>
}

Criando a instância do Retrofit

Crie uma instância singleton do Retrofit — normalmente em um object ou usando o Hilt:

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

object RetrofitClient {
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"

    val api: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

Fazendo uma requisição GET

Chame a API a partir de um Repository usando coroutines do Kotlin:

class PostRepository {
    private val api = RetrofitClient.api

    suspend fun getPosts(): List<Post> {
        return api.getPosts()  // Retrofit handles threading for you
    }

    suspend fun getPost(id: Int): Post {
        return api.getPost(id)
    }
}

// In ViewModel:
fun loadPosts() {
    viewModelScope.launch {
        try {
            val posts = withContext(Dispatchers.IO) {
                repository.getPosts()
            }
            _posts.value = posts
        } catch (e: Exception) {
            _error.value = "Network error: ${e.message}"
        }
    }
}

Mapeamento de JSON com Gson

O Gson converte automaticamente JSON em classes de dados Kotlin. Os nomes dos campos devem corresponder às chaves do JSON; caso contrário, use @SerializedName:

import com.google.gson.annotations.SerializedName

data class User(
    val id: Int,
    val name: String,
    val email: String,
    @SerializedName("phone_number")  // JSON key is 'phone_number'
    val phoneNumber: String,
    @SerializedName("created_at")
    val createdAt: String
)

Requisição POST com um corpo

Envie dados a um servidor usando @POST e @Body:

// API interface:
@POST("users")
suspend fun createUser(@Body user: User): User

// In Repository:
suspend fun createUser(name: String, email: String): User {
    val newUser = User(id = 0, name = name, email = email, phoneNumber = "", createdAt = "")
    return api.createUser(newUser)
}

// In ViewModel:
fun registerUser(name: String, email: String) {
    viewModelScope.launch {
        val user = withContext(Dispatchers.IO) {
            repo.createUser(name, email)
        }
        _registeredUser.value = user
    }
}

Cabeçalhos e autenticação

Adicione cabeçalhos a todas as requisições usando um interceptor do OkHttp:

import okhttp3.OkHttpClient
import okhttp3.Interceptor

val authClient = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer $token")
            .addHeader("Accept", "application/json")
            .build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl(BASE_URL)
    .client(authClient)  // use our authenticated client
    .addConverterFactory(GsonConverterFactory.create())
    .build()

Tratamento de erros HTTP

Uma resposta HTTP bem-sucedida (200–299) retorna um valor. Respostas de erro (4xx, 5xx) lançam uma HttpException. Sempre trate os dois casos:

HttpException — o servidor retornou um código de status de erro
IOException — não há conexão de rede

Verificação rápida

Qual anotação do Retrofit mapeia um parâmetro de método para um segmento do caminho da URL, como /posts/{id}?

Recapitulação: Retrofit e APIs

Agora você pode buscar dados de qualquer API REST:

Defina a API com uma interface Kotlin e anotações (@GET, @POST, @Path, @Query)
Crie uma instância do Retrofit com uma URL base e um conversor Gson
Chame funções suspensas a partir de uma coroutine no ViewModel
Mapeie automaticamente JSON → classes de dados Kotlin
Trate HttpException e IOException

A seguir: exiba imagens da rede com o Coil.

Perguntas Frequentes

A aula “Retrofit e APIs REST” é grátis?

Sim — o texto completo de “Retrofit e APIs REST” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 6 aulas no total.

O que vou aprender em “Retrofit e APIs REST”?

Faça requisições HTTP com Retrofit. Defina interfaces de API, analise JSON com Gson/Moshi, trate respostas e erros e integre tudo às corrotinas. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 6.

Quanto tempo leva a aula “Retrofit e APIs REST”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy