Un'implementazione Pascal nativa di RFC 9113 HTTP/2 — multiplexing degli stream, compressione header HPACK, controllo di flusso, server push e l'estensione WebSocket-su-HTTP/2 (RFC 8441). Stesso componente, client o server, da Delphi 7 a Delphi 13.
Non un sottile wrapper attorno a WinHTTP o libcurl — un'implementazione from-scratch che ti dà il controllo a livello di frame.
Un client HTTP/2 Delphi non è più opzionale: HTTP/2 è il formato di rete che parla l'intero web moderno. Le Apple Push Notification richiedono HTTP/2. Le API Google negoziano HTTP/2. AWS, Azure e CloudFront usano HTTP/2 come default. E i benefici sono reali: una singola connessione TCP/TLS multiplexa decine di richieste in volo, gli header set sono compressi con HPACK e il server può fare push di risorse che il client non ha ancora chiesto. sgcWebSockets distribuisce TsgcHTTP2Client (client) e il supporto HTTP/2 dentro TsgcWebSocketHTTPServer (server) — entrambi puro Pascal, entrambi in esecuzione su ogni piattaforma che il compilatore Delphi targetizza.
Un server HTTP/2 Delphi nella stessa libreria può ospitare API REST, fare push di eventi a client di lunga durata e accettare upgrade WebSocket su HTTP/2 (RFC 8441) — il modo standard in cui l'infrastruttura moderna sovrappone WebSocket a HTTP/2 / HTTP/3.
TsgcHTTP2Client
TsgcWebSocketHTTPServer con HTTP/2 abilitato
RFC 9113 (HTTP/2), RFC 7541 (HPACK), RFC 8441 (WS-su-H2)
OpenSSL, SChannel, HTTP.sys — negoziato via ALPN
I quattro grandi vantaggi rispetto a HTTP/1.1 — e i dettagli operativi che li fanno funzionare.
Fino a SETTINGS_MAX_CONCURRENT_STREAMS richieste in volo su una singola connessione TCP+TLS — nessun head-of-line blocking, nessun pool di connessioni da tarare.
Tabella header statica + dinamica per connessione che elimina i kilobyte di header ripetuti (cookie, user-agent, accept) che gonfiano il traffico HTTP/1.1.
Il server può inviare in anticipo risorse di cui il client avrà bisogno (CSS, JS, sotto-risorse JSON) prima che il client le richieda — risparmia un round-trip.
Peso per stream e albero delle dipendenze ti permettono di dire al server di spedire il documento index prima del blob di analytics.
WINDOW_UPDATE per stream e per connessione impedisce a un consumer lento di affogare il mittente — back-pressure integrato nel formato di rete.
L'ALPN a livello TLS negozia h2 automaticamente — client e server si accordano su HTTP/2 prima della prima richiesta, con fallback a HTTP/1.1 se il peer non lo parla.
RFC 8441: tunnelizza una sessione WebSocket dentro un singolo stream HTTP/2 — passa attraverso ogni load balancer HTTP/2-aware (Envoy, nginx, ALB, GCLB).
I trailer HTTP (per RFC 7230) sono di prima classe — la base per i metadati di status / messaggio di gRPC.
Lancia 10 GET concorrenti su una singola connessione — HPACK e multiplexing rendono questo ordinario.
uses
sgcHTTP2_Client, sgcHTTP_Classes;
var
HTTP2: TsgcHTTP2Client;
i: Integer;
begin
HTTP2 := TsgcHTTP2Client.Create(nil);
HTTP2.Host := 'api.example.com';
HTTP2.Port := 443;
HTTP2.TLS := True;
HTTP2.TLSOptions.ALPNProtocols.Add('h2');
HTTP2.OnResponse := DoResponse;
HTTP2.Connect;
// 10 concurrent GETs on ONE connection, ONE TLS handshake
for i := 1 to 10 do
HTTP2.Get(Format('/items/%d', [i]));
end;
procedure TForm1.DoResponse(Sender: TObject;
const aStreamId: Cardinal;
aHeaders: TsgcHTTP2Headers;
aData: TBytes);
begin
Memo1.Lines.Add(Format('stream %d status %s bytes %d',
[aStreamId, aHeaders.Status, Length(aData)]));
end;Dentro un handler OnCommandGet, chiama PushPromise per inviare in anticipo /style.css insieme a /index.html.
uses
sgcWebSocket, sgcHTTP_Classes;
procedure TForm1.WSServerCommandGet(Sender: TObject;
aContext: TsgcWSConnection;
ARequestInfo: TsgcWSRequestInfo;
AResponseInfo: TsgcWSResponseInfo);
begin
if ARequestInfo.URI = '/index.html' then
begin
// Push the CSS so the browser doesn’t round-trip for it
AResponseInfo.PushPromise('/style.css');
AResponseInfo.PushPromise('/app.js');
AResponseInfo.ContentType := 'text/html; charset=utf-8';
AResponseInfo.ContentText :=
'<!doctype html><link rel="stylesheet" href="/style.css">' +
'<script src="/app.js" defer></script>' +
'<h1>HTTP/2 from Delphi</h1>';
end;
end;APNs accetta solo HTTP/2 — una connessione persistente, migliaia di stream al secondo, autenticazione JWT o basata su certificato. Vedi la pagina Apple Push.
L'API FCM HTTP v1 gira su HTTP/2. Vedi la pagina Google FCM.
gRPC è HTTP/2 con protobuf e trailer. Lo stack HTTP/2 qui presente è la base su cui un client gRPC Pascal si costruisce.
Il modo più pulito di distribuire WebSocket attraverso load balancer e CDN moderne che preferiscono HTTP/2 verso l'upstream.
Una connessione, centinaia di richieste in volo — ideale per crawler, ingesti di market-data e worker di fan-out.
Fai lo stream di una response JSON-lines o in stile SSE su un singolo stream HTTP/2 — back-pressure incluso.
Riferimento completo dei componenti client e server HTTP/2.
Pagina dedicata al componente client.
Pagina dedicata al componente server.
WebSocket su HTTP/2 (RFC 8441) e su HTTP/1.1 (RFC 6455).
Annuncio originale e note di design.
Numeri di benchmark per i guadagni di multiplexing e HPACK.
Eseguire la suite h2spec contro il server.
Esempio pratico di HTTP/2: notifiche APNs.