sgcWebSockets in cinque minuti

Hai installato la libreria e la palette è visibile. Questa pagina ti porta da lì a un server che accetta una connessione e a un client che invia un messaggio e legge la risposta. Tutto ciò che trovi qui sotto proviene da una demo inclusa nel download, quindi puoi aprire il progetto invece di digitare il codice.

Da Delphi 7 a RAD Studio 13
Windows, Linux, macOS, iOS, Android
Client dalla Standard, server dalla Professional

Cosa serve per il primo esempio

Due componenti non visuali, una unit nella clausola uses e un'unit aggiuntiva per i tipi dei parametri dei gestori di evento.

Componente client

TsgcWebSocketClient, dichiarato in sgcWebSocket.pas e registrato nella pagina SGC WebSockets della palette. Imposta Host, Port e poi Active.

Componente server

TsgcWebSocketServer, stessa unit, stessa pagina della palette. Imposta Port e poi Active. Resta in ascolto, esegue l'upgrade dell'handshake e genera OnConnect.

La seconda unit

Ogni evento ti passa un TsgcWSConnection, che si trova in sgcWebSocket_Classes.pas. Le demo scrivono uses sgcWebSocket, sgcWebSocket_Classes; e dovresti farlo anche tu.

Piattaforme

Nessuna delle due unit contiene una guardia di piattaforma ed entrambi i componenti sono registrati con ComponentPlatforms(0), quindi i target VCL, FMX, console e servizio compilano tutti. Nel pacchetto è inclusa una demo client FireMonkey.

Requisiti ed edizioni

La colonna dell'edizione indica il define che regola davvero il codice, con la riga in cui si trova in Source/sgcVer.inc.

Cosa Valore
IDE Da Delphi 7 a RAD Studio 13 e da C++Builder 2007 a 13. Un gruppo di package per ogni versione dell'IDE in Packages\.
Clausola uses sgcWebSocket per i componenti, sgcWebSocket_Classes per TsgcWSConnection.
Edizione client TsgcWebSocketClient è racchiuso in {$IFDEF SGC_WS_CLIENT}. SGC_WS_CLIENT è definito alla riga 697, dentro il blocco {$IFDEF SGC_EDT_STD} che va dalla riga 675 alla riga 724. Quindi Standard e superiori.
Edizione server TsgcWebSocketServer è racchiuso direttamente in {$IFDEF SGC_EDT_PRO}, e la sua registrazione nella palette in sgcWebSocket_Reg.pas si trova nella stessa guardia. Il blocco di funzionalità Professional va dalla riga 727 alla riga 758. Quindi Professional e superiori. Una licenza Standard ti dà il client, non il server.
Pagina della palette Registrata sotto {$IFDEF SGC_PACK_WEBSOCKETS}, definito alla riga 852.
Piattaforme Nessuna guardia di piattaforma a livello di unit in sgcWebSocket.pas, sgcWebSocket_Client.pas o sgcWebSocket_Server.pas. Windows include condizionalmente la unit Windows, nient'altro.

Non sei sicuro di quale edizione stai usando? Apri Source/sgcVer.inc e guarda le prime cinque righe. I define SGC_EDT_* sono cumulativi: All-Access li definisce tutti e Standard solo i primi due.

Installa e verifica la palette

Cinque passaggi dallo zip a un componente che puoi trascinare. Compila il package di runtime prima di installare quello di design-time, perché il secondo fa riferimento al primo.

1. Decomprimi

Decomprimi il download in una cartella a tua scelta. Nel resto di questa pagina la chiamiamo {$DIR}. Le cartelle Source\, Packages\, Demos\ e lib*\ si trovano tutte al suo interno.

2. Library path

Tools, Options, Library. Aggiungi {$DIR}\source e la cartella corrispondente al tuo IDE, per esempio {$DIR}\libD13\$(Platform) su RAD Studio 13 oppure {$DIR}\libD12\$(Platform) sulla 12.

3. Compila i package

Apri {$DIR}\Packages\sgcWebSocketsD13.groupproj per la versione del tuo IDE. Compila prima sgcWebSocketsD13.dpk, poi installa dclsgcWebSocketsD13.dpk. C++Builder usa i file .cbproj presenti nella stessa cartella.

4. Controlla la palette

Compare una nuova pagina chiamata SGC WebSockets. In una build Standard contiene TsgcWebSocketClient. Dalla Professional in su contiene anche TsgcWebSocketServer, TsgcWebSocketHTTPServer, TsgcWebSocketProxyServer e TsgcWebSocketLoadBalancerServer.

