Eine native Pascal-Implementierung von RFC 9113 HTTP/2 — Stream-Multiplexing, HPACK-Header-Kompression, Flow Control, Server Push und die WebSocket-über-HTTP/2-Erweiterung (RFC 8441). Dieselbe Komponente, Client oder Server, von Delphi 7 bis Delphi 13.
Kein dünner Wrapper um WinHTTP oder libcurl — eine von Grund auf neu geschriebene Implementierung, die dir Frame-Level-Kontrolle gibt.
Ein Delphi-HTTP/2-Client ist nicht mehr optional: HTTP/2 ist das Wire-Format, das das gesamte moderne Web spricht. Apple Push Notifications verlangen HTTP/2. Google-APIs handeln HTTP/2 aus. AWS, Azure und CloudFront nutzen HTTP/2 als Standard. Und die Gewinne sind real: Eine einzige TCP-/TLS-Verbindung multiplext Dutzende laufende Requests, Header-Sets werden mit HPACK komprimiert, und der Server kann Ressourcen pushen, die der Client noch gar nicht angefragt hat. sgcWebSockets liefert TsgcHTTP2Client (Client) und HTTP/2-Support im TsgcWebSocketHTTPServer (Server) — beide reines Pascal, beide auf jeder Plattform, die der Delphi-Compiler unterstützt.
Ein Delphi-HTTP/2-Server in derselben Bibliothek kann REST-APIs hosten, Events an langlebige Clients pushen und WebSocket-Upgrades über HTTP/2 (RFC 8441) akzeptieren — der Standardweg, mit dem moderne Infrastruktur WebSocket auf HTTP/2 / HTTP/3 aufsetzt.
TsgcHTTP2Client
TsgcWebSocketHTTPServer mit aktiviertem HTTP/2
RFC 9113 (HTTP/2), RFC 7541 (HPACK), RFC 8441 (WS-over-H2)
OpenSSL, SChannel, HTTP.sys — per ALPN ausgehandelt
Die vier großen Gewinne gegenüber HTTP/1.1 — und die operativen Details, die sie funktionieren lassen.
Bis zu SETTINGS_MAX_CONCURRENT_STREAMS laufende Requests über eine einzige TCP+TLS-Verbindung — kein Head-of-Line-Blocking, kein zu tunender Connection-Pool.
Statische + dynamische Header-Tabelle pro Verbindung eliminiert die Kilobyte sich wiederholender Header (Cookies, User-Agent, Accept), die HTTP/1.1-Traffic aufblähen.
Der Server kann Ressourcen, die der Client gleich brauchen wird (CSS, JS, JSON-Subressourcen), vorbeugend senden, bevor der Client sie anfragt — ein Request-Round-Trip gespart.
Gewicht und Abhängigkeitsbaum pro Stream erlauben es dir, dem Server zu sagen, dass das Index-Dokument vor dem Analytics-Blob ausgeliefert werden soll.
WINDOW_UPDATE pro Stream und pro Verbindung verhindert, dass ein langsamer Konsument den Sender ertränkt — Back-Pressure ist ins Wire-Format eingebaut.
ALPN auf TLS-Ebene handelt h2 automatisch aus — Client und Server einigen sich vor dem ersten Request auf HTTP/2, mit HTTP/1.1-Fallback, falls der Peer es nicht spricht.
RFC 8441: Tunnle eine WebSocket-Session in einem HTTP/2-Stream — läuft durch jeden HTTP/2-bewussten Loadbalancer (Envoy, nginx, ALB, GCLB).
HTTP-Trailer (gemäß RFC 7230) sind erstklassig — die Grundlage für die Status-/Message-Metadaten von gRPC.
Setze 10 parallele GETs über eine einzige Verbindung ab — HPACK und Multiplexing machen das zur Routine.
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;Im OnCommandGet-Handler rufst du PushPromise auf, um /style.css präventiv mit /index.html mitzusenden.
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 akzeptiert ausschließlich HTTP/2 — eine persistente Verbindung, Tausende Streams pro Sekunde, JWT- oder zertifikatsbasierte Auth. Siehe die Seite zu Apple Push.
Die HTTP-v1-FCM-API läuft über HTTP/2. Siehe die Google-FCM-Seite.
gRPC ist HTTP/2 mit Protobuf und Trailers. Der HTTP/2-Stack hier ist die Grundlage, auf der ein Pascal-gRPC-Client aufbaut.
Der sauberste Weg, WebSocket durch moderne Loadbalancer und CDNs auszurollen, die HTTP/2-Upstream bevorzugen.
Eine Verbindung, Hunderte laufende Requests — ideal für Crawler, Marktdaten-Ingester und Fan-Out-Worker.
Streame eine JSON-Lines- oder SSE-artige Antwort über einen einzigen HTTP/2-Stream — inklusive Back-Pressure.
Vollständige Komponentenreferenz für den HTTP/2-Client und -Server.
Eigene Seite zur Client-Komponente.
Eigene Seite zur Server-Komponente.
WebSocket über HTTP/2 (RFC 8441) und über HTTP/1.1 (RFC 6455).
Ursprüngliche Ankündigung und Design-Notizen.
Benchmark-Zahlen zu Multiplexing- und HPACK-Gewinnen.
Die h2spec-Suite gegen den Server fahren.
Praxisbeispiel HTTP/2: APNs-Benachrichtigungen.