Beberapa poin yang perlu jelas tentang komunikasi TCP:
Komunikasi TCP berorientasi pada koneksi, dan Anda perlu memulai server terlebih dahulu dan kemudian memulai klien.
Baik klien dan server harus membuat objek soket. Klien perlu menentukan soket server (port IP+), dan server harus menentukan port layanan.
Socket client_socket = soket baru ("192.168.100.17", 8888); // soket klien (soket kelas soket adalah soket yang terhubung) Serversocket listen_socket = server baru (8888); // Soket server, saat ini, soket mendengarkan (alamat dan port telah terikat ())Server perlu menggunakan metode penerimaan () untuk mengubah soket mendengarkan menjadi soket yang terhubung. Soket mendengarkan ini dapat menghasilkan beberapa soket yang terhubung, sehingga Anda juga dapat mendengarkan permintaan dari klien lain setelah koneksi. Oleh karena itu, akses bersamaan harus diimplementasikan menggunakan multithreading di sini. Setelah mendapatkan soket yang terhubung, Anda dapat memperoleh banyak informasi klien, seperti alamat IP klien, port tempat permintaan dikirim, dll.
Socket server_scoket = socket.accept (); socket server_scoket2 = socket.accept (); socket server_scoket3 = socket.accept ();
Untuk mengimplementasikan koneksi bersamaan di server, secara kasar gunakan kode berikut: di mana threadTask adalah objek tugas utas.
public static void main (string [] args) melempar ioException {serversocket listen_sock = server baru (8888); // Hanya satu yang diperlukan untuk mendengarkan soket, jadi sementara (benar) di luar tugas {// setiap kali koneksi dibuat, utas dibuka. Socket conn_sock = listen_sock.accept (); // Ketika tidak ada koneksi baru masuk, utas utama utama memblokir utas baru ini (threadTask baru (conn_sock)). Start (); }}Klien perlu mendapatkan aliran output berdasarkan soket yang terhubung, dan server perlu mendapatkan aliran input berdasarkan soket. Tentu saja, karena ada soket yang terhubung, Anda bisa mendapatkan aliran input dan aliran output di ujung mana pun.
OutputStream send_stream = client_socket.getoutputStream (); // Klien memperoleh aliran output inputStream recv_stream = server_socket.getInputStream ();
Server harus secara aktif menutup soket yang terhubung, dan soket mendengarkan harus ditutup di tempat yang sesuai.
Server harus bertanggung jawab untuk menerimanya terus menerus.
Klien Sederhana:
impor java.io.ioException; impor java.io.outputStream; impor java.net.socket; kelas publik tcpclient {public static void main (string [] args) {// 1. Buat soket klien soket c_sock = null; OutputStream client_outstream = null; coba {c_sock = soket baru ("192.168.0.124", 8888); // 2. Dapatkan aliran output client_outstream = c_sock.getoutputStream (); // 3. Output data klien_outstream.write ("Halo, saya datang" .getbytes ()); } catch (ioException e) {e.printstacktrace (); } akhirnya {if (c_sock! = null) {coba {c_sock.close (); } catch (ioException e) {e.printstacktrace (); }}}}}}Sisi server sederhana:
impor java.io.bufferedReader; import java.io.ioException; impor java.io.inputstream; import java.io.inputStreamReader; import java.net.serversocket; sangkar public main (public {public class {public static Main (string (] {public class tcpserver {public static void void Main listen_sock = null; coba {listen_sock = server baru (8888); } catch (ioException i) {i.printstacktrace (); } Socket server_sock = null; Inputstream in_sock = null; while (true) {coba {// 2. Buat koneksi dengan klien, hasilkan soket yang terhubung, dan dapatkan alamat IP klien server_sock = listen_sock.accept (); String client_ip = server_sock.getInetAddress (). GetHostAddress (); System.out.println ("Client:" + Client_ip + "Connected"); // 3. Dapatkan aliran input berdasarkan soket yang terhubung, dan baca data yang dikirim oleh klien in_sock = server_sock.getInputStream (); BufferedReader bufr = baru bufferedReader (inputStreamReader baru (in_sock)); Garis string = null; while ((line = bufr.readline ())! = null) {System.out.println (line); } // 4. Tutup socket server_sock.close (); } catch (ioException e) {e.printstacktrace (); }}}}Berikut ini adalah fungsi Upload File TCP:
Selain aliran output soket, klien juga memiliki aliran input yang membaca file lokal, dan aliran input soket untuk membaca informasi umpan balik dari server.
Server juga memiliki tiga aliran: input soket dan aliran output, dan menulis untuk mengunggah file target.
Setelah klien membaca semua data dari file lokal, ia perlu menggunakan shutdownoutput soket () untuk memberi tahu server bahwa aliran output soket telah mencapai ujungnya.
Untuk menyediakan fungsi pengunggahan untuk banyak orang, server perlu menggunakan banyak utas untuk mengimplementasikan koneksi bersamaan.
Klien:
impor java.io.bufferedreader; impor java.io.fileInputStream; impor java.io.ioexception; impor java.io.inputStream; Maindo (Impor publon {publicclea {publicclion {publicclion {publicclion {publicclion {publiccleM; Metode yang dihasilkan otomatis string string server_addr = "192.168.0.124"; int server_port = 8888; Socket send_sock = null; FileInputStream local_read = null; coba {// 1. Socket klien send_sock = soket baru (server_addr, server_port); // 2. Dapatkan aliran output dari pipa koneksi outputStream send_stream = send_sock.getoutputStream (); // 3. Byte Input Stream membaca data file lokal dan menggunakan aliran output soket untuk mengirimkan local_read = FileInputStream baru ("d: /myjava/net/sql.docx"); byte [] buf = byte baru [1024]; int len = 0; while ((len = local_read.read (buf))! = -1) {send_stream.write (buf, 0, len); } // 4. Tandai aliran output ke end send_sock.shutdownoutput (); // 5. Menerima data umpan balik dari server, seperti mengunggah yang berhasil, mengunggah kegagalan, dll. InputStream recv_stream = send_sock.getInputStream (); BufferedReader ACK_RECV = BufferedReader baru (inputStreamReader baru (recv_stream)); Garis string = null; while ((line = ack_recv.readline ())! = null) {System.out.println (line); }} catch (ioException i) {i.printstacktrace (); } akhirnya {if (send_sock! = null) {coba {send_sock.close (); local_read.close (); } catch (ioException i1) {i1.printstacktrace (); }} if (local_read! = null) {coba {local_read.close (); } catch (ioException i2) {i2.printstacktrace (); }}}}}}Sisi server:
impor java.io.file; impor java.io.fileoutputStream; impor java.io.ioException; impor java.io.inputStream; Java.io.outputStream; impor java.net.servercocket; Import void store.net. ServerSocket listen_sock = New ServerSocket (8888); // Hanya satu yang diperlukan untuk mendengarkan soket, jadi sementara (true) {// setiap kali koneksi dibuat, utas dimulai. Socket conn_sock = listen_sock.accept (); // Ketika tidak ada koneksi baru masuk, benang utama utama blok di sini utas baru (pengunggah baru (conn_sock)). Start (); }}} class unggah mengimplementasikan runnable {private file dest_dir = file baru ("d:/temp"); // Unggah direktori soket pribadi conn_sock = null; // Hubungkan socket inputStream recv_stream = null; FileOutputStream dest_stream = null; Unggah (socket conn_sock) melempar ioException {this.conn_sock = conn_sock; } public void run () {coba {if (! dest_dir.exists ()) {dest_dir.mkdirs (); } // 1. Dapatkan aliran input yang menghubungkan pipa recv_stream = conn_sock.getInputStream (); // klien ip string client_ip = conn_sock.getInetAddress (). GetHostAddress (); System.out.println (client_ip + "..... terhubung"); // 2. Lokasi unggahan file, yaitu target output, dinamai IP. Jika file sudah ada, buat file baru dengan tanda kurung dan angka, seperti "192.168.100.23 (1) .txt" file dest_file = file baru (dest_dir, client_ip + ".docx"); Int count = 1; while (dest_file.exists ()) {dest_file = file baru (dest_dir, client_ip + "(" + count + ")" + ".docx"); Count ++; } // 3. Baca data dan tulis ke file target dest_stream = fileoutputStream baru (dest_file); byte [] buf = byte baru [1024]; int len = 0; while ((len = recv_stream.read (buf))! = -1) {dest_stream.write (buf, 0, len); } // 4. Informasi Umpan Balik ke Klien OutputStream ACK_SEND = conn_sock.getoutputStream (); byte [] text = "Unggah sukses!". getBytes (); Ack_send.write (teks); } catch (ioException e1) {e1.printstacktrace (); } akhirnya {if (dest_stream! = null) {coba {dest_stream.close (); } catch (ioException i) {i.printstacktrace (); }} if (conn_sock! = null) {coba {conn_sock.close (); } catch (ioException i) {i.printstacktrace (); }}}}}}Contoh komunikasi TCP di atas dan fungsi unggahan file sederhana dari pemrograman jaringan Java adalah semua konten yang saya bagikan dengan Anda. Saya harap Anda dapat memberi Anda referensi dan saya harap Anda dapat mendukung wulin.com lebih lanjut.