Lib HttpClient Utils: Uma biblioteca Java para simplificar requisições HTTP
Tags: java, http, springboot
Published: 2023-06-25 01:10:33

Com o crescente uso de aplicações web e serviços RESTful, a manipulação eficiente de requisições e respostas HTTP tornou-se crucial no desenvolvimento de software. No entanto, lidar com essas operações de forma simples e otimizada nem sempre é uma tarefa fácil. É nesse contexto que a biblioteca Lib HttpClient Utils surge como uma solução poderosa e personalizada para desenvolvedores Java.

Neste artigo, exploraremos em detalhes a biblioteca Lib HttpClient Utils, uma ferramenta desenvolvida por mim para simplificar e aprimorar a manipulação de requisições HTTP em projetos Java. Com a Lib HttpClient Utils, você poderá reduzir a complexidade do código, aumentar a produtividade e obter um desempenho excepcional nas comunicações HTTP.

Ao longo deste artigo, discutiremos os principais recursos e funcionalidades da Lib HttpClient Utils, apresentaremos exemplos práticos de uso e destacaremos os benefícios que ela oferece. Se você é um desenvolvedor Java em busca de uma solução elegante e eficiente para lidar com requisições HTTP, continue lendo e descubra como a Lib HttpClient Utils pode transformar sua experiência de desenvolvimento.

## 1. Importação da Biblioteca
**Maven**
```xml
<dependency>
    <!-- Outras dependências do seu projeto -->
    <groupId>io.github.jusebandtec</groupId>
    <artifactId>lib-httpclient-utils</artifactId>
    <version>1.1.6</version>
</dependency>
```
**Gradle**
```gradle
dependencies {
    // Outras dependências do seu projeto
    
    implementation 'io.github.jusebandtec:lib-httpclient-utils:1.1.6'
}
```

## 2. Exemplo

Para utilizar é bem simples. A biblioteca é composto em 4 módulos principais:

1. HttpRepository
2. HttpConnection
3. HttpRequest
4. HttpResponse

Estaremos utilizando o contexto do [Via Cep](https://viacep.com.br/) como exemplo. No qual fazemos a requisição:
**HTTP GET** - [Cep 01001000](https://viacep.com.br/ws/01001000/json/)

E vem a seguinte resposta:

```json
{
  "cep": "01001-000",
  "logradouro": "Praça da Sé",
  "complemento": "lado ímpar",
  "bairro": "Sé",
  "localidade": "São Paulo",
  "uf": "SP",
  "ibge": "3550308",
  "gia": "1004",
  "ddd": "11",
  "siafi": "7107"
}
```

Com a **Lib HttpClient Utils** é bem fácil reproduzir o comportamento. 

É só fazer uma classe e **herdar** o módulo de **HttpRepository** para obter as funcionalidades de _doRequest()_.

Veja:

```java
@Component
public class TesteHttpClientUtils extends HttpRepository {

    @Autowired
    public TesteHttpClientUtils(HttpConnection httpConnection) {
        super(httpConnection);
    }
}
```

Note que ela não vai funcionar de primeira, é necessário criar um **_Bean_** da classe HttpConnection, dessa forma:

```java
@Configuration
public class HttpClientLibConfiguration {

    @Bean
    public HttpConnection httpRepository() {
        return new HttpConnectionImpl(HttpClient.newBuilder().build());
    }
}
```

Agora podemos prosseguir.

Precisamos construir nossos objetos de **Request** e **Response**:

```java
public class ObterCepHttpRequest extends HttpRequest {
    public ObterCepHttpRequest(String cep) {
        this.setUriRelative(String.format("https://viacep.com.br/ws/%s/json", cep));
        this.setHttpMethod(HttpMethod.GET);
        this.setTimeout(5000);
    }
}

```

Aqui tem somente alguns exemplos do que o **HttpRequest** tem, mas tem muito mais, como:

- String payload;
- Map<String, String> headers;
- Map<String, MediaType> stringMediaTypeMap;

Dependendo da sua requisição, você pode utilizar.

E a classe de Response:

```java
public class ObterCepHttpResponse implements HttpResponse {

    public ObterCepHttpResponseData obterCepHttpResponseData;

    @Override
    public HttpResponse handle(HttpRequest httpRequest, java.net.http.HttpResponse<?> httpResponse) {
        if (httpResponse.statusCode() != 200)
            return null;

        obterCepHttpResponseData = new JsonHelper<ObterCepHttpResponseData>().deserializeFromString(httpResponse.body().toString(), ObterCepHttpResponseData.class);
        return this;
    }

    public ObterCepHttpResponseData getObterCepHttpResponseData() {
        return obterCepHttpResponseData;
    }
}
```

Vou explicar como é chamado esse método **_handle()_** no próximo bloco.

A biblioteca já leva um módulo de **JsonHelper** no qual você pode serializar e desserializar objetos dependendo do que você deseja.

### 2.1 Fazendo a requisição
Vamos fazer um método para realizar a requisição e obter a resposta na classe que criamos como exemplo. Segue:

```java
public ObterCepHttpResponseData obterCep(String cep) {
        try {
            var request = new ObterCepHttpRequest(cep);
            var response = this.doRequest(request, new ObterCepHttpResponse());
            System.out.println(response.toJson());
            return response.obterCepHttpResponseData;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
```

Veja que é chamado o método **_doRequest(request, new ObterCepHttpResponse()_**, assim que esse método é chamado, ele realiza a requisição passando os parametros que especificamos na classe **ObterCepHttpRequest**, e assim que realizar a request, ele chama a classe **_ObterCepHttpResponse_**, passando a response pra lá, e é assim que conseguimos obter a resposta.

![Imagem do console da aplicação](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sovafe6qu6egld0g1m1a.png)

A biblioteca foi desenvolvida por mim, eu espero muito que tenham gostado. A mesma pode ser encontrada aqui:

[Lib HttpClient Utils](https://github.com/jusemarinho/lib-httpclient)

Até mais.