Alguns pontos que precisam ser claros sobre a comunicação TCP:
A comunicação TCP é orientada para a conexão e você precisa iniciar o servidor primeiro e depois iniciar o cliente.
O cliente e o servidor devem criar objetos de soquete. O cliente precisa especificar o soquete do servidor (porta IP+) e o servidor deve especificar a porta de serviço.
Socket client_socket = new Socket ("192.168.100.17", 8888); // soquete do cliente (o soquete da classe de soquete é um soquete conectado) serversocket listen_socket = new ServerSocket (8888); // soquete do servidor, neste momento, é o soquete de escuta (o endereço e a porta foram limitados ())O servidor precisa usar o método Acep () para converter o soquete de escuta em um soquete conectado. Esse soquete de escuta pode gerar vários soquetes conectados, para que você também possa ouvir solicitações de outros clientes após a conexão. Portanto, o acesso simultâneo deve ser implementado usando o Multithreading aqui. Depois de obter o soquete conectado, você pode obter muitas informações do cliente, como o endereço IP do cliente, a porta onde a solicitação é enviada, etc.
Socket Server_SCOKET = SOCKET.ACECT (); Socket Server_Scoket2 = Socket.Acept (); Socket Server_Scoket3 = Socket.accept ();
Para implementar conexões simultâneas no servidor, use aproximadamente o seguinte código: onde o ThreadTask é um objeto de tarefa do thread.
public static void main (string [] args) lança ioexception {serversocket listen_sock = new ServerSocket (8888); // Somente um é necessário para ouvir o soquete; portanto, enquanto (verdadeiro) fora da tarefa {// sempre que uma conexão é estabelecida, um thread é aberto. Soket conn_sock = ouvice_sock.accept (); // Quando nenhuma nova conexão entra, o thread principal principal bloqueia esse novo thread (novo ThreadTask (conn_sock)). Start (); }}O cliente precisa obter o fluxo de saída com base no soquete conectado e o servidor precisa obter o fluxo de entrada com base no soquete. Obviamente, como existe um soquete conectado, você pode obter o fluxo de entrada e o fluxo de saída em qualquer extremidade.
OutputStream send_stream = client_socket.getOutputStream (); // O cliente obtém o fluxo de saída inputStream recv_stream = server_socket.getInputStream ();
O servidor deve fechar ativamente o soquete conectado e o soquete de escuta deve ser fechado no local apropriado.
O servidor deve ser responsável por recebê -lo continuamente.
Cliente simples:
importar java.io.ioException; importar java.io.OutputStream; importar java.net.socket; public classe tcpclient {public static void main (string [] args) {// 1. Crie soquete do cliente c_sock = null; OutputStream client_outstream = null; tente {c_sock = new Socket ("192.168.0.124", 8888); // 2. Obter fluxo de saída client_outstream = c_sock.getOutputStream (); // 3. Dados de saída client_outstream.write ("Olá, estou vindo" .getBytes ()); } catch (ioexception e) {e.printStackTrace (); } finalmente {if (c_sock! = null) {tente {c_sock.close (); } catch (ioexception e) {e.printStackTrace (); }}}}}}Lado simples do servidor:
importar java.io.bufferedReader; importar java.io.ioException; importar java.io.inputStream; importar java.io.inputStreamReader; importar java.net.Serversocket; importar java.net.socket; public class; tente {escute_sock = new ServerSocket (8888); } catch (ioexception i) {i.printStackTrace (); } Socket Server_sock = null; InputStream in_sock = null; while (true) {tente {// 2. Estabeleça uma conexão com o cliente, gere um soquete conectado e obtenha o endereço IP do cliente server_sock = outing_sock.accept (); String client_ip = server_sock.getineTAddress (). Gethostaddress (); System.out.println ("client:" + client_ip + "conectado"); // 3. Obtenha o fluxo de entrada com base no soquete conectado e leia os dados enviados pelo cliente in_sock = server_sock.getInputStream (); BUBLEREDREADER BUFR = new BufferredReader (new InputStreamReader (in_sock)); Linha de string = null; while ((line = bufr.readline ())! = null) {System.out.println (line); } // 4. Feche o soquete conectado server_sock.close (); } catch (ioexception e) {e.printStackTrace (); }}}}A seguir, é apresentada a função de upload do arquivo TCP:
Além do fluxo de saída do soquete, o cliente também possui o fluxo de entrada que lê arquivos locais e o fluxo de entrada do soquete para ler as informações de feedback do servidor.
O servidor também possui três fluxos: fluxos de entrada e saída de soquete e gravar para fazer upload de arquivos de destino.
Depois que o cliente lê todos os dados do arquivo local, ele precisa usar o desligamento do soquete () para notificar o servidor de que o fluxo de saída do soquete chegou ao final.
Para fornecer funções de upload para várias pessoas, o servidor precisa usar vários threads para implementar conexões simultâneas.
Cliente:
importar java.io.bufferedReader; importar java.io.fileInputStream; importar java.io.ioException; importar java.io.inputStream; importar java.io.inputStreamReader; importar) argclient; Método gerado automaticamente Stub String server_addr = "192.168.0.124"; int server_port = 8888; Soquete send_sock = null; FileInputStream local_read = null; tente {// 1. Setor do cliente send_sock = new Socket (server_addr, server_port); // 2. Obtenha o fluxo de saída do pipeline de conexão outputStream send_stream = send_sock.getOutputStream (); // 3. Fluxo de entrada de byte lê dados de arquivo local e usa o fluxo de saída do soquete para enviar local_read = new FileInputStream ("d: /myjava/net/sql.docx"); byte [] buf = novo byte [1024]; int len = 0; while ((len = local_read.read (buf))! = -1) {send_stream.write (buf, 0, len); } // 4. Marque o fluxo de saída no final send_sock.shutdownoutput (); // 5. Receba dados de feedback do servidor, como fazer upload de sucesso, fazer upload de falha, etc. inputStream recv_stream = send_sock.getInputStream (); BufferredReader ack_recv = new bufferredreader (new InputStreamReader (RECV_STREAM)); Linha de string = null; while ((line = ack_recv.readline ())! = null) {System.out.println (linha); }} catch (ioexception i) {i.printStackTrace (); } finalmente {if (send_sock! = null) {tente {send_sock.close (); local_read.close (); } catch (ioexception i1) {i1.printStackTrace (); }} if (local_read! = null) {tente {local_read.close (); } catch (ioexception i2) {i2.printStackTrace (); }}}}}}Lado do servidor:
importar java.io.file; importar java.io.fileOutputStream; importar java.io.ioException; importar java.io.inputStream; importar java.io.OutputStream; importar java.net.Serversocket; out_sock = new ServerSocket (8888); // Somente um é necessário para ouvir o soquete; portanto, enquanto (true) {// sempre que uma conexão é estabelecida, um thread é iniciado. Soket conn_sock = ouvice_sock.accept (); // Quando nenhuma nova conexão entra, os principais threads principais blocos aqui novos threads (novo uploader (conn_sock)). Start (); }}} classe Uploader implementa Runnable {Private File Dest_dir = new File ("D:/Temp"); // upload de soquete privado do diretório Conn_sock = null; // conecta o soquete inputStream recv_stream = null; FileOutputStream dest_stream = null; Uploader (soquete conn_sock) lança ioexception {this.conn_sock = conn_sock; } public void run () {try {if (! Dest_dir.exists ()) {dest_dir.mkdirs (); } // 1. Obtenha o fluxo de entrada conectando o pipeline recv_stream = conn_sock.getInputStream (); // cliente IP String client_ip = conn_sock.getineTAddress (). Gethostaddress (); System.out.println (client_ip + "..... conectado"); // 2. O local de upload do arquivo, ou seja, o alvo de saída, é nomeado após o IP. Se o arquivo já existir, crie um novo arquivo com colchetes e números, como "192.168.100.23 (1) .txt" arquivo dest_file = novo arquivo (dest_dir, client_ip + ".docx"); int count = 1; while (dest_file.exists ()) {dest_file = novo arquivo (dest_dir, client_ip + "(" + count + ")" + ".docx"); contagem ++; } // 3. Leia os dados e escreva no arquivo de destino dest_stream = new FileOutputStream (dest_file); byte [] buf = novo byte [1024]; int len = 0; while ((len = recv_stream.read (buf))! = -1) {dest_stream.write (buf, 0, len); } // 4. Informações de feedback para o cliente outputStream ack_send = conn_sock.getOutputStream (); byte [] text = "Upload bem -sucedido!". getBytes (); ack_send.write (texto); } catch (ioexception e1) {e1.printStackTrace (); } finalmente {if (dest_stream! = null) {try {dest_stream.close (); } catch (ioexception i) {i.printStackTrace (); }} if (conn_sock! = null) {tente {conn_sock.close (); } catch (ioexception i) {i.printStackTrace (); }}}}}}Os exemplos acima da comunicação TCP e a função simples de upload de arquivos da programação de rede Java são todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.