PDF - VERSÃO DE IMPRESSÃO

Lição 12 - Interface de programação de aplicações (API)

objetivo

Olá, estudante! Tudo bem?

Na lição anterior, você aprendeu a usar o Retrofit e Ktor, que auxiliam no uso de APIs. Agora, chegou a hora de nos aprofundarmos no conceito de APIs, ou Interface de Programação de Aplicações. Sendo assim, o objetivo desta lição é fazer com que você, futuro técnico em Desenvolvimento de Sistemas, seja introduzido aos conceitos fundamentais de Interface de Programação de Aplicações (API) e sua importância no desenvolvimento de software moderno.

A partir de uma abordagem prática e aplicada, você aprenderá a criar e consumir APIs utilizando a linguagem Kotlin, compreendendo como estruturar endpoints eficientes e seguros para a comunicação entre sistemas. Serão exploradas boas práticas de design, incluindo a definição clara de contratos de API, uso adequado de verbos HTTP, padrões de resposta e gerenciamento de erros para garantir aplicações robustas e escaláveis. Ao final da lição, você estará apto a implementar APIs bem estruturadas e consumir serviços de terceiros de maneira eficiente, ampliando suas capacidades de desenvolvimento mobile com Kotlin.

Preparado para iniciarmos essa nova jornada em busca do conhecimento?

problematização

No desenvolvimento de aplicativos móveis, a comunicação eficiente entre o App e servidores remotos é essencial para garantir uma experiência fluida e responsiva aos usuários. No entanto, sem um design adequado de APIs, diversos problemas podem comprometer o desempenho e a confiabilidade da aplicação. APIs mal estruturadas podem gerar respostas excessivamente lentas, dificultar a manutenção e até expor vulnerabilidades de segurança, tornando os aplicativos suscetíveis a falhas e ataques.

Nesse sentido, o uso de boas práticas, na criação e no consumo de APIs, ajuda a mitigar esses desafios, promovendo arquiteturas mais organizadas, escaláveis e seguras. Com um design bem estruturado, a comunicação entre o aplicativo e o servidor torna-se eficiente, reduzindo o consumo de dados, otimizando a velocidade das requisições e proporcionando uma experiência mais estável ao usuário.

Dessa forma, compreender e aplicar diretrizes adequadas no desenvolvimento de APIs é essencial para garantir que aplicativos móveis funcionem de maneira confiável, segura e adaptável às necessidades de um ambiente digital em constante evolução.

Nesta lição, exploraremos esse tema em profundidade. Vamos lá?

case

Agora, que tal entender na prática como funciona uma Interface de Programação de Aplicações (API)? Para isso, utilizaremos um exemplo fictício, mas bastante ilustrativo. Conheça agora a MobPay, uma startup financeira, que enfrentava problemas em seu aplicativo de pagamentos devido a uma API mal planejada. Falhas frequentes, lentidão na atualização de saldos e dificuldades na comunicação com bancos parceiros resultavam em uma experiência instável para os usuários, gerando reclamações constantes.

Diante desse cenário, a equipe de tecnologia decidiu reestruturar completamente a API, adotando boas práticas de design e gerenciamento de respostas. Foram implementados padrões RESTful bem definidos, garantindo a padronização de endpoints e respostas. Para otimizar a velocidade das requisições, a equipe introduziu cache inteligente, compressão de dados e melhorias na estrutura do banco de dados. Também foi adotado o Kotlin para consumir essas APIs de forma mais eficiente dentro do aplicativo, utilizando bibliotecas, como Retrofit, para facilitar a comunicação assíncrona com o servidor.

Com isso, os resultados foram expressivos. O tempo médio de resposta das requisições reduziu em 60%, e a estabilidade do sistema melhorou significativamente, eliminando as interrupções nos horários de maior movimento. A satisfação dos clientes aumentou, refletida na diminuição das reclamações e no crescimento da base de usuários. Com APIs bem estruturadas, a empresa conseguiu transformar um aplicativo problemático em uma plataforma confiável e eficiente, consolidando sua posição no mercado e garantindo uma experiência de uso fluida e segura para seus clientes.

