Explicação detalhada dos exemplos de programação de rede Java com base no soquete

1. Dois principais problemas na programação de rede

Um é como localizar com precisão um ou mais hosts na rede, e o outro é como transmitir dados de maneira confiável e eficiente após encontrar o host.

No protocolo TCP/IP, a camada IP é principalmente responsável pela localização do host de rede e pelo roteamento da transmissão de dados. O endereço IP pode determinar exclusivamente um host na Internet.

A camada TCP fornece um mecanismo de transmissão de dados confiável (TCP) ou não confiável (UDP) para aplicação, que é o principal objeto da programação de rede e geralmente não precisa se preocupar com a forma como a camada IP processa dados.

O modelo de programação de rede mais popular no momento é a estrutura do cliente/servidor (s). Ou seja, uma das partes de comunicação atua como servidor para aguardar o cliente para enviar uma solicitação e responder. O cliente se aplica ao servidor quando o serviço é necessário. O servidor geralmente está sempre em execução como daemon, ouvindo a porta de rede. Depois que um cliente solicitar, ele iniciará um processo de serviço para responder ao cliente e, ao mesmo tempo, continuará ouvindo a própria porta de serviço para que os clientes posteriores também possam obter serviço em tempo hábil.

2. Dois tipos de protocolos de transmissão: TCP; UDP

TCP é a abreviação do Tranfer Control Protocol , um protocolo orientado a conexão que garante transmissão confiável. A transmissão através do protocolo TCP resulta em uma ordem de fluxos de dados sem erros. Uma conexão deve ser estabelecida entre os dois pares de soquetes do remetente e do receptor, a fim de se comunicar com base no protocolo TCP. Quando um soquete (geralmente um soquete do servidor) está esperando para estabelecer uma conexão, o outro soquete pode exigir uma conexão. Depois que esses dois soquetes estiverem conectados, eles podem executar a transmissão de dados de mão dupla e ambas as partes podem executar operações de envio ou recebimento.

UDP é a abreviação do User Datagram Protocol . É um protocolo sem conexão. Cada datagrama é uma informação independente, incluindo um endereço de origem ou destino completo. É transmitido ao destino na rede por qualquer caminho possível. Portanto, se pode chegar ao destino, a hora de chegar ao destino e a correção do conteúdo não podem ser garantidos.

Comparar:

UDP:

1. Cada datagrama fornece informações completas para o endereço, portanto, não há necessidade de estabelecer uma conexão entre o remetente e o receptor.
2. Há um limite de tamanho quando o UDP transmite dados e cada datagrama transmitido deve ser limitado a 64kb.
3. O UDP é um protocolo não confiável, e os datagramas enviados pelo remetente não chegam necessariamente ao receptor na mesma ordem.

TCP:

1. Um protocolo orientado a conexão exige que uma conexão seja estabelecida antes da transmissão de dados entre os soquetes, portanto, é necessário o tempo de conexão no TCP.
2. Limites de tamanho de dados de transmissão TCP. Depois que a conexão é estabelecida, os soquetes de ambas as partes podem transmitir grandes dados em um formato unificado.
3. O TCP é um protocolo confiável que garante que o receptor obtenha completamente todos os dados enviados pelo remetente.

aplicativo:

1. O TCP possui vitalidade extremamente forte na comunicação de rede, como conexão remota (TELNET) e transferência de arquivos (FTP) que exigem que dados de comprimentos variados sejam transmitidos de forma confiável. No entanto, a transmissão confiável tem um custo. A verificação da correção do conteúdo de dados ocupará inevitavelmente o tempo de processamento e a largura de banda de rede do computador. Portanto, a eficiência da transmissão TCP não é tão alta quanto a do UDP.
2. O UDP é simples de operar e requer apenas menos supervisão, por isso geralmente é usado em aplicativos de cliente/servidor em sistemas distribuídos com alta confiabilidade em LANs. Por exemplo, os sistemas de videoconferência não exigem a correção absoluta dos dados de áudio e vídeo, desde que a consistência seja garantida, é obviamente mais razoável usar UDP neste caso.

3. Programação de rede Java baseada em soquete

