Como fazer chamadas assíncronas via Custom Javascript

Vitor Anjos

24 de junho de 2019 13:49
Atualizado

Muitas vezes nos deparamos com situações em que a montagem da requisição é muito trabalhosa, sendo necessário montá-la através do Interceptor customizado Javascript ao invés do uso do Internal API Call ou Service Callout. Além da complexidade da requisição, muitas vezes não é necessário esperarmos a resposta dela para continuar a requisição original. Para tanto, nesse artigo explicaremos como fazer chamadas assíncronas no customJS (Rhino):

Inicialmente, consideraremos:

"chamada principal" a chamada realizada para um recurso de uma API. Exemplo: GET /carros
Consideraremos "chamada JS" a chamada realizada através do custom JS que queremos que seja assíncrona.

Para realizar uma chamada http assíncrona no custom javascript (chamado JS) é necessário iniciar uma Thread nova, como no exemplo abaixo:

var Thread = java.lang.Thread;

new Thread(function () {
    // chamada assíncrona visto que executa em outra thread
    // monte a requisição como desejar :)   
    $http.get("http://supermock.demo.sensedia.com/?sleep=20"); // demorará 20s porém esse tempo não será esperado para continuar o fluxo da chamada Principal
}).start();

$call.tracer.trace("Thread started with http request", "OK");

A Thread nova conterá a lógica da requisição, evitando que a Thread "principal" do algoritmo fique esperando a resposta da mesma. Nesse sentido, a Thread responsável pela chamada JS será executada em paralelo a Thread principal, fazendo com que a chamada principal continue seu fluxo normalmente, independente do tempo de resposta da chamada JS.

Vale a pena destacar no snippet de código acima a utilização da linha abaixo, a qual ajuda-nos a não ter que adicionar o pacote da classe toda vez que temos que utilizá-la:

var Thread = java.lang.Thread;

// referência a java.lang.Thread pode ser Thread por conta da linha acima.
// var Thread = new Thread(...);

Conclusão

Em essência, podemos adicionar qualquer lógica na Thread nova (alguma regra de negócio envolvida por exemplo), não se limitando apenas a chamadas assíncronas. Vale a criatividade e necessidade da implementação para tal.

Comentários

1 comentário

Complementando

Na parte em que temos o comentário:

// monte a requisição como desejar :)

Temos que lembrar só do seguinte, se quisermos fazer chamadas dentro de um loop, como, por exemplo, fazer chamadas pra uma operação de paginação, pode ser um problema executar a função imediatamente dentro da function que por sua vez está dentro do new Thread.

A forma que encontramos de superar essa limitação foi de jogar pra um objeto que tem como execução uma função imediatamente invocada (IIFE) e como retorno dela uma new Thread, com isso conseguimos parametrizar as chamadas a serem executas em paralelo, exemplo:

Após ter instanciado as 8 Threads e tê-las colocado pra rodar com o método start(), percorremos todas elas e chamamos o método join(), com isto iremos aguardar a execução de todas as Threads até o final.

exemplo:

for (let i=0+jump; i < threadPoolSize+jump; i++) {
threadPool[i].t.join();
}

A partir desse momento conseguimos fazer validações e chamar mais 8 páginas, caso tenham mais que 8 páginas, ou se for o caso instanciar e chamar novamente as páginas que deram erros de serem chamadas.

Guilherme Rodella

27 de abril de 2021 02:49

Editado
Excelente artigo! Só gostaria de acrescentar comentando como ficaria uma solução parametrizada, que foi o desafio do time aqui...

Complementando

Na parte em que temos o comentário:
```
// monte a requisição como desejar :)
```
Temos que lembrar só do seguinte, se quisermos fazer chamadas dentro de um loop, como, por exemplo, fazer chamadas pra uma operação de paginação, pode ser um problema executar a função imediatamente dentro da function que por sua vez está dentro do new Thread.

A forma que encontramos de superar essa limitação foi de jogar pra um objeto que tem como execução uma função imediatamente invocada (IIFE) e como retorno dela uma new Thread, com isso conseguimos parametrizar as chamadas a serem executas em paralelo, exemplo:
```
const threadPoolSize = 8;
var threadPool = [];
var retrives = [];

var jump = 0;
var page = 0;
    
var customHeaders = {
    'Content-Type': 'application/json'
};

for (let i=1; i <= threadPoolSize; i++) {
    page = i + jump;
    var o = {
        t: (function(url, page, customHeaders) {
            return new Thread(function() {
                retrives.push($http.get(url + '?offset=' + page, customHeaders));
            });
        })('http://url-com-paginacao', page, customHeaders)
    };
    threadPool.push(o);
    o.t.start();
}
```
Após ter instanciado as 8 Threads e tê-las colocado pra rodar com o método start(), percorremos todas elas e chamamos o método join(), com isto iremos aguardar a execução de todas as Threads até o final.

exemplo:
```
for (let i=0+jump; i < threadPoolSize+jump; i++) {
    threadPool[i].t.join();
}
```
A partir desse momento conseguimos fazer validações e chamar mais 8 páginas, caso tenham mais que 8 páginas, ou se for o caso instanciar e chamar novamente as páginas que deram erros de serem chamadas.
4

Por favor, entre para comentar.

Conclusão

Artigos relacionados

Complementando