 |
| Homem com a mão estendida com a palma virada para cima e a escrita API em cima. |
Índice
O que é API?
API (Application Programming Interface) é um conjunto de regras e definições que permite que diferentes softwares ou sistemas se comuniquem entre si. As APIs são responsáveis por fornecer meios estruturados para que uma aplicação acesse funcionalidades ou dados de outra, sem que seja necessário expor ou manipular diretamente o código-fonte dessa aplicação.
Imagine que uma API é como um garçom em um restaurante: ela recebe o pedido de um cliente (uma aplicação), leva esse pedido para a cozinha (outro sistema) e depois retorna com o prato (os dados ou funcionalidades solicitados). Essa comunicação é feita de maneira padronizada, o que facilita o desenvolvimento e a integração de diversas tecnologias.
Exemplo de API em Delphi
Em Delphi, as APIs podem ser consumidas de várias maneiras, principalmente utilizando o protocolo HTTP para se conectar a serviços web. Abaixo, um exemplo básico de como realizar uma chamada a uma API usando Delphi:
uses
System.Net.HttpClient, System.Net.URLClient, System.SysUtils;
procedure ChamarAPI;
var
HTTP: THTTPClient;
Resposta: IHTTPResponse;
begin
HTTP := THTTPClient.Create;
try
Resposta := HTTP.Get('https://api.chucknorris.io/jokes/random');
ShowMessage(Resposta.ContentAsString);
finally
HTTP.Free;
end;
end;
Neste código, utilizamos o componente THTTPClient para enviar uma requisição HTTP para uma API, e a resposta recebida é exibida em uma janela de mensagem.
O que é API RESTful?
Uma API RESTful é uma API que segue os princípios da arquitetura REST (Representational State Transfer). O REST é uma abordagem que utiliza os métodos HTTP (GET, POST, PUT, DELETE, etc.) para gerenciar e acessar recursos de forma simples e eficiente.
As APIs RESTful são amplamente utilizadas devido à sua flexibilidade e escalabilidade, permitindo que dados sejam transmitidos entre o cliente e o servidor em diversos formatos, como JSON ou XML.
Principais características de uma API RESTful:
- Stateless: Cada requisição do cliente ao servidor deve conter todas as informações necessárias para o processamento. Não há necessidade de armazenar o estado do cliente no servidor.
- Cacheable: Respostas de APIs RESTful podem ser cacheadas, o que melhora a eficiência.
- Métodos HTTP: Cada método tem uma função específica (GET para obter dados, POST para criar, PUT para atualizar, DELETE para remover).
Consumindo uma API REST no Delphi e Exibindo Imagem no TImage
Neste exemplo, vamos aprender como consumir uma API REST no Delphi utilizando o componente THTTPClient, interpretar o retorno em JSON e ainda carregar uma imagem retornada pela API em um componente TImage.
A API utilizada será a famosa Chuck Norris API, que retorna frases aleatórias e um ícone.
Exemplo de Consumo de API RESTful em Delphi: Código completo
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, System.Net.HttpClient,
System.Net.URLClient, System.JSON, Vcl.ExtCtrls, Vcl.Imaging.jpeg, Vcl.Imaging.pngimage;
type
TForm1 = class(TForm)
btnConsumirApi: TButton;
imgAvatar: TImage;
mmValue: TMemo;
mmContent: TMemo;
procedure btnConsumirApiClick(Sender: TObject);
private
procedure ConsumirAPIREST;
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.btnConsumirApiClick(Sender: TObject);
begin
ConsumirAPIREST;
end;
procedure TForm1.ConsumirAPIREST;
var
Http: THTTPClient;
Response: IHTTPResponse;
JSONObj: TJSONObject;
URL, URLImagem: string;
ImgResponse: IHTTPResponse;
ImgStream: TMemoryStream;
ContentType: string;
Jpeg: TJPEGImage;
Png: TPngImage;
begin
mmContent.Lines.Clear;
mmValue.Lines.Clear;
Http := THTTPClient.Create;
try
URL := 'https://api.chucknorris.io/jokes/random';
Response := Http.Get(URL);
if Response.StatusCode = 200 then
begin
mmContent.Lines.Add(Response.ContentAsString());
JSONObj := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
try
mmValue.Lines.Clear;
mmValue.Lines.Add('frase: ' + JSONObj.GetValue<string>('value'));
mmValue.Lines.Add('url: ' + JSONObj.GetValue<string>('url'));
// Baixar avatar
URLImagem := JSONObj.GetValue<string>('icon_url');
ImgResponse := Http.Get(URLImagem);
if ImgResponse.StatusCode = 200 then
begin
ImgStream := TMemoryStream.Create;
try
ImgResponse.ContentStream.Position := 0;
ImgStream.CopyFrom(ImgResponse.ContentStream, -1);
ImgStream.Position := 0;
ContentType := ImgResponse.HeaderValue['Content-Type'];
if ContentType.Contains('jpeg') then
begin
Jpeg := TJPEGImage.Create;
try
Jpeg.LoadFromStream(ImgStream);
imgAvatar.Picture.Assign(Jpeg);
finally
Jpeg.Free;
end;
end
else if ContentType.Contains('png') then
begin
Png := TPngImage.Create;
try
Png.LoadFromStream(ImgStream);
imgAvatar.Picture.Assign(Png);
finally
Png.Free;
end;
end
else
ShowMessage('Formato não suportado: ' + ContentType);
finally
ImgStream.Free;
end;
end;
finally
JSONObj.Free;
end;
end
else
ShowMessage('Erro: ' + Response.StatusCode.ToString);
finally
Http.Free;
end;
end;
end.
Este código demonstra como consumir uma API RESTful usando as classes do framework REST Client Library. O cliente realiza uma requisição GET para buscar dados de uma api e exibe os dados recebidos como resposta.
Veja abaixo a ilustração do projeto:
Código fonte do exemplo
Você pode fazer o download do exemplo do projeto através do repositório do github:
https://github.com/Gisele-de-Melo/API-ChuckNorris
Estrutura do Projeto
O formulário contém os seguintes componentes:
btnConsumirApi → botão para executar a consulta
imgAvatar → exibe a imagem retornada pela API
mmContent → mostra o JSON bruto retornado
mmValue → mostra apenas os campos tratados
Units Utilizadas
System.Net.HttpClient
System.Net.URLClient
System.JSON
Vcl.Imaging.jpeg
Vcl.Imaging.pngimage
Finalidade de cada uma:
System.Net.HttpClient→ responsável pelas requisições HTTPSystem.JSON→ manipulação de JSONjpegepngimage→ carregamento de imagens JPEG e PNG
Clique do Botão
procedure TForm1.btnConsumirApiClick(Sender: TObject);
begin
ConsumirAPIREST;
end;
Ao clicar no botão, chamamos o método principal que irá consumir a API.
Método Principal
procedure TForm1.ConsumirAPIREST;
Esse método executa todo o processo:
Faz requisição para API
Lê o JSON
Extrai valores desejados
Faz download da imagem
Exibe no formulário
Criando o Cliente HTTP
Http := THTTPClient.Create;
Criamos uma instância do THTTPClient, componente moderno do Delphi para comunicação HTTP/HTTPS.
Fazendo a Requisição GET
URL := 'https://api.chucknorris.io/jokes/random';
Response := Http.Get(URL);
Aqui fazemos uma requisição GET para obter uma piada aleatória.
Validando Retorno
if Response.StatusCode = 200 then
O código 200 indica sucesso na requisição.
Exibindo JSON Bruto
mmContent.Lines.Add(Response.ContentAsString());
Mostramos no Memo todo o conteúdo retornado pela API.
Convertendo JSON em Objeto
JSONObj := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
Transformamos a string JSON em objeto Delphi para facilitar a leitura dos campos.
Lendo Valores do JSON
JSONObj.GetValue<string>('value')
JSONObj.GetValue<string>('url')
Campos utilizados:
value→ frase retornadaurl→ link da piada
Exibimos assim:
mmValue.Lines.Add('frase: ...');
mmValue.Lines.Add('url: ...');
Obtendo URL da Imagem
URLImagem := JSONObj.GetValue<string>('icon_url');
A API retorna a URL do ícone do Chuck Norris.
Fazendo Download da Imagem
ImgResponse := Http.Get(URLImagem);
Nova requisição GET, agora para baixar a imagem.
Copiando para Stream
ImgStream := TMemoryStream.Create;
ImgResponse.ContentStream.Position := 0;
ImgStream.CopyFrom(ImgResponse.ContentStream, -1);
A imagem baixada é copiada para memória usando TMemoryStream.
Descobrindo Tipo da Imagem
ContentType := ImgResponse.HeaderValue['Content-Type'];
Lemos o cabeçalho HTTP para saber se a imagem é:
JPEG
PNG
Carregando JPEG
if ContentType.Contains('jpeg') then
Se for JPEG:
Jpeg.LoadFromStream(ImgStream);
imgAvatar.Picture.Assign(Jpeg);
🚀 Quer Aprender Delphi na Prática?
Desenvolva um sistema completo do zero com VCL, FireDAC, POO e Banco de Dados.
📘 Curso em PDF + Código Fonte
⚡ Acesso imediato
💡 Ideal para iniciantes e programadores Delphi
Carregando PNG
else if ContentType.Contains('png') then
Se for PNG:
Png.LoadFromStream(ImgStream);
imgAvatar.Picture.Assign(Png);
Tratamento de Formato Inválido
ShowMessage('Formato não suportado');
Caso a imagem venha em outro formato.
Liberação de Memória
Todo objeto criado manualmente é destruído com Free dentro de blocos try/finally.
Exemplo:
Http.Free;
JSONObj.Free;
ImgStream.Free;
Isso evita vazamentos de memória.
Resultado Final
Ao clicar no botão:
✔ API é consumida
✔ JSON exibido
✔ Valores tratados mostrados
✔ Imagem carregada no TImage
Vantagens do THTTPClient
Suporte nativo HTTPS
Não precisa DLL externa
Moderno e simples de usar
Ideal para APIs REST
Vantagens e Desvantagens de Utilizar APIs
Vantagens:
- Facilita a Integração entre Sistemas: As APIs permitem que diferentes sistemas troquem informações e funcionalidades de forma eficiente e padronizada, sem que os desenvolvedores precisem reescrever código existente.
- Aumento da Produtividade: Com APIs, desenvolvedores podem reutilizar funcionalidades existentes, como serviços de pagamento ou geolocalização, sem precisar construir esses recursos do zero.
- Escalabilidade: Muitas APIs são projetadas para suportar grandes volumes de solicitações simultâneas, o que permite que aplicações baseadas em APIs cresçam de forma escalável.
- Separação de Frontend e Backend: APIs permitem que o frontend de uma aplicação (interface do usuário) e o backend (servidor) sejam desenvolvidos de forma independente, facilitando a manutenção e atualizações.
Desvantagens:
- Dependência Externa: Ao utilizar uma API de terceiros, a aplicação pode se tornar dependente da disponibilidade e funcionamento dessa API. Se o serviço ficar indisponível, isso pode impactar diretamente a aplicação.
- Limitações de Uso: Muitas APIs possuem limites de requisições por minuto ou por hora, o que pode restringir o uso da API em certos cenários.
- Segurança: APIs mal configuradas podem expor dados sensíveis ou criar brechas de segurança. É crucial garantir a implementação de mecanismos de autenticação e autorização adequados.
- Complexidade na Implementação: Em alguns casos, a integração com APIs pode exigir a manipulação de formatos de dados complexos (como JSON aninhado), o que pode aumentar a complexidade do código.
Conclusão
APIs desempenham um papel essencial no desenvolvimento de software moderno, permitindo que diferentes sistemas se conectem e troquem dados de maneira eficiente. As APIs RESTful, em particular, são amplamente utilizadas por sua simplicidade e flexibilidade. Ao integrar APIs em Delphi, como mostrado nos exemplos, é possível aproveitar essas vantagens para criar aplicações robustas e conectadas.
Nenhum comentário:
Postar um comentário