5. Apri una demo

Prima di scrivere qualsiasi cosa, apri {$DIR}\Demos\01.WebSocket_Quick_Start\01.Server_and_Client_Chat. È la coppia funzionante più piccola della libreria e il codice qui sotto proviene da lì.

Un server e un client, in circa venti righe

Avvia il server, avvia il client, invia una stringa. La scheda del server resta in ascolto su una porta; la scheda del client si connette e scrive un messaggio.

uServerChat.pas
uses
  Classes, SysUtils,
  // sgc
  sgcWebSocket, sgcWebSocket_Classes;

procedure TfrmServerChat.btnStartClick(Sender: TObject);
begin
  WSServer.Port := 5418;
  WSServer.Active := True;
  memoLog.Lines.Add('#started');
end;

procedure TfrmServerChat.WSServerConnect(Connection: TsgcWSConnection);
begin
  memoLog.Lines.Add('Connected: ' + Connection.IP);
end;

procedure TfrmServerChat.WSServerDisconnect(Connection: TsgcWSConnection;
  Code: Integer);
begin
  memoLog.Lines.Add('Disconnected (' + IntToStr(Code) + '): ' + Connection.IP);
end;

procedure TfrmServerChat.WSServerMessage(Connection: TsgcWSConnection;
  const Text: string);
begin
  memoLog.Lines.Add(Text);
  // send it straight back, so the client has something to read
  Connection.WriteData('echo: ' + Text);
end;

Trascina TsgcWebSocketServer sul form, chiamalo WSServer e lascia che l'IDE generi i quattro gestori dall'Object Inspector. Sia Connection.IP sia Connection.WriteData provengono da TsgcWSConnection, ed è per questo che sgcWebSocket_Classes è nella clausola uses.

uClientChat.pas
uses
  Classes, SysUtils,
  // sgc
  sgcWebSocket, sgcWebSocket_Classes;

procedure TfrmClientChat.btnStartClick(Sender: TObject);
begin
  WSClient.Host := 'localhost';
  WSClient.Port := 5418;
  WSClient.TLS := False;
  WSClient.Active := True;
end;

procedure TfrmClientChat.btnSendClick(Sender: TObject);
begin
  if WSClient.Active then
    WSClient.WriteData('Hello from Delphi')
  else
    raise Exception.Create('Not connected');
end;

procedure TfrmClientChat.WSClientConnect(Connection: TsgcWSConnection);
begin
  memoLog.Lines.Add('#connected');
end;

procedure TfrmClientChat.WSClientMessage(Connection: TsgcWSConnection;
  const Text: string);
begin
  memoLog.Lines.Add(Text);
end;

Esegui prima il progetto server, poi questo. Nel log del client compare #connected e echo: Hello from Delphi torna in OnMessage. Questo scambio completo è l'intera guida rapida.

uConsole.pas
program WSConsoleClient;

{$APPTYPE CONSOLE}

uses
  Classes, SysUtils,
  // sgc
  sgcWebSocket, sgcWebSocket_Classes;

type
  TChatHandler = class
    procedure DoConnect(Connection: TsgcWSConnection);
    procedure DoMessage(Connection: TsgcWSConnection; const Text: string);
  end;

procedure TChatHandler.DoConnect(Connection: TsgcWSConnection);
begin
  Writeln('#connected');
end;

procedure TChatHandler.DoMessage(Connection: TsgcWSConnection;
  const Text: string);
begin
  Writeln('Server says: ', Text);
end;

var
  oClient: TsgcWebSocketClient;
  oHandler: TChatHandler;
begin
  oHandler := TChatHandler.Create;
  oClient := TsgcWebSocketClient.Create(nil);
  try
    oClient.Host := 'localhost';
    oClient.Port := 5418;
    oClient.WatchDog.Enabled := True;   // reconnect on its own

    // assign the handlers BEFORE Active, or the first
    // OnConnect can fire with nothing attached
    oClient.OnConnect := oHandler.DoConnect;
    oClient.OnMessage := oHandler.DoMessage;

    oClient.Active := True;
    oClient.WriteData('Hello from Delphi');
    Readln;
  finally
    oClient.Free;
    oHandler.Free;
  end;
end.

Il client esegue un proprio thread, quindi un programma console deve mantenere vivo il thread principale. È a questo che serve Readln.

