HTTP4K como cliente HTTP
Tags: kotlin, backend, braziliandevs
Published: 2021-11-28 22:47:31

## Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade [Kotlinautas](https://twitter.com/kotlinautas/), uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

![capa Kotlinautas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jreawpvk6whxigcpmctf.png)

## HTTP4K

[HTTP4K](https://www.http4k.org/) é uma biblioteca feita em Kotlin para receber e fazer requisições HTTP. A principal vantagem do HTTP4K para criar servidores e clientes HTTP é que com poucas linhas conseguimos ter o básico de uma aplicação pronta.

## Materiais

Será necessário ter o [IntelliJ](https://www.jetbrains.com/idea/) instalado na máquina e um conhecimento básico sobre a linguagem [Kotlin](https://kotlinlang.org/).

## Criando o projeto

Abra seu IntelliJ no menu inicial e clique em *New Project*:

![botão New Project no menu inicial do IntelliJ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/awa9p4srmnbwucltkq2h.png)

Depois, selecione a opção **Kotlin DSL build script**, selecione também a opção **Kotlin/JVM**, e opicionalmente remova a primeira opção **Java**. Essa opção não vai mudar em nada, pois ela dá suporte do Gradle á linguagem Java, mas apenas iremos usar Kotlin.

Após isso, clique em **Next** e escreva o nome do projeto e a localização na sua máquina. Essas duas opção são completamente pessoais, caso não tenha nenhuma ideia, coloque algo como **http4k** apenas como identificação.

Agora, com o projeto aberto, vá ao aquivo `build.gradle.kts` e vamos adicionar as dependências do HTTP4K, com a seção `dependencies` ficando assim:

```kotlin
dependencies {
    implementation(platform("org.http4k:http4k-bom:4.14.1.0"))
    implementation("org.http4k:http4k-core")
}
```

Agora, clique no elefante no canto superior direito para carregar as alterações no Gradle.

![Elefante do Gradle no canto superior direito](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3innsslmf0azv3ddoxze.png)

Após isso, poderemos começar a programar. Você pode criar um arquivo em `src/main/kotlin/` chamado `main.kt` para ser o arquivo principal da aplicação.

Mas com qualquer nome de arquivo, como você irá usar as corotinas, sempre se lembre de importar a biblioteca de corotinas no começo do arquivo:

```kotlin
import org.http4k.client.JavaHttpClient
import org.http4k.core.HttpHandler
import org.http4k.core.Method
import org.http4k.core.Request
```

## Criando um cliente HTTP

Para enviar uma requisição HTTP, e mostrar o resultado dessa requisição na tela, temos o código de exemplo abaixo:

```kotlin
fun main() {
	val requisição = Request(Method.GET, "https://xkcd.com/info.0.json")
	val cliente: HttpHandler = JavaHttpClient()
	val respostaRequisição = cliente(requisição)

	println(respostaRequisição)
}
```

- Usamos uma classe `Request` para criar um objeto que represente a requisição. Nesse objeto, passamos o método e a URL dessa requisição;
- Criamos uma variável `cliente` que recebe um cliente nativo do HTTP4K, que é o `JavaHttpClient`;
- Executamos a requisição com `cliente(requisição)`, guardando todos os dados da resposta dessa requisição na variável `respostaRequisição`;
- Mostramos o resultado dessa requisição na última linha com `println`;

Executando esse código, teremos todos os dados sobre a resposta dessa requisição na tela:

```kotlin
HTTP/1.1 200
accept-ranges: bytes
age: 0
cache-control: max-age=300
connection: keep-alive
content-length: 382
content-type: application/json
date: Wed, 06 Oct 2021 02:26:36 GMT
etag: "615bc0f5-17e"
expires: Wed, 06 Oct 2021 00:56:13 GMT
last-modified: Tue, 05 Oct 2021 03:05:25 GMT
server: nginx
vary: Accept-Encoding
via: 1.1 varnish
x-cache: HIT
x-cache-hits: 1
x-served-by: cache-gig17025-GIG
x-timer: S1633487196.752074,VS0,VE392

{"month": "10", "num": 2524, "link": "", "year": "2021", "news": "", "safe_title": "Comet Visitor", "transcript": "", "alt": "It's a myth that the Great Wall of China is the only human-made structure visible from space--there are LOTS of structures for us to feel self-conscious about!", "img": "https://imgs.xkcd.com/comics/comet_visitor.png", "title": "Comet Visitor", "day": "4"}
```

Podemos acessar algumas informações usando as propriedades contidas dentro da variável `respostaRequisição`, caso você queira pegar o status da requsição, pode ser usada a opção `respostaRequisição.status`:

```kotlin
fun main() {
	val requisição = Request(Method.GET, "https://xkcd.com/info.0.json")
	val cliente: HttpHandler = JavaHttpClient()
	val respostaRequisição = cliente(requisição)

	println(respostaRequisição.status)
}
```

O resultado desse código será o status da resposta da requisição:

```
200
```

A mesma coisa pode ser feita para outras propriedades, como o corpo da resposta (`respostaRequisição.body`), os cabeçalhos da resposta (`respostaRequisição.headers`),etc.

## Finalização

Esse é o básico sobre corotinas no Kotlin. Há muito mais detalhes e conteúdos que podem ser abordados, mas para um artigo introdutório isso já é suficiente.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo [@lissatransborda](https://twitter.com/lissatransborda) 👀