O soquete, também conhecido como soquetes, é uma das tecnologias básicas para a comunicação da rede de computadores. Hoje, a maioria dos softwares baseados na Web, como navegadores, ferramentas de mensagens instantâneas e até downloads de P2P, são implementadas com base no soquete. Este artigo introduzirá programação de soquete com base no TCP/IP e como gravar um programa de cliente/servidor.
Sobremesa pré-jantar
O sistema de entrada e saída da Unix (IO) segue modelos de operação, como a localização de leitura aberta. Antes que um processo do usuário execute operações de IO, ele precisa ligar para abrir para especificar e obter permissões para que o arquivo ou dispositivo seja operado para ler ou gravar. Depois que o objeto de operação de IO é aberto, o processo do usuário poderá executar uma ou mais operações de leitura ou gravação no objeto. A operação de leitura é usada para ler dados de objetos de operação de IO e passar os dados para o processo do usuário. A operação de gravação é usada para passar os dados (gravar) nos processos do usuário para objetos de operação de IO. Depois que todas as operações de leitura e gravação são concluídas, o processo do usuário precisa ligar perto para notificar o sistema de que conclui o uso do objeto IO.
Quando o UNIX começou a oferecer suporte à Comunicação Interprocessante (IPC), a interface do IPC foi projetada para ser semelhante à interface de operação do arquivo IO. No UNIX, um processo terá um conjunto de descritores de IO que podem ser lidos e escritos. O descritor de IO pode ser um arquivo, dispositivo ou canal de comunicação (soquete). Um descritor de arquivo consiste em três partes: criando (abertura de soquete), leitura e escrita de dados (aceitando e enviando para o soquete) e destruição (encerramento do soquete).
Nos sistemas UNIX, a versão do tipo BSD da interface IPC é implementada como uma camada acima dos protocolos TCP e UDP. O destino da mensagem é representado pelo endereço do soquete. Um endereço de soquete é um identificador de comunicação composto por um endereço de rede e um número de porta.
As operações de comunicação entre processos exigem um par de soquetes. A comunicação entre processos é realizada pela transmissão de dados entre um soquete em um processo e outro soquete em outro processo. Quando uma mensagem é executada e enviada, a mensagem é filada no soquete na extremidade de envio até que o protocolo de rede de nível inferior envie as mensagens. Quando a mensagem atingir o soquete na extremidade de recebimento, ela também estará em uma fila até que o processo na extremidade receptora receba a mensagem.
Comunicação TCP e UDP
Em relação à programação do soquete, temos dois protocolos de comunicação para escolher. Um é a comunicação de datagrama, o outro é a comunicação de fluxo.
Comunicação de datagrama
O protocolo de comunicação de datagrama é o que chamamos de UDP (Protocolo de dados do usuário). O UDP é um protocolo sem conexão, o que significa que toda vez que enviamos datagramas, precisamos enviar o descritor de soquete da máquina nativa e o descritor de soquete do receptor ao mesmo tempo. Portanto, precisamos enviar dados adicionais toda vez que nos comunicamos.
Comunicação de fluxo
O protocolo de comunicação do fluxo, também conhecido como TCP (Protocolo de Controle de Transferência) também é chamado de TCP (Protocolo de Controle de Transferência). Ao contrário do UDP, o TCP é um protocolo baseado em conexão. Antes de usar a comunicação do fluxo, devemos estabelecer uma conexão entre o par de soquetes de comunicação. Um dos soquetes serve como servidor para ouvir solicitações de conexão. O outro faz solicitações de conexão como cliente. Depois que os dois soquetes estabeleceram uma conexão, eles podem transferir dados em ida ou bidirecional.
Depois de ler isso, temos algumas perguntas sobre se usamos o UDP ou o TCP para programação de soquete. A escolha da programação do soquete com base em qual protocolo é baseado no cenário de aplicativo específico depende do seu programa de cliente-servidor específico. Abaixo, analisamos brevemente a diferença entre os protocolos TCP e UDP, o que pode ajudá -lo a escolher melhor qual deles usar.
No UDP, cada vez que um datagrama é enviado, o descritor de soquete da máquina nativa e o descritor de soquete do receptor precisam ser incluídos. Como o TCP é um protocolo baseado em conexão, uma conexão precisa ser estabelecida entre os pares de soquete de comunicação antes da comunicação; portanto, haverá uma programação de conexão demorada no protocolo TCP.
No UDP, os dados do datagrama têm um limite de 64 KB de tamanho. Não existe tal restrição no TCP. Uma vez que o par de comunicação TCP estabeleça uma conexão, a comunicação entre eles é semelhante a um fluxo de IO e todos os dados serão lidos na ordem, eles serão aceitos.
O UDP é um protocolo não confiável e os datagramas enviados não são necessariamente aceitos pelo soquete de recebimento na ordem em que são enviados. Então o TCP é um protocolo confiável. A ordem dos pacotes recebidos pela extremidade de recebimento é consistente com a ordem dos pacotes na extremidade do envio.
Em resumo, o TCP é adequado para serviços de rede, como login remoto (Rlogin, Telnet) e Transferência de Arquivos (FTP). Porque o tamanho desses dados que precisa ser transmitido é incerto. O UDP é mais simples e mais leve que o TCP. O UDP é usado para implementar alguns serviços mais em tempo real ou não têm importância da perda de pacotes. A taxa de perda de pacotes de UDP na LAN é relativamente baixa.
Programação de soquete em java
Na seção a seguir, explicarei como usar o soquete para escrever programas de clientes e servidores por meio de alguns exemplos.
Nota: No exemplo a seguir, usarei a programação de soquete com base no protocolo TCP/IP, porque esse protocolo é muito mais amplamente utilizado que o UDP/IP. E todas as classes relacionadas ao soquete estão localizadas no pacote java.net, por isso precisamos introduzir este pacote quando estamos fazendo programação de soquete.
Escrita do cliente
Ligue o soquete
Se você estiver do lado do cliente, precisará escrever o código a seguir para abrir um soquete.
String host = "127.0.0.1"; int porta = 8919; Socket Client = new Socket (host, porta);
No código acima, o host é a máquina à qual o cliente precisa se conectar e a porta é a porta usada pelo servidor para ouvir a solicitação. Ao selecionar uma porta, uma coisa em que você precisa prestar atenção é que portas como 0 ~ 1023 foram reservadas pelo sistema. Essas portas são usadas por alguns serviços comumente usados, como correio, FTP e HTTP. Ao escrever código do lado do servidor e selecionar uma porta, selecione uma porta maior que 1023.
Escreva dados
Em seguida, é escrever os dados da solicitação. Obtemos o objeto O outputStream do objeto de soquete do cliente e, em seguida, escrevemos os dados. Muito semelhante ao código de processamento de IO do arquivo.
public class CustomerSocket {public static void main (string args []) {string host = "127.0.0.1"; int porta = 8919; tente {socket client = new Socket (host, porta); Writer Writer = new OtpitStreamWriter (client.getOutputStream ()); writer.write ("Olá do cliente"); writer.flush (); writer.close (); client.close (); } catch (ioexception e) {e.printStackTrace (); }}}Fechar o objeto io
Semelhante ao arquivo IO, depois de ler e escrever dados, precisamos fechar o objeto de IO para garantir a liberação correta de recursos.
Escrita do lado do servidor
Abra o soquete do servidor
int porta = 8919; serversocket server = new ServerSocket (porta); soquete soquete = server.accept ();
O código acima cria um soquete do lado do servidor e chama o método de aceitação para ouvir e obter o soquete de solicitação do cliente. O método de aceitação é um método de bloqueio que aguarda o bloqueio até que uma conexão seja feita entre o servidor e o cliente.
Leia os dados
Obtenha o objeto InputStream através do objeto de soquete obtido acima e instale o arquivo IO para ler os dados. Aqui imprimimos o conteúdo.
classe pública serverclient {public static void main (string [] args) {int porta = 8919; tente {serverSocket Server = new ServerSocket (porta); Soquete soquete = server.accept (); Leitor leitor = new inputStreamReader (soket.getInputStream ()); Char Chars [] = novo char [1024]; int len; StringBuilder Builder = new StringBuilder (); while ((len = leitor.read (chars))! = -1) {builder.append (new string (chars, 0, len)); } System.out.println ("Receba da mensagem do cliente =:" + construtor); leitor.close (); Socket.Close (); server.close (); } catch (Exceção e) {e.printStackTrace (); }}}Fechar o objeto io
Não pode ser esquecido. Por fim, preciso fechar o objeto de IO corretamente para garantir a liberação correta de recursos.
Observe um exemplo
Aqui, adicionamos um exemplo, usando o soquete para implementar um servidor de eco, ou seja, o servidor passará os dados enviados pelo cliente de volta ao cliente. O código é muito simples.
Importar java.io.*; importar java.net. Linha de string; DatainputStream é; PrintStream OS; Socket clientSocket = null; // Tente abrir um soquete do servidor na porta 9999 // Observe que não podemos escolher uma porta menor que 1023 se não formos // usuários privilegiados (root) tente {ecServer = new ServerSocket (9999); } catch (ioexception e) {System.out.println (e); } // Crie um objeto de soquete do ServerSocket para ouvir e aceitar // conexões. // Abra os fluxos de entrada e saída, tente {clientsocket = echoserver.accept (); is = new DataAinputStream (clusterSocket.getInputStream ()); OS = new PrintStream (clusterSocket.getOutputStream ()); // Enquanto recebermos dados, ecoarão esses dados de volta ao cliente. while (true) {line = is.readline (); os.println (linha); }} catch (ioexception e) {System.out.println (e); }}}Compilar e executar o código acima e fazer a seguinte solicitação, você pode ver o conteúdo dos dados transportados pela solicitação do cliente.
15:00 $ curl http://127.0.0.1:9999/?111GET /?111 HTTP/1.1User-Agent: curl/7.37.1Host: 127.0.0.1:9999Accept: */*
Resumir
É bastante interessante executar a programação do cliente-servidor, e a programação de soquete em Java é mais fácil e rápida do que outros idiomas (como C).
O pacote Java.NET contém muitas classes poderosas e flexíveis para os desenvolvedores para programar redes. Ao programar redes, é recomendável usar a API abaixo deste pacote. Ao mesmo tempo, o pacote Sun.* também contém muitas classes relacionadas à programação de rede, mas não é recomendável usar a API abaixo deste pacote, porque este pacote pode mudar. Além disso, este pacote não pode ser garantido para ser incluído em todas as plataformas.
O acima é uma compilação das informações do soquete Java. Continuaremos a adicionar conhecimento relevante no futuro. Obrigado pelo seu apoio a este site!