Le schede server e client sono la demo inclusa Demos\01.WebSocket_Quick_Start\01.Server_and_Client_Chat, senza il codice di supporto per checkbox e caselle di testo. La terza scheda contiene le stesse chiamate scritte su componenti creati a runtime invece che trascinati su un form.

Verifica lo scambio completo

Quattro eventi ti dicono tutto sulla prima esecuzione, e conviene collegarli tutti e quattro prima di andare oltre.

Active

Sul server, Active := True riesce oppure solleva un'eccezione. Se la porta è occupata lo scopri qui, non tre passaggi dopo.

OnConnect

procedure(Connection: TsgcWSConnection). Viene generato su entrambi i lati. Sul server, Connection.IP ti dice chi è arrivato; sul client è la prova che l'handshake è stato aggiornato.

OnMessage

procedure(Connection: TsgcWSConnection; const Text: string). L'eco che torna sul client dimostra lo scambio completo da un capo all'altro.

OnError e OnException

procedure(Connection: TsgcWSConnection; const Error: string) e procedure(Connection: TsgcWSConnection; E: Exception). Collega entrambi. Senza di essi un errore è silenzioso e sembra che non sia successo nulla.

Cosa va storto di solito la prima volta

Quasi tutti i problemi della prima esecuzione sono uno di questi sei.

TsgcWebSocketServer non è nella palette

La classe server viene compilata solo quando è definito SGC_EDT_PRO, alla riga 130 di sgcWebSocket.pas, ed è registrata solo all'interno della stessa guardia. In una build Standard il client c'è e il server no. È una questione di licenza, non di installazione danneggiata.

Identificatore non dichiarato TsgcWSConnection

I componenti si trovano in sgcWebSocket, l'oggetto di connessione in sgcWebSocket_Classes. Aggiungi la seconda unit alla clausola uses. Ogni demo inclusa le ha entrambe.

Il client si connette e poi cade

Imposta WatchDog.Enabled := True in modo che una connessione caduta si riconnetta da sola, e gestisci OnError e OnException. Una disconnessione silenziosa senza gestore sembra che non sia successo nulla.

Al server non arriva nulla

Verifica che il client sia davvero attivo prima di scrivere. WriteData su un client inattivo non fa nulla di utile, ed è per questo che la demo controlla if WSClient.Active then prima di inviare.

Porta già in uso

Un'altra istanza del server, o un altro programma, occupa ancora la porta. Fermala, oppure sposta il server su una porta libera. Le porte predefinite delle demo sono 5416 e 5418.

TLS non funziona su Linux o dispositivi mobili

Una connessione wss:// richiede un back end TLS funzionante. Sceglilo tramite TLSOptions.IOHandler: OpenSSL ovunque, SChannel su Windows senza DLL da distribuire, oppure i gestori nativi Apple e Android nell'edizione Enterprise.

Dove si va dopo il primo messaggio

La coppia di chat è la base. Queste sono le quattro direzioni che il lavoro prende di solito, e tutte e quattro sono nella stessa libreria.

Parla un vero protocollo

Lo stesso client supporta i componenti dei sotto-protocolli MQTT, AMQP, STOMP, Kafka e WAMP. Trascinane uno, punta la sua proprietà Client al tuo TsgcWebSocketClient e sei su un broker.

Guida rapida di sgcMQ e la panoramica dei protocolli

Servi HTTP oltre ai WebSocket

TsgcWebSocketHTTPServer risponde alle normali richieste HTTP e agli upgrade WebSocket sulla stessa porta, che è ciò che serve quando il browser deve scaricare una pagina prima di aprire un socket.

Componenti HTTP

Scala oltre un processo

L'edizione Enterprise aggiunge il clustering, un server bilanciatore di carico e un server proxy, così un singolo endpoint logico può stare davanti a più processi server.

Riferimento del cluster e riferimento del bilanciatore di carico

Rendilo robusto prima del rilascio

Rate limiting, circuit breaker, gestore di chiavi API e un componente firewall si collegano tutti al server che hai già.

Rate limiter, circuit breaker e firewall

Riferimento, demo e documentazione

Le pagine di riferimento documentano ogni proprietà ed evento. I progetti demo sono nel tuo download, in Demos\01.WebSocket_Quick_Start.

