Prodotto autonomo HTTP Server, HTTP/2, gRPC e Google Cloud

sgcHTTP: componenti HTTP Server, HTTP/2, gRPC e Google Cloud per Delphi e C++ Builder

Un server HTTP e cinque componenti client. TsgcHTTPServer pubblica endpoint HTTP e file statici dalla tua applicazione: imposta Port, gestisci OnCommandGet, imposta Active. TsgcHTTP2Client parla HTTP/2 con stream multiplati su un'unica connessione TLS e compressione degli header HPACK. TsgcGRPCClient è un client gRPC costruito sopra di esso, per chiamate Protocol Buffers unarie e in streaming. Altre tre classi raggiungono Google Cloud su HTTPS puro: Pub/Sub, Calendar e Firebase Cloud Messaging. sgcHTTP è autonomo, include il runtime sgcWebSockets Core su cui sono costruiti il server e tutti e cinque i client.

Scarica la versione di prova gratuita Guarda i componenti
Codice sorgente completo
Da Delphi 7 a 13 e C++ Builder
Runtime incluso sgcWebSockets Core Il server HTTP, più il runtime HTTP, TLS e JSON sotto ogni client
HTTP/2 TsgcHTTP2Client
gRPC TsgcGRPCClient
GUARDALO IN AZIONE

Guarda sgcHTTP in due minuti

Un server HTTP, client HTTP/2 e gRPC per Delphi e C++Builder, più integrazioni già pronte con Google Cloud, Amazon e Apple Push.

3 Componenti nella palette Server HTTP, client HTTP/2 e client gRPC, una sola pagina nella palette
5 Classi client totali HTTP/2, gRPC e tre client Google Cloud
3 Servizi Google Cloud Pub/Sub, Calendar e Firebase Cloud Messaging
100% Codice sorgente incluso Il server HTTP, tutti e cinque i client e il runtime Core incluso
12 Mesi di aggiornamenti Ogni versione pubblicata mentre la licenza è attiva
PRIMA DI ACQUISTARE

Due cose che vale la pena sapere subito

Cosa richiede sgcHTTP da te, e cosa no. Entrambe le risposte sono brevi.

sgcHTTP è autosufficiente

Autonomo, include il runtime sgcWebSockets Core: il server HTTP, lo stack client HTTP/TLS con cui ogni client invia le proprie richieste, e lo strato JSON che decodifica le risposte di Google Cloud. Un solo SKU, un solo installer.

Il codice sorgente completo è incluso in ogni licenza, così il server HTTP, tutti e cinque i client e il runtime sotto di loro si possono seguire passo passo nel tuo debugger invece di sparire dentro un binario.

Componente aggiuntivo richiesto per due su cinque

HTTP/2 e gRPC richiedono sgcCustomIndy

HTTP/2 negozia il protocollo h2 con ALPN durante l'handshake TLS, e la libreria Indy standard inclusa in RAD Studio non supporta ALPN. Il client HTTP/2 e il client gRPC di sgcHTTP sono costruiti su sgcCustomIndy, che è sempre incluso quando ordini sgcHTTP, e il prezzo mostrato lo copre già.

I tre client Google Cloud, Pub/Sub, Calendar e Firebase Cloud Messaging, sono HTTPS puro. Girano sul solo runtime Core e non richiedono affatto sgcCustomIndy.

COSA C'È NELLA CONFEZIONE

Tre componenti nella palette, tre client Google Cloud

Il server HTTP, il client HTTP/2 e il client gRPC sono componenti non visuali sulla pagina della palette SGC HTTP. Il server è dichiarato nell'unità sgcHTTP_Server del runtime Core incluso, i due client nell'unità sgcHTTP. Mettine uno su una form o crealo da codice, imposta le opzioni di connessione, aggancia gli eventi, poi chiama i metodi di richiesta tipizzati. I tre client Google Cloud vivono nella stessa unità come classi solo-codice, non c'è nulla da mettere su una form: creane una, imposta GoogleCloudOptions, e chiama i suoi metodi direttamente.

Server HTTP1 componente

Pubblica endpoint HTTP e file statici

TsgcHTTPServer trasforma la tua applicazione Delphi o C++ Builder in un server HTTP. Imposta Port, gestisci OnCommandGet, imposta Active a true, e ogni richiesta arriva al tuo codice con i suoi oggetti request e response, mentre OnCommandOther copre verbi come PUT e DELETE. Punta DocumentRoot a una cartella e il server restituisce da essa i file statici. HTTPCompression comprime le risposte, KeepAlive riutilizza le connessioni, SessionState con OnSessionStart e OnSessionEnd tiene traccia delle sessioni, MaxRequestBodySize limita la dimensione dei body delle richieste e HTTPUploadFiles salva su disco i file caricati. In produzione, SSL e SSLOptions abilitano TLS, Authentication e OnAuthentication proteggono i tuoi endpoint, e ThreadPool e MaxConnections controllano come scala. È lo stesso motore del server WebSocket di sgcWebSockets senza la parte WebSocket, e viene fornito con il runtime Core incluso.

