Ich beschäftige mich grade mit dem Thema Client-Server Anwendung mit den Komponenten (IdTCPServer, IdTCPClient) aus der
Indy Sammlung von Delphi 2007 Prof.
Ich habe einen Server und einen Client erstellt, am Server können sich ein oder mehre Clients "anmelden" Die Clients können
auch einfache Text nachrichten Verschicken, soweit kein Problem.
Server:
Delphi-Quellcode:
unit uSrvMain;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, IdBaseComponent, IdComponent, IdCustomTCPServer, IdTCPServer,
StdCtrls, IdContext, DateUtils, Buttons;
type
tClient =
record
Host :
String;
Port : Integer;
end;
type
TForm1 =
class(TForm)
Memo1: TMemo;
edtCommand: TEdit;
Label1: TLabel;
btnSend: TButton;
IdTCPServer: TIdTCPServer;
ltbClients: TListBox;
Label2: TLabel;
ComboBox1: TComboBox;
Label3: TLabel;
procedure IdTCPServerConnect(AContext: TIdContext);
procedure IdTCPServerDisconnect(AContext: TIdContext);
procedure IdTCPServerExecute(AContext: TIdContext);
procedure FormCreate(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
//init
IdTCPServer.Active := False;
IdTCPServer.Bindings.Clear;
//Einstellungen
IdTCPServer.DefaultPort := 666;
try
IdTCPServer.Active := True;
except
Raise;
end;
Caption := '
Server - Online';
end;
procedure TForm1.IdTCPServerConnect(AContext: TIdContext);
begin
Memo1.Lines.Add('
Connect: '+AContext.Binding.PeerIP);
end;
procedure TForm1.IdTCPServerDisconnect(AContext: TIdContext);
begin
Memo1.Lines.Add('
Disconnect: '+AContext.Binding.PeerIP);
end;
procedure TForm1.IdTCPServerExecute(AContext: TIdContext);
begin
Memo1.Lines.Add('
Message: '+AContext.Connection.IOHandler.ReadLn);
end;
end.
Client:
Delphi-Quellcode:
unit uClMain;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient, StdCtrls;
type
TForm2 =
class(TForm)
btnConnect: TButton;
btnDisconnect: TButton;
IdTCPClient: TIdTCPClient;
Label1: TLabel;
edtCommand: TEdit;
btnSend: TButton;
Memo1: TMemo;
Label2: TLabel;
procedure FormCreate(Sender: TObject);
procedure btnConnectClick(Sender: TObject);
procedure btnDisconnectClick(Sender: TObject);
procedure btnSendClick(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
Form2: TForm2;
implementation
{$R *.dfm}
procedure TForm2.btnConnectClick(Sender: TObject);
begin
IdTCPClient.Host := '
localhost';
IdTCPClient.Port := 666;
IdTCPClient.ConnectTimeout := 5000;
try
IdTCPClient.Connect;
Caption := '
Client - Online!';
except
Raise;
end;
end;
procedure TForm2.btnDisconnectClick(Sender: TObject);
begin
if IdTCPClient.Connected
then IdTCPClient.Disconnect;
end;
procedure TForm2.btnSendClick(Sender: TObject);
begin
if IdTCPClient.Connected
then begin
IdTCPClient.IOHandler.WriteLn(edtCommand.Text);
end;
{if}
end;
procedure TForm2.FormCreate(Sender: TObject);
begin
Caption := '
Client - Offline';
end;
end.
Jetzt zu den Grundsätzlichen Fragen, ich habe schon das Forum durchstöbert aber irgendwie bin ich noch nicht auf die richtigen
Einträge (Tutorial) gestoßen bzw. ich kapier das irgendwie noch nicht so ganz alles.
Was soll das Ganze, der Server soll wissen welche Clients Angemeldet sind um ggf. ohne Aufforderung des Clients Nachrichten
an einen oder mehre Clients zuschicken, dazu muß er wissen welcher Client wie verbunden ist. Ich habe irgendwelche Ansätze
gefunden die auf "TIdContext" basieren so ganz verstehen tu ich das noch nicht.
Frage 1: Die Verwaltung von mehren Clients an einem Server.
Das nächste Thema ist die Kommunikation zwischen Client und Server, auch zu dem Thema habe ich einiges gefunden. Das man sich
ein "Protokoll" ausdenken sollte nach welchem sich die Anwendungen "unterhalten". Was ja bei einer einfachen Anwendung wie z.B.
einem Chat sicherlich nicht das Problem sein sollte. Da ich jedoch plane dem Server eine Verbindung zu einer
mySQL Datenbank
zuverpassen meine Frage macht es da noch sinn alles per "String" zu regeln.
Man könnte vom Client den Befehl schicken "Zeige mir alle Kunden" darauf hin, erstellt der Server eine
SQL Abfrage und schickt
dann ja was, einen riesigen zusammenhängenden String zurück, den der Client mühselig wieder in ein Array umsetzten muß um diesen
anzeigen zu können.
Oder kann man irgendwie ein Object bzw. Record übertragen, was macht an der Stelle sinn. Ich hatte irgendwo gelesen man solle
keine Records schicken. Ich frage mich nur was mache ich wenn ich eine Tabelle mit z.B. 10 Spalten und 5000 Zeilen schicken
will die der Client darstellen soll. Das kann man doch wohl kaum alles in einem String machen oder etwas doch.
Was ich mir vorstelle ist eine flexible art der Kommunikation mit einem Protokoll, wo am Anfang jeder Nachricht zum Server
erst mal ein paar Informationen wie z.b. Identität des Clients, der Befehl, evtl. Parameter und falls nötig Daten gesendet werden.
Message vom Client zum Server:
Zitat:
ID: Client_1
CMD: Get_Customer
PARAM: Name
Data:
Daran weiß der Server er muß die Liste der Kunden nach "Name" sortieren und das Ergebnis an den Client schicken, worum es mir
geht ist eine flexible Kommunikation. Sprich der Server empfängt die Nachricht und entscheidet anhand des Befehls (Protokoll)
was zu tun ist, muß jedoch nicht zwischen zig. möglichkeiten der Interpretation der Nachricht welchseln.
Frage 2: Kommunikation zwischen Clients und Server.
Anhand meiner bisherigen Versuche weiß ich zwar das z.B. OnExecute auf der Serverseite für die Auswertung der Nachrichten der
Clients ist, aber wie man da jetzt ansetzt ein Protokoll zu etablieren welches auf Datenstrukturen und nicht auf "simplen" Strings
besteht weiß ich nicht. Und wie ich eine Liste der zur Zeit angemeldenten Clients bekomme und ich dann Nachrichten an diese
Clients geschickt bekomme.
Ich bin über jeden Tipp und vorallem Beispiele dankbar oder wenn jemand entsprechende Tutoriale kennt.
Ansonsten noch einen schönen Tag.
mfg
TUX