Esse exemplo demonstra, na prática, como um design de API bem estruturado pode transformar um aplicativo problemático em uma plataforma confiável e eficiente, garantindo uma experiência fluida, segura e escalável para os usuários. Agora que já entendemos melhor o tema, vamos explorar a teoria por trás desse conceito em detalhes!

Conceitualização

No desenvolvimento de software moderno, a comunicação entre diferentes sistemas e serviços é fundamental para a criação de aplicações robustas e escaláveis. Para isso, utilizamos as Interfaces de Programação de Aplicações (APIs), que atuam como pontes entre aplicações, permitindo a interoperabilidade de dados de forma estruturada e eficiente.

Saudate (2021) define APIs como uma forma de comunicação com o software que procura abstrair totalmente os detalhes da implementação subjacente — ou ao menos tanto quanto for possível. Em essência, as APIs estabelecem um conjunto de regras que determinam como os sistemas devem se comunicar, viabilizando a integração de serviços, como bancos de dados, plataformas em nuvem e funcionalidades externas, dentro de um único aplicativo.

Para garantir que uma API seja eficiente e funcional, é fundamental compreender seus principais conceitos e boas práticas. A seguir, exploraremos cada um desses conceitos detalhadamente!

Endpoints e estrutura de uma API

Os endpoints são os pontos de acesso que uma API disponibiliza para que outros sistemas possam interagir com seus dados e funcionalidades. Cada endpoint representa um recurso específico, como um banco de usuários, produtos ou pedidos dentro de um sistema. Saudate (2021) chama os endpoints de URLs e sugere que o ideal seria tratá-los como a representação de um conjunto — no sentido mais próximo que isso pode estar do conceito matemático.

Uma API bem projetada deve ter uma estrutura clara e organizada, garantindo que as requisições e respostas sigam um padrão consistente e facilmente compreensível. Um exemplo de endpoint típico seria: https://api.meusistema.com/usuarios

API REST

As APIs REST (Representational State Transfer) são um dos padrões mais utilizados para a comunicação entre sistemas na web, permitindo a troca de dados de forma eficiente e escalável. Saudate (2021) resume o REST como um meio de comunicação entre dois sistemas diferentes, independentemente da linguagem em que foram desenvolvidos. Seguindo princípios fundamentais, como a separação entre cliente e servidor, a ausência de estado entre requisições e o uso de verbos HTTP padronizados (GET, POST, PUT, DELETE), as APIs facilitam a integração entre diferentes aplicações. Quando uma API segue corretamente essas diretrizes, ela é chamada de API RESTful, garantindo maior organização, previsibilidade e interoperabilidade entre serviços. Esse modelo é amplamente utilizado no desenvolvimento de aplicativos móveis, sistemas web e serviços em nuvem, tornando-se um padrão essencial para desenvolvedores que trabalham com comunicação entre sistemas.

Verbos HTTP e métodos de requisição

Os verbos HTTP definem as operações que podem ser realizadas sobre os recursos da API. Métodos [...] (2025) declara que cada um deles implementa uma semântica diferente, um propósito específico e deve ser utilizado corretamente para garantir a integridade e o bom funcionamento da aplicação. É possível que você já os conheça, mas vamos falar agora dos principais verbos HTTP, que são:

GET: utilizado para buscar informações em um servidor.
POST: usado para enviar novos dados e criar novos recursos.
PUT: empregado para atualizar um recurso existente de forma integral.
PATCH: similar ao PUT, mas utilizado para atualizações parciais de um recurso.
DELETE: remove um recurso do servidor.

Padrões de resposta e formato de dados

