Acompanhe os novos blogs no site www.byiorio.com.br

Conteúdo do blog:

Teste de performance - Complemento para o Feign Client

Objetivo

Como vimos no artigo anterior, sobre performance, as chamadas em paralelo podem ajudar a melhorar o desempenho do nosso serviço, lembrando que as chamadas não são interdependentes, o meu objetivo nesse artigo é complementar a chamada do Feign Client, do artigo anterior, adicionando chamadas em paralelo, visando uma melhor performance para quem utiliza o Feign.

Para isso vamos usar 2 novas classes:
- CompletableFuture
- ForkJoinPool

O que é CompletableFuture ?

Link: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html

CompletableFuture é usado para programação assíncrona no Java. Assíncrona significa que vamos escrever um código para processar em paralelo do processamento principal (Main Thread),  notificando ele de todos os resultados: progresso, finalização ou falha.

O que é ForkJoinPool ?

Linl: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ForkJoinPool.html

De um modo simples ele que vai gerenciar as execuções dos nossos processamentos em paralelo. O ForkJoinPool fornece o ponto de entrada para as tarefas, bem como operações de gerenciamento e monitoramento.

Codificando

Vamos configurar o nosso gerenciador ForkJoinPool , no caso do SPRING, vamos criar um @Configuration e um @Bean para retornar a configuração de 200 Threads em paralelo, conforme abaixo:

package br.com.byiorio.performance_test.infra;

import java.util.concurrent.ForkJoinPool;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ForkJoinConfig {

    @Value("${server.parallelism:200}")

    private String parallelism;

    @Bean
    public ForkJoinPool getForkJoinPool() {
        return new ForkJoinPool(Integer.valueOf(parallelism));
    }

}

Dentro do nosso @Service vamos criar o nosso ForkJoinPool.

    @Autowired
    ForkJoinPool forkJoinPool;

Vamos usar o CompletableFuture.supplyAsync() para solicitar a execução da chamada do Feign em paralelo

   CompletableFuture<CardResponse> cardinfo = CompletableFuture.supplyAsync(() -> feignCardClient.getCard(accountNumber), forkJoinPool);

Agora vamos usar o método .get() para pegar o resultado, o método completo ficaria assim:

public BalanceResponse usandoFeignCompletableFuture(Integer accountNumber) throws InterruptedException, ExecutionException {
        BalanceResponse balanceResponse = new BalanceResponse();

        //Faz a primeira chamada
        CompletableFuture<CardResponse> cardinfo = CompletableFuture.supplyAsync(() -> feignCardClient.getCard(accountNumber), forkJoinPool);

        //Faz a segunda chamada
        CompletableFuture<StatusResponse> statusInfo = CompletableFuture.supplyAsync(() -> feignStatusClient.getStatus(accountNumber), forkJoinPool);

        //Juntando as respostas
        balanceResponse.setCardNumber(cardinfo.get().getCardNumber());
        balanceResponse.setStatus(statusInfo.get().getCode());

        // Adiciona o balance
        balanceResponse.setBalance(getBalance(accountNumber));

        return balanceResponse;
    }

Resultado

Com o uso das Threads o processo em paralelo pode ser executado chegando na mesma performance do WebCliente conforme mostrado no vídeo.

feign client; performance; teste;