Fala ai Radizeiros e Radizeiras, tudo bem com vocês?

O crescimento de integrações no mercado da tecnologia tem crescido muito.

E hoje é primordial termos integrações em nossos software.

E no post de hoje iremos mostrar a praticidade de consumir uma api rest utilizando LiveBindings.

Vamos construir um exemplo para consumir um servidor rest.

Vamos criar um projeto FMX mesmo.

Iremos consumir um servidor Rest de CEP, isso mesmo, um servidor Rest que nos retorna os CEP de todas as UF.

O site é o www.viacep.com.br, que consulta todos os CEPs do Brasil, gratuito e de simples utilização.

Se hoje você não utiliza uma api Rest, e ainda uma api que lhe retorne todos os endereços disponíveis, essa é a hora.

E no post de hoje irei mostrar utilizando a biblioteca de paralelismo.

Para analisar o retorno da api de cep, vamos utilizar o Rest Debugger que já acompanha o Delphi.

Vamos copiar o endereço da URI disponível no site da ViaCep.

Vou copiar agora esse endereço, colocar no Rest Debugger e clicar em send resquest.

E agora, o que fazemos para trazer isso para dentro do Delphi, para começarmos agora a criar a nossa aplicação?

Com o Rest Debugger, se você não sabe disso, irá ver agora.

Acabamos de consumir a URI de CEP, na tela no Rest Debugger tem o botão “Copy components”, com isso ele irá copiar para a área de transferência do windows todos os componentes necessários e já com todas as informações necessárias para serem salvas e coladas em nosso projeto.

Agora só colocarmos no nosso projeto.

Viu que os componentes necessários para fazer as requisições rest já encontram-se no projeto, muito legal não é?

Agora iremos adicionar dois componentes a mais para exibirmos os dados na tela, que será o FDMemTable, e um TRestResponseDataSetAdapter.

O TRestResponseDataSetAdapter, é o componente que fica entre as requisições e o FDMemtable, onde em suas configurações iremos apontar para o Dataset e o Response.

Com isso já conseguimos ligar os dados para que nosso projeto já possa funcionar.

Vamos ver agora esses dados?

Vamos colocar um StringGrid na tela vamos ver os dados e depois vamos tratar o rest com a TASK.

Mas para realizar essa conexão irei utilizar o LivBindgins para facilitar e não perdermos muito tempo rodando na munheca.

Basta clicar com o botão direito em cima do TRestResponseDataSetAdapter, e clicar em Bind Visual.

Simplesmente eu ligo o asterisco do meu stringgrid com o asterisco do FDMemtable.

Desta forma já é adicionado na tela do projeto os componentes necessários para ligação, e pronto, quando os dados chegarem no FDMemtable teremos os dados na Stringgrid.

Para que possamos testar em tempo de design só clicar com o botão direito no componente RestRequest clicando em execute.

Isso é possível porque ao copiarmos os componentes pelo Rest Debugger, onde ele já deixa todos os parâmetros preenchidos.

Observe que retornou uma mensagem de OK, e os dados apareceram na stringgrid.

Isso nos ajuda porque, ao ir no FDMemtable, e com o botão direito e em field editor podemos adicionar todos os campos.

Agora eu já tenho todos os campos no FDMemTable e também no Livebindings

Observe que eu posso testar em tempo de design e não em tempo de execução a minha requisição rest e formatar esse campos.

E vamos fazer o seguinte, vamos colocar alguns edits na tela para que possamos manipular os dados também neles.

Agora iremos linkar cada edit com o FDMemtable usando LiveBinds.

Observe que coloquei cada edit linkado com seu respectivo campo, muito legal não é pessoa?

Viu como o Delphi facilita e muito a nossa vida?

Agora já temos o nosso projeto pronto para funcionar com as requisições da api rest de CEP.

Muito legal não é?

Agora iremos trabalhar a nossa requisição.

Vamos no componente RestRequest,e vai uma dica, vejo poucas pessoas falando sobre esses detalhes.

Se você olhar no RestClient, estou passando todo o caminho para as requisições.

Quando vai utilizar esses componentes rest, o programador concatena tudo e manda no base url todas as informações.

Não precisa fazer isso, tá legal?

Nesse campos baseurl irei deixar somente de fato a base url.

Agora vamos no RestRequest, onde ele tem uma opção chamada resource, onde colocamos o recurso, que vai entrar após a base.

Mas se você observar o cep dessa nossa url é volátil, ou seja, ele muda, então dentro dessa opção iremos criar um parâmetro.

Agora ao iremos na opção de parâmetros e clicarmos já podemos ver o parâmetro adicionado no recurso.

E ainda podemos deixar um valor default nele para que ao inciar já carrega esses parâmetros preenchidos.

É dessa forma que devemos trabalhar com os componentes de requisições rest.

Desta forma eu consigo alterar os parâmetros dinamicamente.

Nada de fica concatenando tudo na baseurl.

Usem o RestRequest e as propriedades que ele possui para isso.

Agora vamos fazer a nossa requisição usando as Task de fato.

Dentro do botão de busca iremos fazer essas requisições.

procedure TForm1.Button1Click(Sender: TObject);
begin
    TThread.Synchronize(TThread.CurrentThread,
    procedure
    begin
        AniIndicator1.visible:=true;
        AniIndicator1.Enabled:=true;
    end);

    TTask.Run(procedure
    begin
        Sleep(5000);
        TThread.Synchronize(TThread.CurrentThread,
        procedure
        begin
            RESTRequest1.params.ParameterByName('CEP').value:=edtcep.text;
            RESTRequest1.execute;
            AniIndicator1.visible:=false;
            AniIndicator1.Enabled:=false;
        end);
    end);
end;

Não precisávamos colocar o AniIndicator em uma thread separada, mas foi colocado para que tenhamos certeza que esteja rodando tudo em thread separada.

E todas as vezes que vamos mexer com componentes visuais, componentes que estão na tela e que não são Thread Safe, precisamos utilizar o Synchronize.

Logo em seguida criamos uma tarefa para fazer as requisições, onde deixamos ela rodando em uma tarefa separada.

Observe que dentro do método anonymo da tarefa implementamos a requisição.

Lembra que criamos um parâmetro chamado CEP?

Simplesmente preenchemos esse parâmetro no RestRequest.

Viu que criamos um exemplo bem simples onde fazemos uma requisição usando uma tarefa separada? 

Vamos ver ele funcionando.

Observe que foi feito uma requisição e que nossa aplicação não trava, tudo rodando perfeitamente.

Com os Livebindings conseguimos agilizar e muito as implementações das telas e muito mais.

Dessa forma conseguimos criar uma consulta de CEP usando as Thread, se preocupando com a experiência do usuário.

Essa aula é mais uma do CLUBE DOS PROGRAMADORES EM DELPHI, e dentro desse clube você não encontra só essa série, mas muitas outras que irá lhe ajudar e muito com o desenvolvimento das suas aplicações.

E caso você tenha interesse de conhecer mais sobre PPL acessa o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI, onde você não só terá conteúdos relacionados aos generics, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI