1. Delphi e soquete
A rede de computadores é composta por uma série de protocolos de comunicação de rede, cujos protocolos principais são os protocolos TCP/ip e UDP na camada de transporte. O TCP é orientado à conexão e ambas as partes em comunicação mantêm um caminho, assim como a linha telefônica atual. Se você usar o telnet para efetuar login no BBS, o protocolo TCP será usado sem conexão e as partes em comunicação não manterão cada uma delas. status de outro É usado quando o navegador acessa a Internet. O protocolo HTTP é baseado no protocolo UDP. Os protocolos TCP e UDP são muito complexos, especialmente o protocolo TCP. Para garantir a exatidão e a eficácia da transmissão da rede, uma série de processos complexos de correção e classificação de erros devem ser executados.
Socket é uma especificação de soquete baseada em protocolos da camada de transporte (principalmente TCP e UDP). Foi originalmente proposta pela Universidade da Califórnia, Berkeley. Ela define uma especificação para comunicação entre dois computadores (também uma especificação de programação). um "canal", então as duas extremidades deste "canal" são dois soquetes. Os soquetes protegem as diferenças entre o software de comunicação subjacente e os sistemas operacionais específicos, tornando possível a comunicação entre quaisquer dois computadores que tenham instalado o software do protocolo TCP e implementado a especificação do soquete.
A especificação Windows Socket da Microsoft (abreviadamente Winsock) estende a especificação de soquete Berkeley. Usando métodos Socket padrão, você pode se comunicar com Sockets em qualquer plataforma, você pode implementá-lo de forma mais eficaz em plataformas Windows. No Delphi, o Socket subjacente também deve ser o Windows Socket. O Socket reduz a dificuldade de escrever software de comunicação entre computadores, mas em geral ainda é bastante complicado (isso será discutido em detalhes mais adiante); o InPRise encapsula efetivamente o Windows Socket no Delphi, permitindo aos usuários escrever facilmente programas de comunicação de rede. Abaixo explicamos com exemplos como usar Socket para escrever programas de comunicação em Delphi.
2. Use Delphi para escrever um programa de comunicação Socket.
A seguir está um programa de comunicação Socket simples, no qual o cliente e o servidor são o mesmo programa. Quando o cliente (servidor) insere um trecho de texto no memo1 e pressiona Enter, o texto pode ser exibido no servidor (cliente) em. memo2, o inverso também é verdadeiro. As etapas específicas são as seguintes:
1. Crie um novo formulário e nomeie-o arbitrariamente. Você também pode configurá-lo como chatForm; coloque um MainMenu (na coluna Padrão) e crie os itens de menu ListenItem, ConnectItem, Disconnect e Exit; adicione-os ao chatForm , onde o nome de TClientSocket é definido como ClientSocket, Defina a porta como 1025, o ativo padrão é falso; defina o nome de TServerSocket como ServerSocket, defina a porta como 1025, o ativo padrão é falso e deixe os outros inalterados e coloque dois memorandos, um chamado memo1 e o outro; other Para memo2, a cor do memo2 é definida como cinza porque é usada principalmente para exibir a entrada da outra parte. Abaixo explicamos o motivo ao escrever o código.
2. Clique duas vezes em ItemItem. Escreva o seguinte código:
procedimento TChatForm.ListenItemClick(Remetente: TObject);
começar
ListenItem.Checked := não ListenItem.Checked;
se ListenItem.Checked então
começar
ClientSocket.Active := Falso;
ServerSocket.Active := Verdadeiro;
fim
outro
começar
se ServerSocket.Active então
ServerSocket.Active := Falso;
fim;
fim;
A descrição deste segmento do programa é a seguinte: Quando o usuário seleciona o ListemItem, o ListenItem é invertido. Se selecionado, significa que está no estado Listen O que os leitores precisam entender é: listen é um método proprietário quando o Socket atende. como o Servidor. Se estiver em escuta, o ServerSocket será definido para o estado ativo; caso contrário, a escuta será cancelada e o ServerSocket será fechado; Na verdade, apenas o usuário seleciona inicialmente este item de menu, indicando que o programa está agindo como um servidor. Pelo contrário, se o usuário selecionar ConnectItem, ele deverá ser utilizado como Cliente.
3. Clique duas vezes em ConnectItem e insira o código a seguir.
procedimento TChatForm.ConnectItemClick(Remetente: TObject);
começar
se ClientSocket.Active então ClientSocket.Active := False;
if InputQuery('Computador ao qual conectar', 'Nome do endereço:', Servidor) então
se Comprimento(Servidor) > 0 então
com ClientSocket faça
começar
Anfitrião := Servidor;
Ativo := Verdadeiro;
ListenItem.Checked := Falso;
fim;
fim;
A principal função deste programa é definir o aplicativo como cliente quando o usuário seleciona o item de menu ConnectItem e uma caixa de entrada aparece para permitir que o usuário insira o endereço do servidor. É por isso que não corrigimos o host ClientSocket no início, para que os usuários possam se conectar dinamicamente a diferentes servidores. O que os leitores precisam entender é que o endereço do host é apenas um atributo que o Socket possui quando é um cliente. Quando o Socket é um servidor, ele "geralmente" não usa o endereço porque está vinculado à máquina local.
4. Escreva o seguinte código no método keydown do memo1:
procedimento TChatForm.Memo1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
começar
se Chave = VK_Return então
se forServer então
ServerSocket.Socket.Connections[0].SendText(Memo1.Lines[Memo1.Lines.Count - 1])
outro
ClientSocket.Socket.SendText(Memo1.Lines[Memo1.Lines.Count - 1]);
fim;
A função deste código é óbvia, ou seja, ele inicia o envio de mensagens. Se for um Servidor, ele envia uma mensagem apenas para o primeiro cliente. Como um servidor pode se conectar a vários clientes, e cada conexão com o cliente é mantida por um Socket, o array ServerSocket.Socket.Connections O que é armazenado é o Socket. que mantém a ligação com o Cliente. No Socket padrão, o Socket do lado do servidor obtém o Socket que mantém a conexão com o cliente através do valor de retorno do método accept(), e os métodos de envio e recebimento de mensagens são send(sendto) e recv(recvfrom) respectivamente . Delphi fez esse encapsulamento.
5. Uma breve introdução aos restantes códigos.
procedimento TChatForm.ServerSocketAccept(Remetente: TObject;
Soquete: TCustomWinSocket);
começar
ÉServidor := Verdadeiro;
fim;
O método Accept do ServerSocket é concluído quando o cliente se conecta pela primeira vez. A partir de seus parâmetros, pode-se considerar que ele é executado após o método de aceitação padrão. Como existe o tipo de parâmetro TCustomWinSocket, ele deve ser o valor de retorno do. soquete padrão do lado do servidor.
procedimento TChatForm.ClientSocketRead(Remetente: TObject;
Soquete: TCustomWinSocket);
começar
Memo2.Lines.Add(Socket.ReceiveText);
fim;
procedimento TChatForm.ServerSocketClientRead(Remetente: TObject;
Soquete: TCustomWinSocket);
começar
Memo2.Lines.Add(Socket.ReceiveText);
fim;
Esses dois trechos de código são acionados pelo Delphi quando o lado do servidor e o lado do cliente recebem mensagens um do outro, e sua função é exibir as mensagens recebidas no memo2. Entre eles, o Socket em ClientSocketRead é na verdade o próprio Socket, e o Socket em ServerSocketClientRead é na verdade um Socket em ServerSocket.Socket.Connection[]. Entretanto, no Delphi, o Socket do lado do servidor é efetivamente encapsulado.
procedimento TChatForm.ServerSocketClientConnect(Remetente: TObject;
Soquete: TCustomWinSocket);
começar
Memo2.Linhas.Limpar;
fim;
procedimento TChatForm.ClientSocketDisconnect(Remetente: TObject;
Soquete: TCustomWinSocket);
começar
OuvirItemClick(nil);
fim;
Esses dois parágrafos são relativamente simples. Entre eles, ServerSocketClientConnect é acionado quando ServerSocket recebe uma nova conexão. ClientSocketDisconnect é acionado quando ClientSocket emite Disconncet.
procedimento TChatForm.Exit1Click(Remetente: TObject);
começar
ServidorSocket.Close;
ClienteSocket.Close;
Fechar;
fim;
procedimento TChatForm.Disconnect1Click(Remetente: TObject);
começar
ClientSocket.Active := Falso;
ServerSocket.Active := Verdadeiro;
fim;
O primeiro parágrafo é fechar o aplicativo. No Socket padrão, quando cada Socket é fechado, o método closesocket() deve ser chamado, caso contrário o sistema não liberará recursos. Em ServerSockt.Close e ClientSocket.Close, o método closesocket() deve ser chamado internamente no sistema.
3. Soquete padrão e soquete em Delphi.
A estrutura padrão do aplicativo Socket é a seguinte:
Lado do servidor: Socket()[Crie um novo Socket]--Bind()[Vincule ao endereço do servidor]--Listen()--Accept()--block wait--read()[Aceite mensagens, nas janelas plataforma, o método é send(TCP) ou sendto(UDP)]--process service request--Write()[enviar mensagem, na plataforma Windows, o método é send(TCP), Ou enviar para (UDP).
O lado do cliente é relativamente simples: Socket()--Connect() [Conecta-se a um servidor específico através de uma determinada porta, que é para estabelecer uma conexão com o servidor]--Write()--Read().
O Socket pode ser baseado em TCP ou UDP, e o Socket é até construído em outros protocolos, como IPX/SPX, DECNet, etc. Ao criar um novo Socket, você pode especificar que tipo de Socket criar. Bind() é usado para vincular ao endereço do servidor. Se um host tiver apenas um endereço IP, a função de vinculação é relativamente redundante. Listen() passa a monitorar a rede, Accept() é utilizado para aceitar a conexão e seu valor de retorno é o Socket que mantém contato com o cliente.
No Delphi, o Socket no Windows é efetivamente encapsulado. No Delphi, de acordo com sua relação de herança, eles podem ser divididos em duas categorias:
1. TComponent--TAbstractSocket--TCustomSocket--TCustomServerSocket--TServerSocket
TComponent--TAbstractSocket--TCustomSocket--TClientSocket
2. Herde diretamente do TObject:
TObject--TCustomWinSocket--TServerWinSocket
TObject--TCustomWinSocket--TClientWinSocket
TObject--TCustomWinSocket--TServerClientWinSocket
Pode-se observar que o primeiro tipo é baseado em TCustomSocket, e o segundo tipo é baseado em TCustomWinSocket. O primeiro tipo é construído no TComponet, e o segundo tipo é construído diretamente no TObject. Portanto, se o usuário estiver familiarizado com Socket e quiser escrever um programa de console, ele poderá usar a classe TCustomWinScoket.
Como pode ser visto nos mesmos usos, todos eles são implementados em ScktComp.pas, e schtComp.pas contém o arquivo Winsock.pas. Se você continuar a se aprofundar no arquivo Winsock, poderá encontrar todos os métodos básicos do Windows Socket.
Na verdade, se você entende a estrutura padrão do aplicativo Socket, você se sentirá confortável usando Delphi para escrever aplicativos Socket, isso não significa que você deva entender as funções padrão em Sockets complexos, e isso não é necessário, porque o Delphi já fez isso; para você. Está bem encapsulado, que é o ponto forte do Delphi. Você só precisa entender um pouco do framework básico.
Este é o meu entendimento dos aplicativos Socket em Delphi. Espero que você possa me corrigir se eu tiver alguma deficiência. Ao mesmo tempo, também terei prazer em responder perguntas sobre o Socket no Delphi.