Os aplicativos de rede são divididos em duas partes: cliente e servidor, e a classe de soquete é uma classe Java responsável por lidar com a comunicação do cliente. Através desta classe, você pode se conectar a um servidor com um nome IP ou domínio especificado e pode enviar e receber dados entre si com o servidor. O uso da classe de soquete será discutido em detalhes neste artigo e vários artigos posteriormente, incluindo o básico da classe de soquete, vários métodos de conexão, métodos de obtenção e definição, tempos limites durante a conexão e o fechamento de conexões de rede etc.
Neste artigo, discutiremos as etapas e métodos básicos para usar a classe de soquete. Geralmente, os programas de clientes de rede devem executar as três etapas a seguir ao conectar aos programas de serviço.
1. Conecte -se ao servidor
O cliente pode se conectar ao servidor de duas maneiras, um é conectar -se ao servidor através do IP, e o outro é conectar -se ao servidor através do nome do domínio.
De fato, esses dois métodos são essencialmente de uma maneira. No cliente subjacente, todos eles se conectam ao servidor por meio do IP, mas existem certas diferenças entre os dois métodos. Se o programa do servidor estiver conectado através do IP, o cliente simplesmente se conecta de acordo com o IP. Se o servidor estiver conectado através do nome do domínio, o cliente deverá resolver o nome de domínio no IP através do DNS e depois se conectar de acordo com este IP.
Em muitas linguagens de programação ou ferramentas de desenvolvimento (como C/C ++, Delphi) ao se conectar ao servidor usando o nome do domínio, você deve primeiro resolver o nome de domínio ao IP e depois conectar -se através do IP. Em Java, a função de resolução de nomes de domínio foi incluída na classe de soquete. Portanto, precisamos usar apenas o nome de domínio como o uso do IP.
O método mais comum de conectar -se aos programas de servidor através da classe de soquete é passar o nome IP ou o nome do domínio e o número da porta como parâmetros na classe de soquete através do construtor da classe de soquete. Existem muitas formas sobrecarregadas do construtor da classe de soquete. Nesta seção, apenas um dos formulários mais usados é discutido: soquete público (host de string, porta int). A partir da definição deste construtor, você só precisa passar o nome IP ou de domínio e o número da porta diretamente para o construtor. O código a seguir é um programa de exemplo que se conecta aos programas de servidor:
pacote mysocket; importar java.net.*; public class MyConnection {public static void main (string [] args) {try {if (args.length> 0) {soquete de soquete = new Socket (args [0], 80); System.out.println (args [0] + "conectado com sucesso!"); } else System.out.println ("Especifique o nome IP ou de domínio!"); } catch (Exceção e) {System.err.println ("Mensagem de erro:" + e.getMessage ()); }}} No exposto, o nome IP ou domínio é passado para o programa através do parâmetro da linha de comando e, em seguida, a porta 80 do nome IP ou domínio especificado através do parâmetro da linha de comando é conectado através do soquete do soquete = new Socket (args [0], 80). Como o construtor da classe de soquete usa os arremessos ao definir, ao chamar o construtor de classe do soquete, você deve usar a instrução Try ... Catch para capturar o erro ou usar a instrução THROWS para lançar o erro para a função principal.
Use a classe de soquete para conectar -se ao servidor para determinar quais portas foram abertas em um host. O código a seguir é um programa que verifica que as portas são abertas nesta máquina.
2. Envie e receba dados
Os dois métodos mais importantes na classe de soquete são GetInputStream e GetOutputStream. Esses dois métodos são usados para obter objetos InputStream e OutputStream para leitura e gravação de dados, respectivamente. O InputStream aqui lê os dados enviados pelo programa do servidor para o cliente, e o outputStream são os dados que o cliente deseja enviar para o programa do servidor.
Ao escrever programas reais de clientes de rede, usar o getInputStream ou o GetOutputStream e quem usar primeiro e quem usar mais tarde é determinado pelo aplicativo específico. Por exemplo, conectando -se à porta 80 (geralmente a porta padrão usada pelo protocolo HTTP) do site da Post and Telecommunications Press (www.ptpress.com.cn), enviando uma string e finalmente lendo as informações retornadas de www.ptpress.com.cn.
pacote mysocket; importar java.net.*; importar java.io.*; classe pública myConnection2 {public static void main (string [] args) lança Exceção {soquete Socket = new Socket ("www.ptpress.com.cn", 80); // Envie dados para o programa do servidor outputtStream ops = soket.getOutputStream (); OutputStreamWriter Opsw = new OatdStreamWriter (OPS); BufferWriter BW = New BufferWriter (OPSW); BW.Write ("Hello World/R/N/R/N"); bw.flush (); // Receba dados do programa do servidor inputStream ips = soket.getInputStream (); InputStreamReader ipsr = new InputStreamReader (IPS); BufferErader BR = new BufferredReader (IPSR); String s = ""; while ((s = Br.readline ())! = null) System.out.println (s); Socket.Close (); }} Ao escrever o código acima, você deve prestar atenção aos dois pontos a seguir:
1. Para melhorar a eficiência da transmissão de dados, a classe de soquete não transmite dados toda vez que o método de gravação é chamado, mas grava os dados a serem transferidos para um buffer (o padrão é 8192 bytes) e envia os dados neste buffer juntos através do método de descarga. Portanto, bw.flush (); é necessário.
2. A razão pela qual "/r/n/r/n" é adicionada após o Hello World ao enviar uma string é porque o cabeçalho do protocolo HTTP usa "/r/n/r/n" como o sinalizador final (o conteúdo detalhado do protocolo HTTP será explicado posteriormente). Portanto, ao adicionar "/r/n/r/n" após o envio de uma string, o programa do servidor pode pensar que o cabeçalho HTTP terminou e pode ser processado. Se "/r/n/r/n" não for adicionado, o programa do servidor aguardará o final do cabeçalho HTTP, ou seja, "/r/n/r/n". Nesse caso, o programa do servidor não enviará informações de resposta ao cliente, e o Br.ReadLine () será bloqueado porque não pode ser lido para responder as informações até que a conexão seja interrompida.
3. Desligue a conexão da rede
Até agora, temos um entendimento preliminar dos métodos básicos de uso da classe de soquete, mas depois que a classe de soquete processou os dados, o método de final mais razoável é usar o método de fechamento da classe de soquete para fechar a conexão de rede. Embora o método próximo tenha sido usado nele, o método de fechar a conexão de rede não é apenas o método próximo. Vamos ver em que circunstâncias o Java pode fechar a conexão de rede.
Existem quatro situações em que as conexões de rede podem ser fechadas:
Embora todos esses 4 métodos possam atingir o mesmo objetivo, é melhor usar o primeiro ou o segundo método para fechar a conexão de rede. Isso ocorre porque o terceiro e o quarto métodos geralmente não fecham a conexão de rede imediatamente. Nesse caso, para algumas aplicações, será deixado um grande número de conexões de rede inúteis, o que ocupará uma grande quantidade de recursos do sistema.
Depois que o objeto de soquete estiver fechado, podemos usar o método ISCLOSED para determinar se um objeto de soquete está em um estado fechado. No entanto, o que é retornado usando o método de isclosed é o estado atual do objeto de soquete. Ou seja, independentemente de o objeto de soquete ter sido conectado com sucesso, o ISCLOSDE retorna verdadeiro enquanto estiver no estado fechado. Se você apenas criar um objeto de soquete desconectado, o ISClose também retorna true. Conforme mostrado no código a seguir, o false será emitido.
Socket Socket = new Socket (); System.out.println (SOCKET.isclosed ());
Além do método ISCLOSE, a classe de soquete também possui um método ISConnected para determinar se o objeto de soquete está conectado com sucesso. Quando você vê esse nome, os leitores podem entender mal. De fato, o método ISConnected não determina o status de conexão atual do objeto de soquete, mas se o objeto de soquete foi conectado com sucesso. Se foi conectado com sucesso, mesmo que o ISClose retorne true agora, o ISConnected ainda retorna true. Portanto, para determinar se o objeto de soquete atual está em um estado conectado, os métodos ISClose e IsConnected devem ser usados ao mesmo tempo, ou seja, o objeto de soquete está em um estado conectado somente quando o ISClose retorna false e isconected retorna verdadeiro. O código a seguir demonstra o processo de geração de vários estados do objeto de soquete acima.
pacote mysocket; importar java.net.*; classe pública myCloseConnection {public static void printState (soquete, nome da string) {System.out.println (nome + ".isclosed ():" + Socket.iscled ()); System.out.println (nome + ".isconnected ():" + soket.isconnected ()); if (Socket.isclosed () == false && socket.isconnected () == true) system.out.println (nome + "no estado conectado!"); else System.out.println (nome + "no estado não conectado!"); System.out.println (); } public static void main (string [] args) lança Exceção {soquete Socket1 = NULL, Socket2 = NULL; Socket1 = novo soquete ("www.ptpress.com.cn", 80); printState (Socket1, "Socket1"); Socket1.getOutputStream (). Close (); printState (Socket1, "Socket1"); Socket2 = new Socket (); printState (Socket2, "Socket2"); Socket2.Close (); printState (Socket2, "Socket2"); }} Depois de executar o código acima, a seguinte saída será mostrada:
Socket1.isclosed (): false
Socket1.isconnected (): true
O Socket1 está em um estado conectado!
Socket1.isclosed (): true
Socket1.isconnected (): true
O Socket1 está em um estado não conectado!
Socket2.isclosed (): false
Socket2.isconnected (): false
O Socket2 está em um estado não conectado!
Socket2.isclosed (): true
Socket2.isconnected (): false
O Socket2 está em um estado não conectado!
A partir dos resultados da saída, pode -se observar que, após o fechamento de saída do Socket1, o Socket1 também é fechado automaticamente. No código acima, podemos ver que, para um soquete Socket2 que não está conectado ao servidor, seu método ISCLOUD é falso. Se o método Socket2 ISCLOSED retornar TRUE, o método de fechamento deverá ser chamado de exibição de Socket2.Close.
Embora na maioria das vezes, possamos usar a classe de soquete ou o método de fechamento do fluxo de entrada e saída para fechar a conexão de rede, às vezes queremos fechar o outputStream ou o InputStream e, ao fechar o fluxo de entrada e saída, não fechamos a conexão de rede. Isso requer o uso de outros dois métodos da classe de soquete: ShutdownInput e ShutdownOutput. Esses dois métodos fecham apenas os fluxos de entrada e saída correspondentes, mas não têm a função de fechar a conexão de rede ao mesmo tempo. Como os métodos isclosed e isconected, a classe de soquete também fornece dois métodos para determinar se os fluxos de entrada e saída do objeto de soquete estão fechados. Esses dois métodos são ISInputShutDown () e isOutputShutDown (). O código a seguir demonstra o processo de fechar apenas fluxos de entrada e saída:
pacote mysocket; importar java.net.*; classe pública myClosEConnection1 {public static void printState (soquete) {System.out.println ("isInputShutDown:" + soket.isInputShutDown ()); System.out.println ("isOutputShutDown:" + Socket.isOutputShutDown ()); System.out.println ("isClosed:" + Socket.isclosed ()); System.out.println (); } public static void main (string [] args) lança Exceção {soquete soquete = new Socket ("www.ptpress.com.cn", 80); printState (soquete); soket.shutdownInput (); printState (soquete); soket.shutdownOutput (); printState (soquete); }} Depois de executar a geração acima, você obterá a seguinte saída:
ISInputShutDown: False
isOutputShutDown: false
ISCLOSED: FALSO
IsInputShutdown: true
isOutputShutDown: false
ISCLOSED: FALSO
IsInputShutdown: true
isOutputShutdown: true
ISCLOSED: FALSO
A partir dos resultados da saída, podemos ver que o método ISCLOSED sempre retorna false, por isso é certo que o desligamento e o desligamento não afetam o status do objeto de soquete.
Espero que este artigo seja útil para você. Isso é tudo para o Java usar a classe de soquete para receber e enviar conteúdo de dados. Espero que todos continuem a seguir nosso site! Se você quiser aprender Java, pode continuar a seguir este site.