TsgcHTTPServer Incluso nel runtime Core
HTTP/21 componente

Stream multiplati su un'unica connessione TLS

TsgcHTTP2Client parla HTTP/2 (RFC 9113): più richieste condividono un'unica connessione TCP come stream indipendenti, così una risposta lenta non blocca le altre dietro di essa. Gli header sono compressi con HPACK, e il protocollo h2 viene negoziato durante l'handshake TLS tramite ALPN, il motivo per cui il componente è costruito su sgcCustomIndy invece che sulla libreria Indy standard. Ogni verbo è coperto, Connect, Get, Post, Put, Patch, Delete e Options, ciascuno con una chiamata sincrona e un gemello Async. Gli eventi mostrano il ciclo di vita della connessione: OnHTTP2Connect, OnHTTP2Response, OnHTTP2ResponseFragment per i corpi a blocchi, OnHTTP2PushPromise per il server push, OnHTTP2GoAway e OnHTTP2Disconnect. HTTP2Options configura il frame di impostazioni locale, e TLSOptions e Authentication arrivano dal resto dello stack sgc HTTP.

TsgcHTTP2Client Richiede sgcCustomIndy
gRPC1 componente

RPC unari e in streaming sul client HTTP/2

TsgcGRPCClient è costruito sul client HTTP/2, quindi eredita la connessione multiplata e aggiunge sopra il formato sul filo di gRPC: messaggi Protocol Buffers con prefisso di lunghezza su stream HTTP/2. Call e CallAsync coprono le RPC unarie, ServerStreamingCall gestisce uno stream di risposte per una richiesta, e OpenClientStream/SendStreamMessage/CloseClientStream più OpenBidiStream/SendBidiMessage/CloseBidiStream coprono le RPC in streaming lato client e bidirezionale. OnGRPCResponse, OnGRPCStreamMessage e OnGRPCStreamEnd consegnano il traffico, e RetryPolicy, Interceptors e ServiceConfig aggiungono logica di retry, logica trasversale e configurazione del servizio senza toccare i punti di chiamata. Come il client HTTP/2 su cui è costruito, richiede sgcCustomIndy per ALPN.

TsgcGRPCClient Richiede sgcCustomIndy
Google Cloud3 classi

Pub/Sub, Calendar e notifiche push, HTTPS puro

Altre tre classi raggiungono i servizi Google Cloud su HTTPS puro, autenticate con un service account Google, e nessuna di loro richiede sgcCustomIndy. TsgcHTTPGoogleCloud_PubSub_Client pubblica e preleva messaggi e gestisce topic, subscription e snapshot: Publish, Pull, Acknowledge, CreateTopic, CreateSubscription e il resto della superficie REST di Pub/Sub. TsgcHTTPGoogleCloud_Calendar_Client avvolge la Google Calendar API v3: NewCalendar, NewEvent, LoadEvents e LoadCalendars, con gli eventi OnGetCalendar e OnGetCalendarEvent per la sincronizzazione. TsgcHTTPGoogleCloud_FCM_Client invia un payload di notifica push a un progetto Firebase con una sola chiamata, SendMessage. Tutte e tre sono classi solo-codice: creane una, imposta GoogleCloudOptions, chiama i metodi.

TsgcHTTPGoogleCloud_PubSub_Client TsgcHTTPGoogleCloud_Calendar_Client TsgcHTTPGoogleCloud_FCM_Client
Guarda come i pezzi si incastrano →
COME FUNZIONA

Due dipendenze, non cinque

Le cinque classi si dividono nettamente in base a cosa richiedono sotto. HTTP/2 e gRPC richiedono ALPN, il che significa sgcCustomIndy. Google Cloud non richiede altro che HTTPS e un service account, che il runtime Core incluso già fornisce.

HTTP/2 richiede ALPN, quindi richiede sgcCustomIndy

L'Application-Layer Protocol Negotiation sceglie h2 durante l'handshake TLS, e la libreria Indy standard inclusa in RAD Studio non ha supporto ALPN. TsgcHTTP2Client è costruito invece su sgcCustomIndy, la build Indy personalizzata di eSeGeCe.

gRPC è Protocol Buffers a bordo del client HTTP/2

TsgcGRPCClient non apre una propria connessione, la sua proprietà Client è un TsgcHTTP2Client. Le chiamate unarie, server-streaming, client-streaming e bidirezionali viaggiano tutte come stream HTTP/2 sotto.

Google Cloud è HTTPS più un service account