1. O que é soquete

Dois programas na rede realizam a troca de dados através de uma conexão de comunicação bidirecional. Uma extremidade deste link de mão dupla é chamada de soquete. O soquete é geralmente usado para conectar -se entre clientes e provedores de serviços. O soquete é uma interface de programação muito popular do protocolo TCP/IP. Um soquete é determinado exclusivamente por um endereço IP e um número de porta.

No entanto, os tipos de protocolos suportados pelo soquete não são apenas TCP/IP; portanto, não há conexão necessária entre os dois. No ambiente Java, a programação do soquete refere -se principalmente à programação de rede com base no protocolo TCP/IP.

2. O processo de comunicação do soquete

O servidor ouve (ouve) se existe uma solicitação de conexão em uma determinada porta. O lado do cliente emite uma solicitação de conexão para o lado do servidor e o lado do servidor envia uma mensagem de aceitação de volta ao lado do cliente. Uma conexão é estabelecida. O servidor e o lado do cliente podem se comunicar entre si por meio de envio, gravação e outros métodos.

Para um soquete totalmente funcional, ele deve incluir a seguinte estrutura básica, e seu processo de trabalho inclui as quatro etapas básicas a seguir:

(1) criar soquete;

(2) abra a entrada/saída conectada ao soquete;

(3) Leia/Escreva o soquete de acordo com um determinado protocolo;

(4) Feche o soquete. (Em aplicações reais, o fechamento exibido não é usado. Embora muitos artigos recomendam isso, no meu programa, pode não ter nenhum impacto porque o próprio programa é relativamente simples e possui requisitos baixos.)

3. Crie soquete

 Soquete (endereço inetaddress, porta int); Soquete (endereço inetaddress, porta int, fluxo booleano); Soquete (host de string, int prot); Socket (host de string, int prot, fluxo booleano); Socket (soquete Impl) Socket (host de string, porta int, inetAddress LocalAddr, int localport) (endereço INETADDRESS, porta int, InetAddress LocalAddr, int localport) ServerSocket (porta int); ServerSocket (porta int, int backlog); Serversocket (porta int, int backlog, INETAddress bindaddr), onde o endereço, o host e a porta são o endereço IP, o nome do host e o número da outra parte na conexão bidirecional, respectivamente. O fluxo indica se o soquete é um soquete de fluxo ou um soquete de datagrama. Localport indica que o número da porta do host local, LocalAddr e Bindaddr são o endereço da máquina local (o endereço do host do ServerSocket). Impl é a classe pai do soquete, que pode ser usada para criar o ServerSocket e criar soquetes. A contagem representa o número máximo de conexões que o servidor pode suportar. Por exemplo: Aprendendo a rede de vídeo http://www.xxspw.com cliente de soquete = new Socket ("127.0.01.", 80); ServerSocket Server = new ServerSocket (80);

Observe que você deve ter cuidado ao selecionar uma porta. Cada porta fornece um serviço específico. Somente fornecendo a porta correta, o serviço correspondente pode ser obtido. Os números da porta de 0 ~ 1023 são reservados pelo sistema. Por exemplo, o número da porta do serviço HTTP é 80, o número da porta do serviço Telnet é 21 e o número da porta do serviço FTP é 23. Portanto, quando selecionamos o número da porta, é melhor escolher um número maior que 1023 para evitar conflitos.

Se ocorrer um erro ao criar um soquete, uma IoException será gerada e deve ser processada no programa. Portanto, ao criar soquete ou servidorsocket, as exceções devem ser capturadas ou arremessadas.

4. Programa de cliente/servidor simples