Uma API precisa retornar os dados no formato correto para que o sistema cliente consiga interpretá-los. O formato mais comum de resposta é o JSON (JavaScript Object Notation), definido por Json (2025) como uma sintaxe para serialização de objetos, matrizes e números, devido à sua simplicidade e compatibilidade com diversas linguagens de programação, incluindo Kotlin. Veja agora, na Figura 1, um exemplo de resposta JSON:

Figura 1 - Exemplo de resposta em JSON
Fonte: o autor.

#PraCegoVer: a figura apresenta cinco linhas. Na linha 1, está escrito “{“; na linha 2, “‘id’: 1”; na linha 3, “‘nome’: ‘João Silva’”; na linha 4, “‘email’: ‘joao@email.com’”; e, na linha 5, “}”. Fim da descrição.

Vale ressaltar que, além do JSON, algumas APIs também utilizam XML ou outros formatos específicos para transmissão de dados.

Tratamento de erros e status HTTP

Ao consumir uma API, é essencial que o sistema saiba lidar com possíveis erros. Para isso, as APIs utilizam códigos de status HTTP. Códigos [...] (2025) explica que os códigos de status de respostas indicam se uma solicitação HTTP específica foi concluída com êxito, as respostas são agrupadas em cinco classes:

Respostas informativas: códigos (100 - 199).
Respostas bem-sucedidas: códigos (200 - 299).
Mensagens de redirecionamento: códigos (300 - 399).
Respostas de erro do cliente: códigos (400 - 499).
Respostas de erro do servidor: códigos (500 - 599).

E alguns dos status mais comuns incluem:

200 OK – A requisição foi bem-sucedida.
201 Created – Um novo recurso foi criado com sucesso.
400 Bad Request – A requisição está incorreta ou malformada.
401 Unauthorized – O acesso ao recurso exige autenticação.
404 Not Found – O recurso solicitado não foi encontrado.
500 Internal Server Error – Ocorreu um erro no servidor.

É importante destacar que lidar corretamente com esses códigos permite melhor gerenciamento de falhas, melhorando a experiência do usuário e a estabilidade do sistema.

Segurança na comunicação

As APIs precisam garantir que apenas usuários e sistemas autorizados possam acessar seus dados. Para isso, é comum a implementação de mecanismos de autenticação e autorização, como:

● Token JWT (JSON Web Token)

Um token gerado pelo servidor que identifica e autentica o usuário. Json (2025) define JWT como um padrão aberto que define uma maneira compacta e autônoma de transmitir informações com segurança entre as partes como um objeto JSON.

● OAuth 2.0

Protocolo de autorização amplamente utilizado para permitir acesso seguro a APIs. OAuth 2.0 (2025) define o protocolo como sendo o protocolo padrão do mercado para autorização. Ele concentra-se na simplicidade do desenvolvimento do cliente e fornece fluxos de autorização específicos para aplicativos web, aplicativos desktop e telefones celulares.

Na lição anterior, aprendemos como consumir e criar APIs utilizando Kotlin com as bibliotecas Retrofit e Ktor, duas das principais soluções para integrar aplicações Android a servidores e serviços externos. Ambas oferecem abordagens eficientes para realizar requisições HTTP, manipular respostas e garantir a comunicação entre cliente e servidor de forma segura e organizada.

saiba aplicar

No desenvolvimento de software moderno, compreender e aplicar os conceitos de API é um requisito essencial para a criação de sistemas conectados, eficientes e escaláveis. Para você, futuro técnico em Desenvolvimento de Sistemas, dominar a criação e o consumo de APIs em Kotlin significa garantir que diferentes aplicações possam se comunicar de maneira segura e organizada, promovendo a integração entre dispositivos, serviços e plataformas.

Agora entendendo melhor a teoria, vamos colocar isso em prática? Nesta atividade prática, você aprenderá a consumir dados de uma API REST externa usando Ktor Client e exibi-los em uma lista utilizando o Jetpack Compose. Lembra de algo parecido? Sim, fizemos o mesmo tipo de atividade na lição anterior e, sim, utilizaremos o mesmo projeto fazendo as devidas atualizações para remover o Retrofit e utilizarmos o Ktor Client.