I tre client Google Cloud si autenticano con GoogleCloudOptions.JWT, il project id, l'email client e la chiave privata di un service account Google, e chiamano le API REST sullo stack HTTPS puro del runtime Core. OnAuthToken e OnAuthTokenError mostrano lo scambio del token.

Il runtime Core è nella confezione

Autonomo, include il runtime sgcWebSockets Core. Contribuisce TsgcHTTPServer e lo stack client HTTP/TLS attraverso cui chiama ognuno dei cinque client, e il suo codice sorgente completo fa parte della confezione come tutto il resto.

GUIDA RAPIDA

Server HTTP, HTTP/2 e gRPC, fianco a fianco

I due client sono dichiarati nell'unità sgcHTTP e il server in sgcHTTP_Server, e TsgcGRPCClient porta la propria connessione HTTP/2 attraverso la sua proprietà Client. Lo stesso codice compila in Delphi 7-13 e in C++ Builder.

uses
  sgcHTTP, sgcHTTP_Server;

var
  Server: TsgcHTTPServer;
  HTTP2: TsgcHTTP2Client;
  GRPC: TsgcGRPCClient;
begin
  // HTTP server: endpoints and static files
  Server := TsgcHTTPServer.Create(nil);
  Server.Port := 8080;
  Server.DocumentRoot := 'C:\www';
  Server.OnCommandGet := ServerCommandGet;
  Server.Active := True;

  // HTTP/2: multiplexed requests over one TLS connection
  HTTP2 := TsgcHTTP2Client.Create(nil);
  HTTP2.Host := 'https://api.example.com';
  HTTP2.OnHTTP2Response := HTTP2Response;
  HTTP2.Active := True;

  HTTP2.GetAsync('/v1/status');

  // gRPC: built on the HTTP/2 client, unary and streaming RPC
  GRPC := TsgcGRPCClient.Create(nil);
  GRPC.Client.Host := 'https://grpc.example.com';
  GRPC.OnGRPCResponse := GRPCResponse;

  GRPC.CallAsync('example.OrderService', 'GetOrder', RequestBytes);
end;

procedure TForm1.HTTP2Response(Sender: TObject;
  const Connection: TsgcHTTP2ConnectionClient;
  const Request: TsgcHTTP2RequestProperty;
  const Response: TsgcHTTP2ResponseProperty);
begin
  Memo1.Lines.Add(Response.DataString);
end;

procedure TForm1.GRPCResponse(Sender: TObject;
  const aResponse: TsgcGRPCResponse);
begin
  Memo1.Lines.Add(aResponse.DataString);
end;

procedure TForm1.ServerCommandGet(AContext: TIdContext;
  ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo);
begin
  if ARequestInfo.Document = '/api/status' then
  begin
    AResponseInfo.ContentType := 'application/json';
    AResponseInfo.ContentText := '{"status":"ok"}';
  end;
end;
// include: sgcHTTP.hpp, sgcHTTP_Server.hpp

// HTTP server: endpoints and static files
TsgcHTTPServer *Server = new TsgcHTTPServer(this);
Server->Port = 8080;
Server->DocumentRoot = "C:\\www";
Server->OnCommandGet = ServerCommandGet;
Server->Active = true;

// HTTP/2: multiplexed requests over one TLS connection
TsgcHTTP2Client *HTTP2 = new TsgcHTTP2Client(this);
HTTP2->Host = "https://api.example.com";
HTTP2->OnHTTP2Response = HTTP2Response;
HTTP2->Active = true;

HTTP2->GetAsync("/v1/status");

// gRPC: built on the HTTP/2 client, unary and streaming RPC
TsgcGRPCClient *GRPC = new TsgcGRPCClient(this);
GRPC->Client->Host = "https://grpc.example.com";
GRPC->OnGRPCResponse = GRPCResponse;

GRPC->CallAsync("example.OrderService", "GetOrder", RequestBytes);

void __fastcall TForm1::HTTP2Response(TObject *Sender,
    const TsgcHTTP2ConnectionClient* Connection,
    const TsgcHTTP2RequestProperty* Request,
    const TsgcHTTP2ResponseProperty* Response)
{
  Memo1->Lines->Add(Response->DataString);
}

void __fastcall TForm1::GRPCResponse(TObject *Sender,
    const TsgcGRPCResponse* aResponse)
{
  Memo1->Lines->Add(aResponse->DataString);
}

void __fastcall TForm1::ServerCommandGet(TIdContext *AContext,
    TIdHTTPRequestInfo *ARequestInfo, TIdHTTPResponseInfo *AResponseInfo)
{
  if (ARequestInfo->Document == "/api/status")
  {
    AResponseInfo->ContentType = "application/json";
    AResponseInfo->ContentText = "{\"status\":\"ok\"}";
  }
}
PIATTAFORME

