{"componentChunkName":"component---src-templates-blog-post-js","path":"/spring-feign-assincrono/","result":{"data":{"markdownRemark":{"html":"

Muitas vezes precisamos fazer comunicação com outros serviços externos, seja um GET, um POST ou etc. e por diversas vezes podemos fazer esse processamento de forma assíncrona, sem precisar esperar pela resposta. E se ocorre uma falha nessa requisição HTTP o que fazer? As vezes a resposta pode ser simples as vezes não, mas seria bom poder ter uma forma de poder retentar fazer essa chamada ou então guardar isso para poder fazer essa requisição mais tarde.\nVamos fazer uma requisição para buscar no site do Correios e ver aqui uma alternativa a isso usando Feign para fazer as chamadas assíncronas e primeira retentativa e o mecanismo de Scheduling que o Spring nos provê para fazer o agendamento de requisições que falharam.\nPara esse projeto estou usando Spring Boot e com Gradle para gerenciar as dependências.

\n

Client

\n

Vamos começar com o nosso client que irá fazer a buscar:

\n
@FeignClient(name = \"cepClient\", url = \"${externalUrl}\")\npublic interface CepClient {\n\n    @GetMapping(value = \"/v1/cep/{cep}\")\n    Cep get(@PathVariable(\"cep\") String cep);\n}
\n

Aqui usamos o FeignClient e criamos uma interface onde temos um método chamado get que anotamos com um @GetMapping com o path do CEP. A nossa interface é anotada com o @FeignClient onde passamos um name para ele e a url que está no nossa arquivo de properties. E mapeamos o retorno com o objeto Cep que contém as informações:

\n
@Data\npublic class Cep {\n\n    private String logradouro;\n    private String bairro;\n    private String cidade;\n    private String estado;\n\n}
\n

Até aqui se usarmos esse client teremos uma requisição HTTP do tipo GET síncrona e para deixar ela de forma assíncrona devemos fazer a nossa configuração:

\n
@Configuration\n@EnableAsync\npublic class ThreadPoolTaskAsyncConfig {\n\n    @Bean(name = \"threadPoolTaskAsyncExecutor\")\n    public Executor threadPoolTaskExecutor() {\n        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();\n        threadPoolTaskExecutor.setMaxPoolSize(50);\n        threadPoolTaskExecutor.setCorePoolSize(50);\n        threadPoolTaskExecutor.setQueueCapacity(50);\n        return threadPoolTaskExecutor;\n    }\n\n}
\n

Aqui criamos a nossa classe de configuração com a anotação @Configuration e também adicionamos a @EnableAsync que nos permite fazer essa comunicação assíncrona. Temos o nosso @Bean nomeado threadPoolTaskAsyncExecutor e nele definimos um novo ThreadPoolTaskExecutor e configuramos para que tenha uma capacidade de processar até 50 threads, se por acaso tiver um número maior o processo fica em espera.\nCom isso temos o serviço podendo ser usado de forma assíncrona mas vamos ver agora como podemos tratar eventuais falhas quando formos fazer esse GET, caso a API esteja fora por exemplo, como podemos resolver isso?\nPor padrão o Feign lida com nas requisições com a interface Retryer então podemos implementar essa interface:

\n
@Slf4j\n@Component\n@NoArgsConstructor\npublic class CustomRetryer implements Retryer {\n\n    @Value(\"${retryMaxAttempt}\")\n    private int retryMaxAttempt;\n\n    @Value(\"${retryInterval}\")\n    private long retryInterval;\n\n    private int attempt = 1;\n\n    public CustomRetryer(int retryMaxAttempt, Long retryInterval) {\n        this.retryMaxAttempt = retryMaxAttempt;\n        this.retryInterval = retryInterval;\n    }\n\n    @Override\n    public void continueOrPropagate(RetryableException e) {\n        log.info(\"Feign retry attempt {} due to {} \", attempt, e.getMessage());\n\n        if(attempt++ == retryMaxAttempt){\n            throw e;\n        }\n        try {\n            Thread.sleep(retryInterval);\n        } catch (InterruptedException ignored) {\n            Thread.currentThread().interrupt();\n        }\n\n    }\n\n    @Override\n    public Retryer clone() {\n        return new CustomRetryer(retryMaxAttempt, retryInterval);\n    }\n}
\n

Explicando o código acima.\nImplementando essa interface Retryer temos os métodos clone e continueOrPropagate, no nosso clone instanciamos o nosso CustomRetryer onde passamos a quantidade máxima de tentativas para o retry e o intervalo para cada solicitação.\nNo continueOrPropagate recebemos a Exception e checamos se já estouramos o limite de retentativas e caso seja isso propagamos a Exception caso não esperamos o tempo que configuramos e Feign irá fazer o retry.\nO último detalhe que falta é que precisamos da anotação @EnableFeignClients que podemos colocar junto da nossa classe main:

\n
package com.example.demo;\n\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.cloud.openfeign.EnableFeignClients;\n\nimport java.util.Optional;\n\n@SpringBootApplication\n@EnableFeignClients\npublic class DemoApplication {\n\n\n\tpublic static void main(String[] args) {\n\t\tSpringApplication.run(DemoApplication.class, args);\n\t}\n}
\n

Service

\n

Com o nosso client criado vamos fazer a nossa camada de serviço que é quem irá fazer uso o do client de forma assíncrona, vamos começar criando a classe ConsultService:

\n
@Service\npublic class ConsultService {\n\n    @Autowired\n    private CepClient client;\n\n    public Optional<Cep> consultCep(String cep){\n\n        try {\n            Cep cepResponse = this.getByCep(cep).get();\n\n            return Optional.of(cepResponse);\n\n        }catch (RetryableException | InterruptedException | ExecutionException e){\n            //TODO\n        }\n\n        return Optional.empty();\n    }\n\n    @Async(\"threadPoolTaskAsyncExecutor\")\n    public CompletableFuture<Cep> getByCep(String cep){\n        return CompletableFuture.completedFuture(client.get(cep));\n    }\n\n}
\n

O ponto a ser observado é o método getByCep que faz a chamada ao client usamos a anotação @Async(“threadPoolTaskAsyncExecutor”) referenciando o nosso Bean que configuramos anteriormente e isso já nos permite fazer a chamada de forma assíncrona.\nO método getByCep está envolto em um bloco try/catch que o nosso CustomRetryer captura em caso de excessão e faz as retentativas.

\n

Schedule

\n

Até agora temos as nossas chamadas de forma assíncrona e um mecanismo de retentativas mas pense na seguinte situação e se a url estiver fora do ar? Não é uma situação que conseguimos resolver mas acreditamos que esse serviço eventualmente será reestabelecido então podemos guardar em algum lugar essa informação que deu errado e depois tentamos fazer a requisição. O Java já nos provê mecanismos para isso e o framework Spring Boot facilita aida mais esse processo, então vamos comçar criando a nossa classe de configuração para o serviço agendado (schedule):

\n
package com.example.demo.config;\n\nimport com.example.demo.service.ScheduleService;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;\n\n@Configuration\n@ComponentScan(basePackages = \"com.example.demo.service\", basePackageClasses = {ScheduleService.class})\npublic class ThreadPoolTaskSchedulerConfig {\n\n    @Bean\n    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {\n        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();\n        threadPoolTaskScheduler.setPoolSize(5);\n        threadPoolTaskScheduler.setThreadNamePrefix(\"ScheduleService\");\n        return threadPoolTaskScheduler;\n    }\n}
\n

Aqui temos o código onde temos a classe de configuração anotada com Configuration e adicionado o caminho do pacote e a classe que irá fazer o agendamento que ainda não criamos. No nosso Bean criamos uma instância de ThreadPoolTaskScheduler com um pool de 5 threads e nomeamos com o prefixo ScheduleService.\nAntes de continuar com as próximas configurações de schedule vamos fazer o mecanismo onde guardamos os dados das requisições que falharam e que deverão ser reprocessadas, vamos usar para fins de exemplo um banco de dados em memória, H2, e Spring Data para fazer o gerenciamento do banco.\nVamos começar criando a nossa model que iserá a representação da nossa tabela de banco de dados:

\n
@Data\n@Entity\n@NoArgsConstructor\npublic class Response {\n\n    @Id\n    private String cep;\n    private Date create_at;\n    private Date update_at;\n    private String logradouro;\n    private String bairro;\n    private String cidade;\n    private String estado;\n    private boolean success;\n\n}
\n

O campo que usaremos para fazer o nosso controle é o success que é um booleano. Vamos criar agora a nossa interface de comunicação que extende da interface JpaRepository:

\n
@Repository\npublic interface ResponseRepository extends JpaRepository<Response, Integer> {\n\n    Optional<List<Response>> findAllBySuccessIsFalse();\n\n    Optional<Response> findByCep(String cep);\n}
\n

Com essa herança de interface passamos a ter os métodos de gerenciamento que o JpaRepository nos dá mas ainda precisamos adicionar mais alguns um pouco mais específicos, graças ao Spring Data podemos fazer nossas querys usando query methods onde definimos a nossa busca, nesse caso, pela nomenclatura do método mais explicações estão aqui Query Methods.\nVamos criar nossa classe de serviço agendado:

\n
@Component(\"scheduleService\")\npublic class ScheduleService {\n\n    @Value(\"${cronTimer.reprocess}\")\n    private String reprocess;\n\n    @Autowired\n    private ThreadPoolTaskScheduler taskScheduler;\n\n    @Autowired\n    private ResponseRepository repository;\n\n    @Autowired\n    private ConsultService consultService;\n\n    @PostConstruct\n    public void init() {\n        taskScheduler.schedule(() -> {\n            repository.findAllBySuccessIsFalse().ifPresent(cepList -> cepList.forEach(cep -> consultService.consultCep(cep.getCep())));\n        }, new CronTrigger(reprocess));\n    }\n}
\n

Explicando o código acima temos nossa classe que é um Component do Spring e nele injetamos o nosso Scheduler, Repository e Service ainda temos a variável reprocess onde definimos uma expressão Cron: 0 */1 * * * *\n(Para saber mais sobre Cron Expressions)

\n

Onde ele vai rodar a cada minuto a nossa taskScheduler e faz uma busca na nossa repository todos os registros onde o campo success for false e vai chamar a nossa service.\nPara finalizar a nossa única alteração será na nossa service onde vamos começar a salvar os registros das nossas requisições e no campo success definimos se foi sucesso true ou falha false:

\n
@Service\npublic class ConsultService {\n\n    @Autowired\n    private CepClient client;\n\n    @Autowired\n    private ResponseRepository repository;\n\n    public Optional<Cep> consultCep(String cep){\n\n        try {\n            Cep cepResponse = this.getByCep(cep).get();\n\n            Response response = new Response();\n            response.setCep(cep);\n            response.setCreate_at(new Date());\n            response.setLogradouro(cepResponse.getLogradouro());\n            response.setBairro(cepResponse.getBairro());\n            response.setCidade(cepResponse.getCidade());\n            response.setEstado(cepResponse.getEstado());\n\n            repository.save(response);\n\n            return Optional.of(cepResponse);\n\n        }catch (RetryableException | InterruptedException | ExecutionException e){\n\n            Optional<Response> repositoryById = repository.findByCep(cep);\n            Response response;\n\n            if(repositoryById.isPresent()){\n                response = repositoryById.get();\n                response.setUpdate_at(new Date());\n            }else {\n                response = new Response();\n                response.setCep(cep);\n                response.setCreate_at(new Date());\n\n            }\n\n            repository.save(response);\n        }\n\n        return Optional.empty();\n    }\n\n    @Async(\"threadPoolTaskAsyncExecutor\")\n    public CompletableFuture<Cep> getByCep(String cep){\n        return CompletableFuture.completedFuture(client.get(cep));\n    }\n\n}
\n

Então aqui temos a nossa chamada assíncrona onde caso dê algum erro o nosso CustomRetryer vai tentar algumas vezes e após isso vai salvar como falha para ser processado posteriormente e caso dê certo nós gravamos como um registro de sucesso.

\n

Executando o serviço

\n

Agora vamos rodar tudo junto, pra isso vou usar a interface CommandLineRunner para ser executada no momento em que aplicação subir:

\n
@SpringBootApplication\n@EnableFeignClients\n@EnableScheduling\npublic class DemoApplication implements CommandLineRunner {\n\n\t@Autowired\n\tprivate ConsultService service;\n\n\tpublic static void main(String[] args) {\n\t\tSpringApplication.run(DemoApplication.class, args);\n\t}\n\n\t@Override\n\tpublic void run(String... args) throws Exception {\n\t\tOptional<Cep> cep = service.consultCep(\"01032000\");\n\t\tcep.ifPresent(System.out::println);\n\t}\n}
\n

Coloquei na classe main mesmo; então no momento da execução ele irá fazer a busca com o CEP informado.

\n

Conclusão

\n

Vimos aqui uma dentre outras mil formas que podemos pensar em fazer chamadas HTTP com um client de forma assíncrona, pensando em possíveis cenários de falha e com uma tentativa de reprocessamento agendado.\nSegue o link do projeto no GitHub

","fields":{"slug":"/spring-feign-assincrono/"},"frontmatter":{"date":"08 de setembro de 2020","description":"Como fazer chamadas REST assíncronas com Feign e com retry e agendamento","title":"Comunicação assíncrona com Feign","tags":["Desenvolvimento","Spring Boot","Feign","Assíncrono","Schedule"],"author":"Guilherme Alves","image":{"id":"b7134ed9-ef1a-5502-81b1-a3b71dd6282d","publicURL":"/static/b3d0cee8a895d39bf6956e6b74f24a93/spring.jpeg","childImageSharp":{"fluid":{"base64":"data:image/jpeg;base64,/9j/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wgARCAAKABQDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMCBf/EABUBAQEAAAAAAAAAAAAAAAAAAAIB/9oADAMBAAIQAxAAAAHrN0BksV//xAAaEAEBAAIDAAAAAAAAAAAAAAABAgADEiIx/9oACAEBAAEFAuzWykzXSzYckEPP/8QAFBEBAAAAAAAAAAAAAAAAAAAAEP/aAAgBAwEBPwE//8QAFREBAQAAAAAAAAAAAAAAAAAAAAH/2gAIAQIBAT8BR//EABsQAAEEAwAAAAAAAAAAAAAAAAABEBEhMlFh/9oACAEBAAY/Aso4JBsSi2//xAAZEAEBAQEBAQAAAAAAAAAAAAABEQAhQWH/2gAIAQEAAT8hbnmMAYgpL6e7pBhlyLjSAE+4BAQ3/9oADAMBAAIAAwAAABBT3//EABcRAQADAAAAAAAAAAAAAAAAAAABMVH/2gAIAQMBAT8Q1FP/xAAYEQEBAAMAAAAAAAAAAAAAAAABABEhQf/aAAgBAgEBPxDjBwbv/8QAHBABAAICAwEAAAAAAAAAAAAAAQARITFBgbHw/9oACAEBAAE/EKOv9gUOYMAstV04PeowzALmftdRSQuFTcyArQsgoQaAon//2Q==","aspectRatio":1.9875776397515528,"src":"/static/b3d0cee8a895d39bf6956e6b74f24a93/f496a/spring.jpg","srcSet":"/static/b3d0cee8a895d39bf6956e6b74f24a93/1983d/spring.jpg 320w,\n/static/b3d0cee8a895d39bf6956e6b74f24a93/f496a/spring.jpg 574w","sizes":"(max-width: 574px) 100vw, 574px"}}}},"timeToRead":8}},"pageContext":{"slug":"/spring-feign-assincrono/","previous":{"fields":{"slug":"/minha-experiencia-com-a-laboratoria/"},"frontmatter":{"title":"Minha experiência com a Laboratória","date":"08 set, 2020"}},"next":{"fields":{"slug":"/factory-strategy/"},"frontmatter":{"title":"Usando padrões de projeto em uma aplicação","date":"14 set, 2020"}}}},"staticQueryHashes":["63159454"]}