Java grava um servidor e um cliente que podem fazer upload de arquivos. O conteúdo específico é o seguinte
Lado do servidor
Classe Server {public static void main (string [] args) lança exceção {// crie o servidor servidor ServerSocket SS = new ServerSocket (10005); // Receba o soquete do cliente FileLoaderSocket = ss.accept (); // Imprima as informações de conexão string ip = fileLoaderSocket.getineTAddress (). Gethostaddress (); System.out.println (ip + "... conceleted"); // Receba o arquivo e salve InputStream em = FileloaderSocket.getInputStream (); // instanciam o objeto Arquivos de Arquivos outputStream FilesAve = new FileOutputStream ("e: //3.mp3"); // Crie uma matriz buf byte [] buf = novo byte [1024]; int len = 0; // Defende se o final do arquivo é lido enquanto ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // refrescam filesave.flush (); } // Retornar Informações de cópia de arquivo BufferWriter Out = new BufferWriter (new O outputStreamWriter (FileLoaderSocket.getOutputStream ())); out.write ("upload de arquivo bem -sucedido"); // atualizar.flush (); // Recurso Fechar Ss.Close (); fileloadersocket.close (); filesvelave.close (); }}Cliente:
Classe Client {public static void main (string [] args) lança exceção {// Crie soquete de soquete FileLoaderSocket = new Socket ("168.168.168.94", 10005); // Leia o arquivo localmente do cliente e grava no fluxo de saída do soquete outputStream out = fileLoaderSocket.getOutputStream (); // instancia o objeto FileReader inputStream fileread = new FileInputStream ("g: //2.mp3"); // Crie um byte de matriz [] buf = novo byte [1024]; int len = 0; // julga se o final do arquivo é lido enquanto ((len = fileread.read (buf))! = -1) {out.write (buf, 0, len); } // Diga ao servidor que o arquivo foi transferido FileloaderSocket.shutdownoutput (); // Obtenha o feedback das informações do servidor BufferReader em = new BufferredReader (new InputStreamReader (FileLoaderSocket.getInputStream ())); String serverback = in.readline (); System.out.println (Serverback); // Recurso Fechar FileloaderSocket.close (); fileread.close (); }}O programa a seguir é copiado diretamente de outros lugares para referência de aprendizado:
Programação do soquete Java
Para a programação do soquete Java, existem dois conceitos, um é o ServerSocket e o outro é o soquete. O servidor e o cliente estão conectados através do soquete e, em seguida, eles podem se comunicar. Primeiro, o ServerSocket ouvirá uma porta no servidor. Quando se vê que o cliente tem um soquete para tentar se conectar a ele, aceitará a solicitação de conexão do soquete e, ao mesmo tempo, estabelecerá um soquete correspondente no servidor para se comunicar com ele. Dessa forma, existem dois soquetes, um no cliente e outro no servidor.
A comunicação entre soquetes é realmente muito simples. Quando o servidor grava algo no fluxo de saída do soquete, o cliente pode ler o conteúdo correspondente através do fluxo de entrada do soquete. O soquete e o soquete estão conectados em duas direções, para que o cliente também possa escrever coisas no fluxo de saída de soquete correspondente e, em seguida, o fluxo de entrada de soquete correspondente do servidor pode ler o conteúdo correspondente. Aqui estão alguns exemplos de comunicação do lado do servidor com os clientes:
1. Escreva do cliente e leitura do servidor
Código Java do servidor
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); // O servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Depois de estabelecer uma conexão com o cliente, podemos obter o InputStream do soquete e ler as informações enviadas pelo cliente. Leitor leitor = new inputStreamReader (soket.getInputStream ()); chars [] = novo char [64]; int len; Stringbuilder sb = new stringbuilder (); while ((len = leitor.read (chars))! = -1) {sb.append (new string (chars, 0, len)); } System.out.println ("do cliente:" + sb); leitor.close (); Socket.Close (); server.close (); }}A operação do servidor para ler dados do inputStream do soquete também está bloqueando. Se os dados não forem lidos no fluxo de entrada, o programa permanecerá lá até que o cliente grava dados no fluxo de saída do soquete ou feche o fluxo de saída do soquete. Obviamente, o mesmo se aplica aos soquetes do cliente. Após a conclusão da operação, lembre -se de fechar os recursos correspondentes antes que todo o programa seja concluído, ou seja, feche o fluxo e o soquete correspondentes.
Código Java Client
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // O endereço IP do servidor a ser conectado é intt = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados no servidor Writer = new OutputStreamWriter (client.getOutputStream ()); writer.Write ("Hello Server."); writer.flush (); // Lembre -se de Flush Writer.Close (); client.close (); }}Ao escrever dados no fluxo de saída do soquete, você deve prestar atenção a uma coisa. Se o programa não corresponder ao desligamento do fluxo de saída após a operação de gravação, mas executar outras operações de bloqueio (como a leitura de dados do fluxo de entrada), lembre -se de liberá -lo. Somente dessa maneira o servidor pode receber os dados enviados pelo cliente, caso contrário, poderá causar uma espera ilimitada um pelo outro. Esse problema será mencionado mais adiante ao falar sobre a leitura e a escrita do cliente e do servidor ao mesmo tempo.
2. O cliente e o servidor leem e escrevem ao mesmo tempo
Como mencionado anteriormente, os soquetes se comunicam de maneiras bidirecionais, que podem receber dados e enviar dados.
Código Java do servidor
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); // O servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Depois de estabelecer uma conexão com o cliente, podemos obter o InputStream do soquete e ler as informações enviadas pelo cliente. Leitor leitor = new inputStreamReader (soket.getInputStream ()); chars [] = novo char [64]; int len; Stringbuilder sb = new stringbuilder (); while ((len = leitor.read (chars))! = -1) {sb.append (new string (chars, 0, len)); } System.out.println ("do cliente:" + sb); // Escreva uma frase depois de ler o escritor de TI = new OutputStreamWriter (Socket.getOutputStream ()); writer.Write ("Hello Client."); writer.flush (); writer.close (); leitor.close (); Socket.Close (); server.close (); }}No código acima, lemos os dados enviados pelo cliente a partir do fluxo de entrada e, em seguida, escrevemos os dados no fluxo de saída para o cliente e, em seguida, fechamos o arquivo de recursos correspondente. De fato, o código acima pode não ser executado da maneira que assumimos com antecedência, porque a leitura de dados do fluxo de entrada é uma operação de bloqueio. Quando os dados são lidos no acima, durante o loop, o corpo do loop será executado, caso contrário, serão bloqueados, para que as operações de gravação subsequentes nunca sejam executadas. O loop while será interrompido, a menos que o soquete correspondente do cliente esteja fechado e bloqueado. A solução para essa situação em que pode nunca ser executada é que, no tempo, o loop precisa ser saltado condicionalmente. Olhando para o código acima, a única coisa que muda é o comprimento e os dados que são lidos. Len não é mais utilizável, e a única coisa que pode ser usada são os dados que são lidos. Nesse caso, geralmente concordamos com uma etiqueta final. Quando os dados enviados pelo cliente contêm uma determinada etiqueta final, isso significa que os dados atuais foram enviados e, neste momento, podemos fazer uma saída. Então o código aprimorado ficará assim:
Código Java
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); // O servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Depois de estabelecer uma conexão com o cliente, podemos obter o InputStream do soquete e ler as informações enviadas pelo cliente. Leitor leitor = new inputStreamReader (soket.getInputStream ()); chars [] = novo char [64]; int len; Stringbuilder sb = new stringbuilder (); Temp de string; índice int; while ((len = leitor.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// A recepção é encerrada quando o EOF é encontrado sb.append (temp.substring (0, índice)); quebrar; } sb.append (temp); } System.out.println ("do cliente:" + sb); // Escreva uma frase após a leitura do escritor do Writer = new OatdStreamWriter (Socket.getOutputStream ()); writer.Write ("Hello Client."); writer.flush (); writer.close (); leitor.close (); Socket.Close (); server.close (); }}No código acima, quando o servidor lê a marca final enviada pelo cliente, ou seja, "EOF", a recepção de dados será encerrada e o loop será encerrado, para que o código subsequente possa continuar.
Código Java Client
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // o endereço IP do servidor a ser conectado int porta = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados no servidor Writer = new OutputStreamWriter (client.getOutputStream ()); writer.Write ("Hello Server."); writer.flush (); // Leia após escrever leitor leitor = new inputStreamReader (client.getInputStream ()); chars [] = novo char [64]; int len; StringBuffer sb = new StringBuffer (); while ((len = leitor.read (chars))! = -1) {sb.append (new string (chars, 0, len)); } System.out.println ("do servidor:" + sb); writer.close (); leitor.close (); client.close (); }}No código acima, enviamos um dos dados primeiro ao servidor e depois lemos os dados retornados pelo servidor. Como o servidor anterior, ele pode fazer com que o programa fique lá o tempo todo e nunca pular do loop while. Esse código é combinado com o primeiro código do servidor, basta analisar que o servidor sempre receberá dados lá e nunca sairá do loop while, portanto, não haverá um servidor subsequente para retornar dados ao cliente e o cliente não poderá receber dados retornados pelo servidor. A solução é mostrada no segundo código do servidor. Depois que o cliente enviar os dados, escreva uma marca final no fluxo de saída para informar ao servidor que os dados foram enviados. O servidor também envia uma marca para informar ao cliente após a devolução dos dados. Então o código do cliente modificado deve ficar assim:
Código Java
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // O endereço IP do servidor a ser conectado é intt = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados no servidor Writer = new OutputStreamWriter (client.getOutputStream ()); writer.Write ("Hello Server."); writer.write ("EOF"); writer.flush (); // Leia após escrever leitor leitor = new inputStreamReader (client.getInputStream ()); chars [] = novo char [64]; int len; StringBuffer sb = new StringBuffer (); Temp de string; índice int; while ((len = leitor.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); quebrar; } sb.append (new string (chars, 0, len)); } System.out.println ("do servidor:" + sb); writer.close (); leitor.close (); client.close (); }}O formulário mais comum que usamos na vida diária é que o cliente envia dados para o servidor e o servidor recebe os dados e retorna os resultados correspondentes ao cliente. No entanto, não há mais um relacionamento único entre o cliente e o servidor, mas a situação em que vários clientes correspondem ao mesmo servidor mencionado abaixo.
3. Vários clientes se conectam ao mesmo servidor
Para os dois exemplos mencionados acima, o servidor termina após receber a solicitação de um cliente e não pode receber solicitações de outros clientes, que geralmente não podem atender aos nossos requisitos. Normalmente fazemos isso:
Código Java
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); enquanto (true) {// o servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Depois de estabelecer uma conexão com o cliente, podemos obter o InputStream do soquete e ler as informações enviadas pelo cliente. Leitor leitor = new inputStreamReader (soket.getInputStream ()); chars [] = novo char [64]; int len; Stringbuilder sb = new stringbuilder (); Temp de string; índice int; while ((len = leitor.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// A recepção é encerrada quando o EOF é encontrado sb.append (temp.substring (0, índice)); quebrar; } sb.append (temp); } System.out.println ("do cliente:" + sb); // Escreva uma frase após a leitura do escritor do Writer = new OatdStreamWriter (Socket.getOutputStream ()); writer.Write ("Hello Client."); writer.flush (); writer.close (); leitor.close (); Socket.Close (); }}} No código acima, usamos um loop morto, onde o ServerSocket chama seu método de aceitação para tentar receber uma solicitação de conexão do cliente. Quando a solicitação não for recebida, o programa bloqueará aqui até receber a solicitação de conexão do cliente e depois se comunicar com o cliente que estabeleceu a conexão. Depois disso, ele executará o corpo do loop e tentará receber uma nova solicitação de conexão novamente. Dessa forma, nosso ServerSocket pode receber solicitações de conexão de todos os clientes e se comunicar com eles. Isso implementa um modo simples de comunicação com vários clientes em um servidor.
No exemplo acima, embora um servidor seja implementado para se comunicar com vários clientes, ainda há um problema. No exemplo acima, nosso servidor lida com a solicitação de conexão do cliente de maneira síncrona. Toda vez que recebemos uma solicitação de conexão do cliente, devemos primeiro nos comunicar com o cliente atual antes de processar a próxima solicitação de conexão. Isso afetará seriamente o desempenho do programa quando houver mais simultaneidade. Por esse motivo, podemos alterá -lo para o seguinte processamento assíncrono de comunicação com o cliente:
Código Java
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); enquanto (true) {// o servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Toda vez que um soquete é recebido, um novo thread é estabelecido para lidar com seu novo thread (nova tarefa (soquete)). Start (); }} / ** * * / classe estática Tarefa implementa Runnable {Socket Socket privado; Tarefa pública (soquete de soquete) {this.socket = soquete; } public void run () {try {handleSocket (); } catch (Exceção e) {e.printStackTrace (); }} / *** Comunique -se com o soquete do cliente* @throws Exception* / private void handlesocket () lança Exceção {leitor leitor = new inputStreamReader (soket.getInputStream ()); chars [] = novo char [64]; int len; Stringbuilder sb = new stringbuilder (); Temp de string; índice int; while ((len = leitor.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// A recepção é encerrada quando o EOF é encontrado sb.append (temp.substring (0, índice)); quebrar; } sb.append (temp); } System.out.println ("do cliente:" + sb); // Escreva uma frase após a leitura do escritor do Writer = new OatdStreamWriter (Socket.getOutputStream ()); writer.Write ("Hello Client."); writer.flush (); writer.close (); leitor.close (); Socket.Close (); }}} No código acima, sempre que o ServerSocket recebe uma nova solicitação de conexão de soquete, um novo thread será gerado para se comunicar com o soquete atual, que alcançará o processamento assíncrono da comunicação com o soquete do cliente.
Ao receber dados do InputStream do soquete, a leitura um pouco como a acima é muito complicada. Às vezes, usaremos o BufferredReader para ler uma linha de cada vez, como:
Código Java
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); enquanto (true) {// o servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Toda vez que um soquete é recebido, um novo thread é estabelecido para lidar com seu novo thread (nova tarefa (soquete)). Start (); }} / ** * * / classe estática Tarefa implementa Runnable {Socket Socket privado; Tarefa pública (soquete de soquete) {this.socket = soquete; } public void run () {try {handleSocket (); } catch (Exceção e) {e.printStackTrace (); }} / *** Comunique -se com o soquete do cliente* @throws Exception* / private void handleSocket () lança Exceção {BufferredReader Br = new BufferredReader (new InputStreamReader (Socket.getInputStream ()); Stringbuilder sb = new stringbuilder (); Temp de string; índice int; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// encerre a recepção quando o EOF é encontrado sb.append (temp.substring (0, índice)); quebrar; } sb.append (temp); } System.out.println ("do cliente:" + sb); // Escreva uma frase após a leitura do escritor do Writer = new OatdStreamWriter (Socket.getOutputStream ()); writer.Write ("Hello Client."); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); Socket.Close (); }}}Neste momento, deve -se notar que o método ReadLine do BufferredReader lê uma linha de cada vez. Este método está bloqueado. O programa não continuará sendo executado até lê uma linha de dados. Então, quando o ReadLine lerá uma linha? O método ReadLine não pensará que foi lido uma linha até que o programa encontre uma nova linha ou o caráter final do fluxo correspondente. Ele terminará seu bloqueio e permitirá que o programa continue a executar. Portanto, quando usamos a linha de leitura do BufferErader para ler os dados, devemos lembrar de escrever quebras de linha no fluxo de saída correspondente (ele será automaticamente marcado como final após o término do fluxo e a linha de leitura pode ser reconhecida). Depois de escrever as quebras da linha, devemos lembrar de descarregar se o fluxo de saída não estiver fechado imediatamente, para que os dados sejam realmente gravados no buffer. Correspondente ao código acima, nosso programa de clientes deve ser escrito assim:
Código Java
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // O endereço IP do servidor a ser conectado é intt = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados no servidor Writer = new OutputStreamWriter (client.getOutputStream ()); writer.Write ("Hello Server."); writer.write ("eof/n"); writer.flush (); // Leia após escrever BufferReader BR = new BufferredReader (new InputStreamReader (client.getInputStream ())); StringBuffer sb = new StringBuffer (); Temp de string; índice int; while ((temp = br.readline ())! = null) {if ((index = temp.indexOf ("eof"))! = -1) {sb.append (temp.substring (0, index)); quebrar; } sb.append (temp); } System.out.println ("do servidor:" + sb); writer.close (); br.close (); client.close (); }}4. Defina o tempo de tempo limite
Suponha que exista tal requisito de que nosso cliente precise obter informações XX do servidor através do soquete e exibi -las para o usuário na página. Sabemos que o soquete está bloqueando ao ler dados e, se você não ler os dados, o programa continuará bloqueando lá. Ao sincronizar a solicitação, não devemos permitir que essa situação aconteça. Isso exige que controlemos a interrupção de bloqueio depois que a solicitação atingir um certo tempo para que o programa possa continuar sendo executado. O Socket nos fornece um método setSotimeout () para definir o tempo de tempo limite dos dados recebidos em milissegundos. Quando o tempo de tempo limite definido for maior que 0 e, após esse período, o soquete não recebeu os dados retornados, o soquete lançará uma SockettimeoutException.
Suponha que precisamos controlar nosso cliente para interromper e bloquear antes de ler os dados por 10 segundos depois de começar a ler os dados, podemos fazer isso:
Código Java
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // O endereço IP do servidor a ser conectado é intt = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados no servidor Writer = new OutputStreamWriter (client.getOutputStream ()); writer.Write ("Hello Server."); writer.write ("eof/n"); writer.flush (); // Leia após escrever BufferReader BR = new BufferredReader (new InputStreamReader (client.getInputStream ())); // Defina o tempo limite para 10 segundos client.SetSotimeout (10*1000); StringBuffer sb = new StringBuffer (); Temp de string; índice int; tente {while ((temp = b.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); quebrar; } sb.append (temp); }} catch (sockettimeoutException e) {System.out.println ("Dados Leia o tempo limite."); } System.out.println ("do servidor:" + sb); writer.close (); br.close (); client.close (); }}5. Receba o código de dados de dados
Para esses casos em que o servidor ou cliente recebe código chinês ilegal, geralmente ocorre porque a codificação usada quando os dados são enviados é inconsistente com a codificação usada quando os dados são recebidos. Por exemplo, existe um código de servidor como este:
Código Java
public class Server {public static void main (string args []) lança IoException {// Para simplificar, todas as informações de exceção são lançadas na porta int = 8899; // Defina um ServerSocket ouvindo na porta 8899 ServerSocket Server = new ServerSocket (porta); enquanto (true) {// o servidor tenta receber solicitações de conexão de outros soquetes. O método de aceitação do servidor é um soquete de bloqueio = server.accept (); // Toda vez que um soquete é recebido, um novo thread é estabelecido para lidar com seu novo thread (nova tarefa (soquete)). Start (); }} / ** * * / classe estática Tarefa implementa Runnable {Socket Socket privado; Tarefa pública (soquete de soquete) {this.socket = soquete; } public void run () {try {handleSocket (); } catch (Exceção e) {e.printStackTrace (); }} / *** Comunique -se com o soquete do cliente* @throws Exception* / private void handleSocket () lança exceção {buffarredreader br = new BufferredReader (new InputStreamReader (soquete.getInputStream (), "gbk"); Stringbuilder sb = new stringbuilder (); Temp de string; índice int; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// recepção final quando o EOF é encontrado sb.append (temp.substring (0, index)); quebrar; } sb.append (temp); } System.out.println ("Client:" + SB); // Escreva uma frase após a leitura do escritor do Writer = new O outputStreamWriter (Socket.getOutputStream (), "UTF-8"); writer.write ("Olá, cliente."); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); Socket.Close (); }}}Estou um pouco confuso quando o usei aqui para testar. No código do servidor acima, definimos claramente o uso da codificação GBK para ler dados ao definir o fluxo de entrada e especificar claramente que o uso da codificação UTF-8 para enviar dados ao definir o fluxo de saída. Se o cliente não enviar dados na codificação de GBK ao enviar dados no cliente, é provável que os dados recebidos pelo servidor sejam distorcidos; Da mesma forma, se o cliente não enviar dados de codificação ao enviar dados no servidor, ou seja, a codificação UTF-8 para receber dados, também é muito provável que os dados ocorram. Portanto, para o código do servidor acima, para permitir que nosso programa leia os dados enviados pela outra parte sem código ilegal, nosso cliente deve ser assim:
Código Java
public class Client {public static void main (string args []) lança exceção {// Para simplificar, todas as exceções são expulsas diretamente String host = "127.0.0.1"; // o endereço IP do servidor a ser conectado int porta = 8899; // a porta de escuta correspondente do servidor a ser conectada // A conexão é estabelecida com o servidor Socket Client = new Socket (host, porta); // Depois de estabelecer a conexão, você pode gravar dados para o servidor Writer = new OutputStreamWriter (client.getOutputStream (), "GBK"); writer.write ("Olá, servidor."); writer.write ("eof/n"); writer.flush (); // Leia depois de escrever BufferReader BR = new BufferredReader (new InputStreamReader (client.getInputStream (), "UTF-8")); // Defina o tempo limite para 10 segundos client.SetSotimeout (10*1000); StringBuffer sb = new StringBuffer (); Temp de string; índice int; tente {while ((temp = b.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); quebrar; } sb.append (temp); }} catch (sockettimeoutException e) {System.out.println ("Dados Leia o tempo limite."); } System.out.println ("Server:" + SB); writer.close (); br.close (); client.close (); }}Este artigo foi compilado em "Resumo das técnicas de operação de upload de Java", e todos são convidados a aprender e ler.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.