Como Fazer uma Requisição HTTP para Obter um JSON em Delphi

Fala galera de Delphi, tudo beleza?

Neste post, vamos aprender como fazer uma requisição HTTP para obter um arquivo JSON a partir de uma URL em Delphi. Utilizaremos a biblioteca TNetHTTPClient, que é fácil de usar e está disponível nas versões mais recentes do Delphi.

Passos Iniciais

1. Crie um novo projeto Delphi VCL ou FMX.
2. Adicione um componente TNetHTTPClient ao seu formulário.
3. Adicione um botão (TButton) e um memo (TMemo) ao formulário para iniciar a requisição e exibir os dados recebidos.

Importando Módulos Necessários

Primeiro, precisamos importar os módulos necessários. Abra o formulário principal e adicione as seguintes unidades à seção uses:

uses
  System.SysUtils, System.Classes, System.JSON, System.Net.HttpClient, System.Net.URLClient, System.Net.HttpClientComponent;

Estrutura do Formulário

No formulário principal, adicione os seguintes componentes:

• TNetHTTPClient: Nomeie como NetHTTPClient1.
• TButton: Nomeie como Button1 e defina o evento OnClick para iniciar a requisição.
• TMemo: Nomeie como Memo1 para exibir o JSON recebido.

Código para Fazer a Requisição

Aqui está o código completo que você deve adicionar ao evento OnClick do botão:

procedure TForm1.Button1Click(Sender: TObject);
var
  LResponse: IHTTPResponse;
  LJSONObject: TJSONObject;
  LStreamReader: TStreamReader;
begin
  try
    // Faz a requisição GET para obter o JSON
    LResponse := NetHTTPClient1.Get('https://api.example.com/list');

    // Verifica se a requisição foi bem-sucedida
    if LResponse.StatusCode = 200 then
    begin
      // Lê a resposta JSON
      LStreamReader := TStreamReader.Create(LResponse.ContentStream, TEncoding.UTF8);
      try
        // Carrega o conteúdo JSON em um objeto TJSONObject
        LJSONObject := TJSONObject.ParseJSONValue(LStreamReader.ReadToEnd) as TJSONObject;
        try
          // Agora você pode acessar os dados do JSON
          // Exemplo: Mostrar o JSON em um memo
          Memo1.Lines.Text := LJSONObject.ToString;
        finally
          LJSONObject.Free;
        end;
      finally
        LStreamReader.Free;
      end;
    end
    else
    begin
      ShowMessage('Erro ao obter JSON: ' + LResponse.StatusCode.ToString);
    end;
  except
    on E: Exception do
      ShowMessage('Exceção ao obter JSON: ' + E.Message);
  end;
end;

Explicação do Código

1. Fazendo a Requisição HTTP:
   • Utilizamos NetHTTPClient1.Get para fazer uma requisição GET para a URL especificada.
   • LResponse contém a resposta da requisição.
2. Verificando a Resposta:
   • LResponse.StatusCode é verificado para garantir que a requisição foi bem-sucedida (código 200).
3. Lendo e Processando o JSON:
   • TStreamReader é usado para ler a resposta do fluxo de conteúdo (LResponse.ContentStream).
   • TJSONObject.ParseJSONValue converte a string JSON em um objeto TJSONObject.
   • O conteúdo do JSON é exibido no TMemo (Memo1.Lines.Text := LJSONObject.ToString).
4. Tratamento de Exceções:
   • try...except é usado para capturar e exibir qualquer exceção que ocorra durante o processo de requisição e leitura do JSON.

Executando o Projeto

Após adicionar o código acima, compile e execute o projeto. Clique no botão para iniciar a requisição e, se tudo estiver correto, o JSON recebido será exibido no TMemo.

Expandindo o Exemplo

Além do método GET, que usamos para obter dados, há outros métodos HTTP importantes que são frequentemente utilizados para manipular dados em uma API. Vamos dar uma breve olhada nos métodos POST, PUT e DELETE.

Método POST

O método POST é utilizado para enviar dados ao servidor para criar um novo recurso. Por exemplo, ao preencher um formulário de registro de usuário, os dados do formulário são enviados ao servidor usando o método POST.

var
  HTTPClient: TNetHTTPClient;
  Response: IHTTPResponse;
  JSONToSend: TStringStream;
begin
  HTTPClient := TNetHTTPClient.Create(nil);
  try
    JSONToSend := TStringStream.Create('{"name":"John Doe","email":"john@example.com"}', TEncoding.UTF8);
    try
      Response := HTTPClient.Post('https://api.example.com/users', JSONToSend);
      // Processar a resposta
    finally
      JSONToSend.Free;
    end;
  finally
    HTTPClient.Free;
  end;
end;

Método PUT

O método PUT é usado para atualizar um recurso existente no servidor. Diferente do POST, o PUT geralmente requer que você especifique o recurso que está sendo atualizado.

var
  HTTPClient: TNetHTTPClient;
  Response: IHTTPResponse;
  JSONToSend: TStringStream;
begin
  HTTPClient := TNetHTTPClient.Create(nil);
  try
    JSONToSend := TStringStream.Create('{"name":"John Doe","email":"john.doe@example.com"}', TEncoding.UTF8);
    try
      Response := HTTPClient.Put('https://api.example.com/users/1', JSONToSend); // Atualiza o usuário com ID 1
      // Processar a resposta
    finally
      JSONToSend.Free;
    end;
  finally
    HTTPClient.Free;
  end;
end;

Método DELETE

O método DELETE é utilizado para remover um recurso existente no servidor. Por exemplo, para deletar um usuário específico pelo seu ID.

var
  HTTPClient: TNetHTTPClient;
  Response: IHTTPResponse;
begin
  HTTPClient := TNetHTTPClient.Create(nil);
  try
    Response := HTTPClient.Delete('https://api.example.com/users/1'); // Deleta o usuário com ID 1
    // Processar a resposta
  finally
    HTTPClient.Free;
  end;
end;

Conclusão

Neste post, exploramos como fazer uma requisição HTTP para obter um JSON em Delphi usando a biblioteca TNetHTTPClient. Aprendemos a configurar o projeto, adicionar os componentes necessários e escrever o código para realizar a requisição, processar a resposta e exibir o conteúdo JSON em um TMemo.

Também demos uma breve introdução aos métodos HTTP POST, PUT e DELETE, que são fundamentais para interagir com APIs RESTful de maneira completa, permitindo não apenas a leitura de dados, mas também a criação, atualização e exclusão de recursos no servidor.

O que Aprendemos

• Requisição GET: Como utilizar o método GET para obter dados JSON de uma URL e processar a resposta em Delphi.
• Componentes do Delphi: Uso de TNetHTTPClient, TButton e TMemo para realizar requisições HTTP e manipular dados.
• Leitura de JSON: Conversão de uma resposta JSON em um objeto TJSONObject e exibição do conteúdo.
• Introdução a POST, PUT e DELETE: Compreensão básica dos métodos HTTP adicionais para interagir com APIs de maneira mais robusta.

Com essas habilidades, você está bem equipado para começar a integrar Delphi com APIs RESTful, possibilitando uma vasta gama de funcionalidades em suas aplicações. No próximo post, aprofundaremos nossos conhecimentos sobre os métodos POST, PUT e DELETE, abordando exemplos práticos de como utilizá-los para enviar, atualizar e deletar dados de um servidor.

Beleza pessoal? Espero que possa ajudar.

Dúvida ou sugestões? Deixe o seu comentário!

Um abraço e até o próximo post. Valeu!

#Delphi

#Programação

#APIs

#Desenvolvimento

#GiovaniDaCruz