Riferimento, client WebSocket Ogni proprietà, metodo ed evento di TsgcWebSocketClient.
Riferimento, server WebSocket Binding, autenticazione, broadcast e gestione delle connessioni in TsgcWebSocketServer.
Guida online, TsgcWebSocketClient Il riferimento generato dei componenti, sempre allineato alla versione corrente.
Quale edizione mi serve Funzionalità per funzionalità, cosa attivano Standard, Professional, Enterprise e All-Access.
Scarica la versione di prova Lo stesso installer della versione di produzione, con limite di tempo, uno per ogni versione dell'IDE.
Manuale utente (PDF) Il manuale completo che copre ogni componente della libreria.

Letture correlate: cosa sono davvero i WebSocket, gli eventi di connessione e watchdog del client e come proteggere un server WebSocket. Ogni prodotto ha la propria guida rapida, elencata nella pagina per iniziare.

Domande sulla guida rapida di sgcWebSockets

sgcWebSocket ti dà TsgcWebSocketClient e TsgcWebSocketServer. Aggiungi anche sgcWebSocket_Classes, perché ogni evento ti passa un TsgcWSConnection e quel tipo è dichiarato lì. Le demo incluse scrivono uses sgcWebSocket, sgcWebSocket_Classes; e la demo del server aggiunge sgcWebSocket_Server.
La classe server è compilata dentro {$IFDEF SGC_EDT_PRO}, e la sua registrazione nella palette in sgcWebSocket_Reg.pas si trova nella stessa guardia. SGC_EDT_PRO attiva il blocco di funzionalità Professional, righe da 727 a 758 di sgcVer.inc. Una build Standard compila solo il client. Il define del client, SGC_WS_CLIENT, è alla riga 697 dentro il blocco Standard, righe da 675 a 724.
Provengono da sgcWebSocket_Classes.pas. OnConnect è procedure(Connection: TsgcWSConnection). OnDisconnect è procedure(Connection: TsgcWSConnection; Code: Integer). OnMessage è procedure(Connection: TsgcWSConnection; const Text: string). OnError è procedure(Connection: TsgcWSConnection; const Error: string). OnException è procedure(Connection: TsgcWSConnection; E: Exception). Lascia che sia l'IDE a generarli invece di digitarli, perché un parametro in più o in meno è l'errore di compilazione più comune in un primo progetto.
Sì. sgcWebSocket.pas, sgcWebSocket_Client.pas e sgcWebSocket_Server.pas non contengono guardie di piattaforma a livello di unit ed entrambi i componenti sono registrati con ComponentPlatforms(0), quindi l'IDE non li limita a un target. Una demo client e server FireMonkey è inclusa in Demos\01.WebSocket_Quick_Start\07.Firemonkey_Server_and_Client. L'unico componente WebSocket della libreria limitato a una piattaforma è TsgcWebSocketClient_WinHTTP, che è Win32 e Win64.
Imposta TLS := True sul client e punta Port alla porta TLS. Poi scegli un back end TLS con TLSOptions.IOHandler. OpenSSL funziona ovunque e su Windows richiede libcrypto-3.dll e libssl-3.dll accanto all'eseguibile. SChannel è solo per Windows e non richiede nulla di aggiuntivo. I gestori nativi Apple e Android sono funzionalità Enterprise.
Sì, ed è esattamente ciò che fa la terza scheda qui sopra. Assegna i gestori di evento prima di impostare Active := True, altrimenti il primo OnConnect può essere generato prima che il tuo gestore sia collegato. In un'applicazione console ricorda che il client esegue un proprio thread, quindi il thread principale deve restare vivo, ed è per questo che l'esempio termina con Readln.
Riconnette un client che è caduto, a un intervallo che scegli tu. Attivalo per qualsiasi applicazione a lunga esecuzione, perché un problema di rete che chiude il socket altrimenti lascerebbe la tua applicazione disconnessa in silenzio. Imposta WatchDog.Enabled := True e, se il valore predefinito è troppo aggressivo, WatchDog.Interval e WatchDog.Attempts.
Nel tuo download, in Demos\. La coppia usata in questa pagina è 01.WebSocket_Quick_Start\01.Server_and_Client_Chat. Vale la pena aprire presto anche 06.Authentication per un server che verifica le credenziali, 07.Firemonkey_Server_and_Client per un client multipiattaforma e 12.Groups per fare broadcast a un sottoinsieme di connessioni.
La scelta più conveniente: All-AccessTutti i prodotti eSeGeCe, con Supporto Premium incluso, a partire da €1,059/anno.
Vedi i prezzi All-Access

Pronto a costruire?

Scarica la versione di prova ed esegui la demo della chat prima di scrivere una riga di codice tua.