Une implémentation Pascal native de la RFC 9113 HTTP/2 — multiplexage de flux, compression d'en-têtes HPACK, contrôle de flux, server push et l'extension WebSocket-sur-HTTP/2 (RFC 8441). Même composant, client ou serveur, de Delphi 7 à Delphi 13.
Pas un mince wrapper autour de WinHTTP ou libcurl — une implémentation faite de zéro qui vous donne le contrôle au niveau frame.
Un client HTTP/2 Delphi n'est plus optionnel : HTTP/2 est le format wire que tout le web moderne parle. Apple Push Notifications nécessite HTTP/2. Les API Google négocient HTTP/2. AWS, Azure et CloudFront utilisent HTTP/2 par défaut. Et les gains sont réels : une seule connexion TCP/TLS multiplexe des dizaines de requêtes en vol, les ensembles d'en-têtes sont compressés avec HPACK, et le serveur peut pousser des ressources que le client n'a pas encore demandées. sgcWebSockets livre TsgcHTTP2Client (client) et le support HTTP/2 dans TsgcWebSocketHTTPServer (serveur) — les deux en Pascal pur, les deux tournant sur chaque plateforme que le compilateur Delphi cible.
Un serveur HTTP/2 Delphi dans la même bibliothèque peut héberger des API REST, pousser des événements vers des clients longue durée et accepter des upgrades WebSocket sur HTTP/2 (RFC 8441) — la façon standard dont l'infrastructure moderne empile WebSocket au-dessus de HTTP/2 / HTTP/3.
TsgcHTTP2Client
TsgcWebSocketHTTPServer avec HTTP/2 activé
RFC 9113 (HTTP/2), RFC 7541 (HPACK), RFC 8441 (WS-sur-H2)
OpenSSL, SChannel, HTTP.sys — négocié par ALPN
Les quatre gros gains par rapport à HTTP/1.1 — et les détails opérationnels qui les font marcher.
Jusqu'à SETTINGS_MAX_CONCURRENT_STREAMS requêtes en vol sur une seule connexion TCP+TLS — pas de blocage en tête de file, pas de pool de connexions à tuner.
La table d'en-têtes statique + dynamique par connexion élimine les kilo-octets d'en-têtes répétés (cookies, user-agent, accept) qui gonflent le trafic HTTP/1.1.
Le serveur peut envoyer préventivement des ressources dont le client aura besoin (CSS, JS, sous-ressources JSON) avant que le client ne les demande — économisez un aller-retour de requête.
Le poids par flux et l'arbre de dépendances vous permettent de dire au serveur de livrer le document index avant le blob d'analytics.
WINDOW_UPDATE par flux et par connexion empêche un consommateur lent de noyer l'émetteur — back-pressure intégré dans le format wire.
ALPN au niveau TLS négocie h2 automatiquement — le client et le serveur s'accordent sur HTTP/2 avant la première requête, avec fallback HTTP/1.1 si le pair ne le parle pas.
RFC 8441 : tunnellisez une session WebSocket dans un flux HTTP/2 — passe à travers chaque load balancer HTTP/2-aware (Envoy, nginx, ALB, GCLB).
Les trailers HTTP (selon la RFC 7230) sont de premier ordre — la fondation des métadonnées status / message de gRPC.
Tirez 10 GET concurrents sur une seule connexion — HPACK et le multiplexage rendent cela routinier.
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;À l'intérieur d'un handler OnCommandGet, appelez PushPromise pour envoyer préventivement /style.css à côté de /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 n'accepte que HTTP/2 — une connexion persistante, des milliers de flux par seconde, auth JWT ou par certificat. Voir la page Apple Push.
L'API FCM HTTP v1 tourne sur HTTP/2. Voir la page Google FCM.
gRPC est HTTP/2 avec protobuf et trailers. La pile HTTP/2 ici est la fondation sur laquelle un client gRPC Pascal construit.
La façon la plus propre de déployer WebSocket à travers les load balancers et CDN modernes qui préfèrent HTTP/2 en amont.
Une connexion, des centaines de requêtes en vol — idéal pour les crawlers, ingesteurs de données de marché et workers de fan-out.
Streamez une réponse JSON-lines ou style SSE sur un seul flux HTTP/2 — back-pressure inclus.
Référence complète du composant pour le client et le serveur HTTP/2.
Page dédiée au composant client.
Page dédiée au composant serveur.
WebSocket sur HTTP/2 (RFC 8441) et sur HTTP/1.1 (RFC 6455).
Annonce originale et notes de conception.
Chiffres de benchmark pour les gains de multiplexage et HPACK.
Faire tourner la suite h2spec contre le serveur.
Exemple HTTP/2 pratique : notifications APNs.