Una dipendenza per due client, nessuna per tre

Il client HTTP/2 e il client gRPC si basano su sgcCustomIndy, che copre lo stesso intervallo di piattaforme di sgcWebSockets stesso. I client Google Cloud sono HTTPS puro, quindi girano ovunque giri il runtime Core.

TsgcHTTP2Client e TsgcGRPCClient Costruiti su sgcCustomIndy per ALPN
Windows Win32 Windows Win64 Linux64 macOS iOS Android
Client Google Cloud HTTPS puro, sgcCustomIndy non richiesto
Windows Win32 Windows Win64 Linux64 macOS iOS Android
Supporto IDE Un solo albero dei sorgenti, package di design-time per ogni versione
Da Delphi 7 a 13 C++ Builder
Installer di prova La versione di prova All-Access di sgcWebSockets include i componenti sgcHTTP
Un solo download, il server e tutti e cinque i client

Scarica l'installer di prova →

PREZZI

Un package autonomo

sgcHTTP viene concesso in licenza da solo, a partire da €398 per un singolo sviluppatore. Tutte le licenze includono il codice sorgente completo, 1 anno di aggiornamenti e uno sconto sul rinnovo dal 50% al 70%: il 50% se rinnovi un pacchetto, il 60% con due, il 70% con tre o più. sgcAI, sgcMQ, sgcSocial, sgcCustomIndy, sgcAuth, sgcHTTP e sgcREST contano ciascuno come un pacchetto. sgcHTTP è incluso anche nel bundle All-Access.

sgcHTTP

€398

Licenze Single, Team e Site disponibili.

  • Server HTTP con file statici, sessioni e TLS
  • Client HTTP/2 con multiplexing e HPACK
  • Client gRPC, RPC unarie e in streaming
  • Client Google Cloud Pub/Sub, Calendar e FCM
  • Runtime sgcWebSockets Core incluso
  • Da Delphi 7 a 13 e C++ Builder
  • Codice sorgente completo
  • 1 anno di aggiornamenti

HTTP/2 e gRPC richiedono il componente aggiuntivo sgcCustomIndy. È sempre incluso nel tuo ordine, e il prezzo mostrato lo copre già.

Acquista licenza Single €398
Team €648 Site €1,048

Il pagamento elenca tre voci: il diritto d'uso del runtime sgcWebSockets Core, addebitato a zero, il pacchetto sgcHTTP stesso, e il componente aggiuntivo sgcCustomIndy, sempre incluso. Tutti i dettagli sui prezzi.

3,000+Sviluppatori
20+Anni
761+Componenti
30+Integrazioni API
5Piattaforme
Garanzia soddisfatti o rimborsati di 30 giorniNon sei soddisfatto? Richiedi un rimborso completo entro 30 giorni dall'acquisto. Vedi la politica di rimborso

HTTP moderno, gRPC e Google Cloud da codice nativo

Un server HTTP, HTTP/2 multiplato, gRPC in streaming e tre client Google Cloud, con il runtime incluso e il codice sorgente completo nella confezione. Scarica l'installer di prova All-Access e prova subito tutti i componenti.

Scarica la versione di prova gratuita Vedi i prezzi
ALTRO DA ESEGECE

Altri prodotti di eSeGeCe

Abbina sgcHTTP alle nostre altre librerie di componenti per Delphi, C++ Builder e .NET.

sgcCustomIndy

La libreria Indy personalizzata su cui sono costruiti i client HTTP/2 e gRPC di sgcHTTP: ALPN, TLS 1.3 e linking statico di OpenSSL.

Scopri di più →

sgcWebSockets

La libreria completa: client e server WebSocket, HTTP/2, gRPC, componenti IoT, P2P e AI. La sua edizione Enterprise include anche gRPC.

Scopri di più →

sgcAI

Componenti AI, LLM e MCP. Un solo componente di chat raggiunge OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok e Mistral.

Scopri di più →

sgcMQ

Componenti client nativi MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka e STOMP, con il runtime Core incluso.

Scopri di più →

sgcCrypto

Cifrari simmetrici e asimmetrici, hashing e algoritmi post-quantum. Inclusa gratuitamente da sgcWebSockets Standard in su.

Scopri di più →

sgcSocial

Componenti client WhatsApp Business Cloud API e Telegram TDLib, con il runtime Core incluso.

Scopri di più →

sgcQUIC

Componenti client e server QUIC (RFC 9000) e HTTP/3 (RFC 9114) costruiti sul motore QUIC nativo di OpenSSL 3.5.

Scopri di più →

sgcWebRTC

Motore multimediale WebRTC completo: chiamate audio/video, canali dati e condivisione dello schermo. Un componente aggiuntivo per sgcWebSockets Enterprise.

Scopri di più →