1. Programa do cliente

 importar java.io.*; importar java.net.*; public class TalkClient {public static void main (string args []) {try {soquete soquete = new Socket ("127.0.0.1", 4700); // Envie uma solicitação de cliente para a porta 4700 do Machine BufferReader sin = new BufferredReader (new InputStreamReader (System.in)); // Construa o objeto BufferredReader a partir do sistema de entrada padrão do sistema PrintWriter OS = new PrintWriter (Socket.getOutputStream ()); // Obtenha o fluxo de saída do objeto de soquete e construa o PrintWriter Object BupiceReader IS = new BufferErader (new InputStreamReader (Socket.getInputStream ())); // Obtenha o fluxo de entrada do objeto de soquete e construa o objeto BufferReader correspondente String ReadLine; readLine = sin.readline (); // Leia uma string a partir da entrada padrão do sistema while (! Readline.equals ("tchau")) {// Se a string lida da entrada padrão for "tchau", pare o loop os.println (readline); // em saída a string lida da entrada padrão do sistema para servidor os.flush (); // Atualize o fluxo de saída para que o servidor receba imediatamente o String System.out.println ("Client:"+ReadLine); // Imprima o String String.out.println ("servidor:"+is.readline ()); // Leia uma string do servidor e imprima -a para a saída padrão readline = sin.readline (); // Leia uma sequência da entrada padrão do sistema} // Continue a fazer loop os.close (); // Fechar o fluxo de saída do soquete is.close (); // Fechar soquete de fluxo de entrada do soquete.close (); // Fechar o soquete} Catch (Exceção e) {System.out.println ("Error"+E); // ocorre um erro, uma mensagem de erro é impressa}}}

2. Programa do lado do servidor

 importar java.io.*; importar java.net.*; importar java.applet.applet; public class TalkServer {public static void main (string args []) {try {serverSocket Server = null; tente {server = new ServerSocket (4700); // Crie um ServerSocket para ouvir as solicitações do cliente na porta 4700} Catch (Exceção e) {System.out.println ("Não pode ouvir:"+e); // erro, imprimir mensagem de erro} soquete = null; tente {socket = server.accept (); // use aceite () para bloquear e aguardar a solicitação do cliente. Se um cliente // após a solicitação chegar, um objeto de soquete será gerado e continue a executar} catch (Exceção e) {System.out.println ("Error."+E); // ocorre um erro, as informações de erro de impressão são impressas} linha de string; BufferredReader IS = new BufferredReader (new InputStreamReader (Socket.getInputStream ())); // Obtenha o fluxo de entrada do objeto de soquete e construa o objeto BufferReader correspondente PrintWriter OS = NewPrintWriter (Socket.getOutputStream ()); // Obtenha o fluxo de saída do objeto de soquete e construa o PrintWriter Object BufferReader sin = new BufferredReader (new InputStreamReader (System.in)); // Construa o BufferEredReader Object System.out.println ("client:"+is.readline ()); // imprima a string lida do cliente na linha de saída padrão = sin.readline (); // Leia uma string a partir da entrada padrão while (! Line.equals ("tchau")) {// se a string for "tchau", pare o loop os.println (line); // em saída o string os.flush () para o cliente; // Atualize o fluxo de saída para que o cliente receba imediatamente o String System.out.println ("Server:"+Line); // Imprima o String String.out.println ("cliente:"+is.readline ()); // Leia uma string do cliente e imprima -a na linha de saída padrão = sin.readline (); // Leia uma sequência da entrada padrão do sistema} // Continue a fazer loop os.close (); // Fechar o fluxo de saída do soquete is.close (); // Fechar soquete de fluxo de entrada do soquete.close (); // Fechar o Socket Server.close (); // Fechar o ServerSocket} Catch (Exceção e) {System.out.println ("Error:"+E); // Ocorreu um erro, imprima mensagem de erro}}}

5. Suporte ao programa de cliente/servidor multi-cliente

O programa de cliente/servidor anterior pode implementar apenas conversas entre o servidor e um cliente. Em aplicativos reais, um programa permanente geralmente é executado no servidor, que pode receber solicitações de vários outros clientes e fornecer serviços correspondentes. Para realizar a função de fornecer serviços a vários clientes no servidor, o programa acima precisa ser transformado e o mecanismo de multi-threading é implementado. O servidor sempre escuta se existem solicitações de cliente na porta especificada. Depois que a solicitação do cliente for ouvida, o servidor iniciará um tópico de serviço especial para responder à solicitação do cliente. O próprio servidor entra imediatamente no estado de escuta depois de iniciar o tópico, aguardando o próximo cliente chegar.