O passo a passo para essa atividade é o seguinte:

1) Crie um projeto básico usando Kotlin e Jetpack Compose no Android Studio.

2) Como já vimos no projeto anterior (Retrofit), por estarmos fazendo uma conexão com uma API externa usando a internet, é preciso acrescentarmos no arquivo AndroidManifest.xml a seguinte linha:

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

3) Adicione as dependências do Ktor no arquivo build.gradle.kts no módulo :app, adicionando as dependências no array dependencies, conforme a Figura 2. Em seguida, sincronize o Gradle para garantir que as bibliotecas sejam baixadas corretamente.

Figura 2 - Incluindo as dependências do Ktor
Fonte: o autor.

#PraCegoVer: a figura apresenta oito linhas. Na linha 1, está escrito “dependencies { na linha 2 // depois das dependências já instaladas”; na linha 3, “implementation("io.ktor:ktor-client-core:2.3.4")”; na linha 4, “implementation("io.ktor:ktor-client-cio:2.3.4")”; na linha 5, “implementation("io.ktor:ktor-client-content-negotiation:2.3.4")”; na linha 6, “implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.4")”; na linha 7, “implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")”; e, na linha 8, “}”. Fim da descrição.

4) Crie um novo arquivo chamado ApiService.kt e implemente a lógica para buscar dados da API conforme a Figura 3:

Figura 3 - Criando o serviço de busca dos dados na API em Kotlin
Fonte: o autor.

#PraCegoVer: a figura apresenta 35 linhas. Na linha 1, está escrito “// 1 - Crie o modelo de dados para representar um Post da API”; na linha 2, “@Serializable”; na linha 3, “data class Post(”; na linha 4, “val userId: Int”; na linha 5, “val id: Int”; na linha 6, “val title: String”; na linha 7, “val body: String”; na linha 8, “)”; na linha 10, “// 2 - Crie o cliente HTTP do Ktor”; na linha 11, “object ApiService {”; na linha 12, “private val client = HttpClient(CIO) {”; na linha 13, “install(ContentNegotiation) {”; na linha 14, “json(Json {”; na linha 15, “ignoreUnknownKeys = true”; na linha 16, “isLenient = true”; na linha 17, “})”; na linha 18, “}”; na linha 19, “}”; na linha 21, “private const val BASE_URL = ‘https://jsonplaceholder.typicode.com’”; na linha 23, “// 3 - Crie a função para buscar posts da API”; na linha 24, “suspend fun getPosts(): List<Post> {”; na linha 25, “return try {”; na linha 26, “Log.d("ApiService", "Iniciando requisição à API...")”; na linha 27, “val response: List<Post> = client.get("$BASE_URL/posts").body()”; na linha 28, “Log.d("ApiService", "Requisição bem-sucedida! ${response.size} posts recebidos.")”; na linha 29, “response”; na linha 30, “} catch (e: Exception) {”; na linha 31, "Log.e("ApiService", "Erro na requisição: ${e.message}", e)”; na linha 32, “emptyList()”; na linha 33, “}”; na linha 34, “}”; e, na linha 35, “}”. Nas linhas 9, 20 e 22, não há conteúdo escrito. Fim da descrição.

5) Agora crie a tela no Jetpack Compose que exibirá os posts em uma lista. Crie um arquivo PostListScreen.kt com o seguinte código conforme a Figura 4:

Figura 4 - Criando a ViewModel para exibição dos Posts em Cards
Fonte: o autor.

