Algunos puntos que deben ser claros sobre la comunicación TCP:
La comunicación TCP está orientada a la conexión, y debe iniciar primero el servidor y luego iniciar el cliente.
Tanto el cliente como el servidor deben crear objetos de socket. El cliente debe especificar el Servidor Socket (Puerto IP+), y el servidor debe especificar el puerto de servicio.
Socket client_socket = new Socket ("192.168.100.17", 8888); // Cliente Socket (el socket de la clase de socket es un socket conectado) Serversocket Learch_socket = new Serversocket (8888); // SOCKECHE, en este momento, es el socket de audición (la dirección y el puerto han sido vinculados ())El servidor debe usar el método Acept () para convertir el enchufe de audición en un socket conectado. Este enchufe de escucha puede generar múltiples enchufes conectados, para que también pueda escuchar las solicitudes de otros clientes después de la conexión. Por lo tanto, el acceso concurrente debe implementarse utilizando múltiples lecturas aquí. Después de obtener el socket conectado, puede obtener mucha información del cliente, como la dirección IP del cliente, el puerto donde se envía la solicitud, etc.
Socket server_scoket = Socket.accept (); Socket server_scoket2 = Socket.accept (); Socket server_scoket3 = Socket.accept ();
Para implementar conexiones concurrentes en el servidor, use aproximadamente el siguiente código: donde ThreadTask es un objeto de tarea de Thread.
public static void main (string [] args) lanza IOException {Serversocket Learch_sock = new Serversocket (8888); // Solo se requiere uno para escuchar el socket, por lo que mientras (verdadero) fuera de la tarea {// Cada vez que se establece una conexión, se abre un hilo. Socket conn_sock = escuchar_sock.accept (); // Cuando no entra una nueva conexión, el subproceso principal bloquea este nuevo hilo (nuevo ThreadTask (Conn_sock)). Start (); }}El cliente debe obtener la secuencia de salida en función del enchufe conectado, y el servidor debe obtener la secuencia de entrada basada en el socket. Por supuesto, dado que hay un enchufe conectado, puede obtener la secuencia de entrada y la secuencia de salida en cualquier extremo.
OutputStream send_stream = client_socket.getOutputStream (); // El cliente obtiene la transmisión de salida InputStream Recv_stream = server_socket.getInputStream ();
El servidor debe cerrar activamente el enchufe conectado, y el enchufe de escucha debe cerrarse en el lugar apropiado.
El servidor debe ser responsable de recibirlo continuamente.
Cliente simple:
import java.io.ioException; import java.io.outputstream; import java.net.socket; public class tcpClient {public static void main (string [] args) {// 1. Cree socket de socket de cliente c_sock = null; OutputStream Client_outStream = null; intente {c_sock = new Socket ("192.168.0.124", 8888); // 2. Obtener la transmisión de salida client_outstream = c_sock.getOutputStream (); // 3. Datos de salida client_outstream.write ("Hola, estoy llegando" .getBytes ()); } catch (ioException e) {E.PrintStackTrace (); } finalmente {if (c_sock! = null) {try {c_sock.close (); } catch (ioException e) {E.PrintStackTrace (); }}}}}}Lado del servidor simple:
import java.io.bufferedReader; import java.io.ioException; import java.io.inputstream; import java.io.inputstreamreader; import java.net.serversocket; import java.net.socket; public class tcPserver {public static void main (args) {// 1. CREATE A LISTEY SOUCKECKECKECKEK intente {escuchar_sock = new ServerSocket (8888); } catch (ioException i) {i.printstackTrace (); } Socket server_sock = null; InputStream in_sock = null; while (true) {try {// 2. Establezca una conexión con el cliente, genere un socket conectado y obtenga la dirección IP del cliente server_sock = escucha_sock.accept (); Cadena client_ip = server_sock.getInetAddress (). Gethostaddress (); System.out.println ("Client:" + Client_ip + "Connected"); // 3. Obtenga el flujo de entrada basado en el socket conectado y lea los datos enviados por el cliente en_sock = server_sock.getInputStream (); BufferedReader bufr = new BufferedReader (new InputStreamReader (in_sock)); Línea de cadena = nulo; while ((línea = bufr.readline ())! = null) {system.out.println (línea); } // 4. Cierre el socket conectado servidor_sock.close (); } catch (ioException e) {E.PrintStackTrace (); }}}}La siguiente es la función de carga de archivo TCP:
Además de la transmisión de salida de socket, el cliente también tiene la secuencia de entrada que lee archivos locales y el flujo de entrada de socket para leer la información de comentarios del servidor.
El servidor también tiene tres transmisiones: transmisión de entrada y salida de socket, y escribe para cargar archivos de destino.
Después de que el cliente lee todos los datos del archivo local, debe usar el encendido de Socket () para notificar al servidor que la secuencia de salida del socket ha alcanzado el final.
Para proporcionar funciones de carga para varias personas, el servidor debe usar múltiples subprocesos para implementar conexiones concurrentes.
Cliente:
import java.io.bufferedReader; import java.io.fileinputstream; import java.io.ioException; import java.io.inputstream; import java.io.inputstreamreamreader; import java.io.outputStream; import java.net.net; public class owloadClient {public static vhats (string [] [] args; Método generado automático stub string server_addr = "192.168.0.124"; int server_port = 8888; Socket send_sock = null; FileInputStream local_read = null; Pruebe {// 1. Client Socket sock_sock = new Socket (server_addr, server_port); // 2. Obtenga la secuencia de salida de la salida de la tubería de conexión Send_stream = send_sock.getOutputStream (); // 3. El flujo de entrada de byte lee los datos del archivo local y utiliza la transmisión de salida del socket para enviar local_read = nuevo fileInputStream ("d: /myjava/net/sql.docx"); byte [] buf = nuevo byte [1024]; int len = 0; while ((len = local_read.read (buf))! = -1) {send_stream.write (buf, 0, len); } // 4. Marque la transmisión de salida al final send_sock.shutdodoutput (); // 5. Reciba datos de retroalimentación del servidor, como cargar una falla exitosa y de carga, etc. InputStream Recv_stream = send_sock.getInputStream (); BufferedReader ack_recv = new BufferedReader (new InputStreamReader (Recv_stream)); Línea de cadena = nulo; while ((line = ack_recv.readline ())! = null) {system.out.println (línea); }} catch (ioException i) {i.printstacktrace (); } Finalmente {if (send_sock! = null) {try {send_sock.close (); local_read.close (); } catch (ioException i1) {i1.printStackTrace (); }} if (local_read! = null) {try {local_read.close (); } catch (ioException i2) {i2.printstackTrace (); }}}}}}Lado del servidor:
import java.io.file; import java.io.fileOutputStream; import java.io.ioexception; import java.io.inputstream; import java.io.ioutputstream; import java.net.serversocke; import java.net.socket; public classserServer {public static void main (String [] shishsock; = nuevo ServerSocket (8888); // Solo se requiere uno para escuchar el socket, por lo que mientras (verdadero) {// Cada vez que se establece una conexión, se inicia un hilo. Socket conn_sock = escuchar_sock.accept (); // Cuando no entra una nueva conexión, el subproceso principal bloquea aquí el nuevo subproceso (nuevo cargador (conn_sock)). Start (); }}} class SupeLloader implementa Runnable {archivo privado dest_dir = nuevo archivo ("d:/temp"); // cargar directorio socket privado conn_sock = null; // Conecte el socket inputStream recv_stream = null; FileOutputStream des_stream = null; Suboader (Socket Conn_sock) lanza ioexception {this.conn_sock = conn_sock; } public void run () {try {if (! dest_dir.exists ()) {dest_dir.mkdirs (); } // 1. Obtenga la secuencia de entrada que conecta la tubería recv_stream = conn_sock.getInputStream (); // Client IP String Client_ip = Conn_sock.getInetAddress (). GetHostAdDress (); System.out.println (client_ip + "..... conectado"); // 2. La ubicación de carga del archivo, es decir, el objetivo de salida, lleva el nombre de IP. Si el archivo ya existe, cree un nuevo archivo con soportes y números, como "192.168.100.23 (1) .txt" archivo dest_file = nuevo archivo (dest_dir, client_ip + ".docx"); int count = 1; while (dest_file.exists ()) {dest_file = new File (dest_dir, client_ip + "(" + count + ")" + ".docx"); contar ++; } // 3. Lea los datos y escriba en el archivo de destino dest_stream = new FileOutputStream (Dest_File); byte [] buf = nuevo byte [1024]; int len = 0; while ((len = recv_stream.read (buf))! = -1) {dest_stream.write (buf, 0, len); } // 4. Información de retroalimentación para el cliente OutputStream ACK_SEND = CONN_SOCK.GETOUTPUTStream (); byte [] text = "¡Cargue exitoso!". 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) {try {conn_sock.close (); } catch (ioException i) {i.printstackTrace (); }}}}}}Los ejemplos anteriores de la comunicación TCP y la función de carga simple de archivos de la programación de red Java son todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.