#PraCegoVer: a figura apresenta 37 linhas. Na linha 1, está escrito “@Composable”; na linha 2, “fun PostListScreen() {”; na linha 3, “var posts by remember { mutableStateOf<List<Post>>(emptyList()) }”; na linha 5, “LaunchedEffect(Unit) {”; na linha 6, “posts = ApiService.getPosts()”; na linha 7, “}”; na linha 9, “if (posts.isEmpty()) {”; na linha 10, “Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {”; na linha 11, “CircularProgressIndicator()”; na linha 12, “}”; na linha 13, “} else {”; na linha 14, “LazyColumn(”; na linha 15, “modifier = Modifier.fillMaxSize().padding(16.dp)”; na linha 16, “verticalArrangement = Arrangement.spacedBy(8.dp)”; na linha 17, “) {”; na linha 18, “items(posts) { post ->”; na linha 18, “PostCard(post)”; na linha 20, “}”; na linha 21, “}”; na linha 22, “}”; na linha 23, “}”; na linha 25, “@Composable”; na linha 26, “fun PostCard(post: Post) {”; na linha 27, “Card( na linha 28 modifier = Modifier.fillMaxWidth()”; na linha 29, “elevation = CardDefaults.cardElevation(4.dp)”; na linha 30, “) {”; na linha 31, “Column(modifier = Modifier.padding(16.dp)) {”; na linha 32, “Text(text = post.title, style = MaterialTheme.typography.headlineSmall)”; na linha 33, “Spacer(modifier = Modifier.height(8.dp))”; na linha 34, “Text(text = post.body, style = MaterialTheme.typography.bodyMedium)”; na linha 35, “}”; na linha 36, “}”; e, na linha 37, “}”. Nas linhas 4, 8 e 24, não há conteúdo escrito. Fim da descrição.

6) Agora, vá até o arquivo MainActivity.kt e modifique-o para carregar a tela de listagem de posts conforme a Figura 5:

Figura 5 - Ajustando a MainActivity para executar PostListScreen
Fonte: o autor.

#PraCegoVer: a figura apresenta dez linhas. Na linha 1, está escrito “class MainActivity : ComponentActivity() {”; na linha 2, “override fun onCreate(savedInstanceState: Bundle?) {”; na linha 3, “super.onCreate(savedInstanceState)”; na linha 4, “setContent {”; na linha 5, “KtorExampleTheme {”; na linha 6, “PostListScreen()”; na linha 7, “}”; na linha 8, “}”; na linha 9, “}”; e, na linha 10, “}”. Fim da descrição.

Após executar o aplicativo, os posts da API serão exibidos em uma lista no Jetpack Compose, dentro de cartões estilizados. Nesse passo a passo, aprendemos:

Como configurar o Ktor Client para consumir API REST.
Como buscar e exibir dados da API JSONPlaceholder no Android.
Como utilizar LazyColumn e Cards no Jetpack Compose para criar uma interface visual moderna.

Assim, agora que você está pronto para integrar APIs externas em seus aplicativos Android de maneira eficiente com Ktor, desafie seus colegas e/ou professores a consumir alguma outra API de sua preferência. Bom trabalho!

REFERÊNCIAS

CÓDIGOS de status de respostas HTTP. MDN Web Docs, 27 abr. 2025. Disponível em: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status. Acesso em: 29 abr. 2025.

JSON Web Tokens. Auth0, c2025. Disponível em: https://auth0.com/docs/secure/tokens/json-web-tokens. Acesso em: 29 abr. 2025.

JSON. MDN Web Docs, 25 abr. 2025. Disponível em: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON. Acesso em: 29 abr. 2025.

MÉTODOS de requisição HTTP. MDN Web Docs, 14 abr. 2025. Disponível em: https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Reference/Methods. Acesso em: 19 mar. 2025.

OAUTH 2.0. OAuth, 27 abr. 2025. Disponível em: https://oauth.net/2/. Acesso em: 29 abr. 2025.

SAUDATE, A. APIs REST em Kotlin: seus serviços prontos para o mundo real. São Paulo: Casa do Código, 2021.

SAUDATE, A. APIs REST: seus serviços prontos para o mundo real. São Paulo: Casa do Código, 2021.

Page updated

Google Sites

Report abuse