Java menulis server dan klien yang dapat mengunggah file. Konten spesifiknya adalah sebagai berikut
Sisi server
Class Server {public static void main (String [] args) melempar Exception {// Buat server socket server ss = server new (10005); // menerima soket klien fileloadersocket = ss.accept (); // Cetak Informasi Koneksi String IP = FileLoadersocket.getInetAddress (). GetHostAddress (); System.out.println (IP + "... Connceected"); // Terima file dan simpan inputStream in = fileloadersocket.getInputStream (); // Instantiate Object FileSave OutputStream FileSave = new FileOutputStream ("e: //3.mp3"); // Buat array buf byte [] buf = byte baru [1024]; int len = 0; // pertahankan apakah akhir file dibaca sementara ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // Refresh filesave.flush (); } // Kembalikan File Informasi Menyalin BufferedWriter out = BufferedWriter baru (outputStreamWriter baru (fileloadersocket.getoutputStream ())); out.write ("File Unggah sukses"); // Refresh out.flush (); // sumber daya tutup ss.close (); fileloadersocket.close (); FileAVE.CLOSE (); }}Klien:
Class Client {public static void main (String [] args) melempar Exception {// Buat soket socket socket fileloadersocket = socket baru ("168.168.168.94", 10005); // Baca file secara lokal dari klien dan tulis ke output output outputStream out = fileloadersocket.getoutputStream (); // instantiate objek filereader inputStream fileread = new fileInputStream ("g: //2.mp3"); // Buat array byte [] buf = byte baru [1024]; int len = 0; // menilai apakah akhir file dibaca sementara ((len = fileread.read (buf))! = -1) {out.write (buf, 0, len); } // Beri tahu server bahwa file tersebut telah ditransfer fileloadersocket.shutdownoutput (); // Dapatkan umpan balik informasi dari server bufferedReader di = BufferedReader baru (inputStreamReader baru (fileloadersocket.getInputStream ())); String serverback = in.readline (); System.out.println (serverback); // sumber daya tutup fileloadersocket.close (); fileread.close (); }}Program berikut disalin langsung dari tempat lain untuk referensi belajar:
Pemrograman Soket Java
Untuk pemrograman soket java, ada dua konsep, satu adalah server dan yang lainnya adalah soket. Server dan klien terhubung melalui soket, dan kemudian mereka dapat berkomunikasi. Pertama, server akan mendengarkan port di server. Ketika ditemukan bahwa klien memiliki soket untuk mencoba menghubungkannya, itu akan menerima permintaan koneksi soket, dan pada saat yang sama membuat soket yang sesuai di server untuk berkomunikasi dengannya. Dengan cara ini, ada dua soket, satu di klien dan satu di server.
Komunikasi antar soket sebenarnya sangat sederhana. Ketika server menulis sesuatu ke dalam aliran output soket, klien dapat membaca konten yang sesuai melalui aliran input soket. Soket dan soket terhubung dalam dua arah, sehingga klien juga dapat menulis hal -hal ke dalam aliran output soket yang sesuai, dan kemudian aliran input soket yang sesuai dari server dapat membacakan konten yang sesuai. Berikut adalah beberapa contoh komunikasi sisi server dengan klien:
1. Penulisan klien dan server baca
Kode Java Server
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); // Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setelah membuat koneksi dengan klien, kami dapat memperoleh inputstream soket dan membaca informasi yang dikirim oleh klien. Reader reader = new InputStreamReader (socket.getInputStream ()); char chars [] = char baru [64]; int len; StringBuilder SB = StringBuilder baru (); while ((len = reader.read (chars))! = -1) {sb.append (string baru (chars, 0, len)); } System.out.println ("Dari Klien:" + SB); reader.close (); socket.close (); server.close (); }}Pengoperasian server untuk membaca data dari inputstream soket juga memblokir. Jika data tidak dibaca dari aliran input, program akan tetap di sana sampai klien menulis data ke dalam aliran output soket atau menutup aliran output soket. Tentu saja, hal yang sama berlaku untuk soket klien. Setelah operasi selesai, ingatlah untuk menutup sumber daya yang sesuai sebelum seluruh program selesai, yaitu, tutup aliran dan soket IO yang sesuai.
Kode Java Klien
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung adalah int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream ()); writer.write ("Hello Server."); writer.flush (); // ingat flush writer.close (); client.close (); }}Saat menulis data ke aliran output soket, Anda harus memperhatikan satu hal. Jika program tidak sesuai dengan shutdown aliran output setelah operasi tulis, tetapi melakukan operasi pemblokiran lainnya (seperti membaca data dari aliran input), ingatlah untuk menyiramnya. Hanya dengan cara ini server dapat menerima data yang dikirim oleh klien, jika tidak, hal itu dapat menyebabkan menunggu tanpa batas satu sama lain. Masalah ini akan disebutkan nanti ketika berbicara tentang klien dan server membaca dan menulis pada saat yang sama.
2. Klien dan server membaca dan menulis secara bersamaan
Seperti disebutkan sebelumnya, soket berkomunikasi dengan cara dua arah, yang dapat menerima data dan mengirim data.
Kode Java Server
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); // Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setelah membuat koneksi dengan klien, kami dapat memperoleh inputstream soket dan membaca informasi yang dikirim oleh klien. Reader reader = new InputStreamReader (socket.getInputStream ()); char chars [] = char baru [64]; int len; StringBuilder SB = StringBuilder baru (); while ((len = reader.read (chars))! = -1) {sb.append (string baru (chars, 0, len)); } System.out.println ("Dari Klien:" + SB); // Tulis kalimat setelah membaca penulisnya penulis = outputStreamWriter baru (socket.getoutputStream ()); writer.write ("Hello Client."); writer.flush (); writer.close (); reader.close (); socket.close (); server.close (); }}Dalam kode di atas, pertama -tama kami membaca data yang dikirim oleh klien dari aliran input, dan kemudian menulis data ke dalam aliran output ke klien, dan kemudian tutup file sumber daya yang sesuai. Bahkan, kode di atas mungkin tidak berjalan dengan cara yang kami asumsikan sebelumnya, karena membaca data dari aliran input adalah operasi pemblokiran. Ketika data dibaca di atas saat loop, badan loop akan dieksekusi, jika tidak itu akan diblokir, sehingga operasi penulisan selanjutnya tidak akan pernah dieksekusi. Loop sementara akan berhenti kecuali soket yang sesuai dari klien ditutup dan diblokir. Solusi untuk situasi ini di mana mungkin tidak pernah dieksekusi adalah bahwa loop sementara harus dilompati secara kondisional. Melihat kode di atas, satu -satunya hal yang berubah adalah len panjang dan data yang dibaca. Len tidak lagi dapat digunakan, dan satu -satunya hal yang dapat digunakan adalah data yang dibaca. Dalam hal ini, kami biasanya menyetujui tag akhir. Ketika data yang dikirim oleh klien berisi tag akhir tertentu, itu berarti bahwa data saat ini telah dikirim, dan pada saat ini kami dapat mengulang. Maka kode yang ditingkatkan akan terlihat seperti ini:
Kode Java
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); // Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setelah membuat koneksi dengan klien, kami dapat memperoleh inputstream soket dan membaca informasi yang dikirim oleh klien. Reader reader = new InputStreamReader (socket.getInputStream ()); char chars [] = char baru [64]; int len; StringBuilder SB = StringBuilder baru (); String temp; indeks int; while ((len = reader.read (chars))! = -1) {temp = string baru (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// Resepsi berakhir ketika EOF ditemui SB.Append (Temp.SubString (0, index)); merusak; } SB.Append (temp); } System.out.println ("Dari Klien:" + SB); // Tulis kalimat setelah membaca penulis penulis = outputStreamWriter baru (socket.getoutputStream ()); writer.write ("Hello Client."); writer.flush (); writer.close (); reader.close (); socket.close (); server.close (); }}Dalam kode di atas, ketika server membaca tanda akhir yang dikirim oleh klien, yaitu, "EOF", penerimaan data akan diakhiri dan loop akan diakhiri, sehingga kode selanjutnya dapat dilanjutkan.
Kode Java Klien
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream ()); writer.write ("Hello Server."); writer.flush (); // Baca setelah menulis pembaca pembaca = inputStreamReader baru (client.getInputStream ()); char chars [] = char baru [64]; int len; StringBuffer SB = StringBuffer baru (); while ((len = reader.read (chars))! = -1) {sb.append (string baru (chars, 0, len)); } System.out.println ("Dari Server:" + SB); writer.close (); reader.close (); client.close (); }}Dalam kode di atas, pertama -tama kami mengirim sepotong data ke server, dan kemudian membaca data yang dikembalikan oleh server. Seperti server sebelumnya, ini dapat menyebabkan program menggantung di sana sepanjang waktu dan tidak pernah melompat keluar dari loop sementara. Kode ini dikombinasikan dengan kode pertama server, biarkan kami menganalisis bahwa server akan selalu menerima data di sana, dan tidak akan pernah melompat keluar dari loop sementara, sehingga tidak akan ada server berikutnya untuk mengembalikan data ke klien, dan klien tidak akan dapat menerima data yang dikembalikan oleh server. Solusinya ditampilkan dalam kode kedua server. Setelah klien mengirimkan data, tulis tanda ujung ke aliran output untuk memberi tahu server bahwa data telah dikirim. Server juga mengirimkan tanda untuk memberi tahu klien setelah data dikembalikan. Maka kode klien yang dimodifikasi akan terlihat seperti ini:
Kode Java
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung adalah int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream ()); writer.write ("Hello Server."); writer.write ("eof"); writer.flush (); // Baca setelah menulis pembaca pembaca = inputStreamReader baru (client.getInputStream ()); char chars [] = char baru [64]; int len; StringBuffer SB = StringBuffer baru (); String temp; indeks int; while ((len = reader.read (chars))! = -1) {temp = string baru (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); merusak; } sb.append (string baru (chars, 0, len)); } System.out.println ("Dari Server:" + SB); writer.close (); reader.close (); client.close (); }}Bentuk paling umum yang kami gunakan dalam kehidupan sehari -hari adalah bahwa klien mengirimkan data ke server, dan server menerima data dan mengembalikan hasil yang sesuai kepada klien. Namun, tidak ada lagi hubungan satu-ke-satu antara klien dan server, tetapi situasi di mana banyak klien sesuai dengan server yang sama seperti yang disebutkan di bawah ini.
3. Beberapa klien terhubung ke server yang sama
Untuk dua contoh yang disebutkan di atas, server berakhir setelah menerima permintaan klien dan tidak dapat menerima permintaan dari klien lain, yang seringkali tidak dapat memenuhi persyaratan kami. Biasanya kami melakukan ini:
Kode Java
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); while (true) {// Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setelah membuat koneksi dengan klien, kami dapat memperoleh inputstream soket dan membaca informasi yang dikirim oleh klien. Reader reader = new InputStreamReader (socket.getInputStream ()); char chars [] = char baru [64]; int len; StringBuilder SB = StringBuilder baru (); String temp; indeks int; while ((len = reader.read (chars))! = -1) {temp = string baru (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// Resepsi berakhir ketika EOF ditemui SB.Append (Temp.SubString (0, index)); merusak; } SB.Append (temp); } System.out.println ("Dari Klien:" + SB); // Tulis kalimat setelah membaca penulis penulis = outputStreamWriter baru (socket.getoutputStream ()); writer.write ("Hello Client."); writer.flush (); writer.close (); reader.close (); socket.close (); }}} Dalam kode di atas, kami menggunakan loop dead, di mana ServerSocket memanggil metode penerimaannya untuk mencoba menerima permintaan koneksi dari klien. Ketika permintaan tidak diterima, program akan diblokir di sini sampai menerima permintaan koneksi dari klien, dan kemudian berkomunikasi dengan klien yang telah membuat koneksi. Setelah itu, kemudian akan menjalankan badan loop dan mencoba menerima permintaan koneksi baru lagi. Dengan cara ini server kami dapat menerima permintaan koneksi dari semua klien dan berkomunikasi dengan mereka. Ini mengimplementasikan mode komunikasi sederhana dengan banyak klien di satu server.
Dalam contoh di atas, meskipun satu server diimplementasikan untuk berkomunikasi dengan banyak klien, masih ada masalah. Dalam contoh di atas, server kami menangani permintaan koneksi klien secara serempak. Setiap kali kami menerima permintaan koneksi dari klien, pertama -tama kami harus berkomunikasi dengan klien saat ini sebelum kami dapat memproses permintaan koneksi berikutnya. Ini akan secara serius mempengaruhi kinerja program ketika ada lebih banyak konkurensi. Untuk alasan ini, kita dapat mengubahnya menjadi pemrosesan komunikasi asinkron berikut dengan klien:
Kode Java
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); while (true) {// Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setiap kali soket diterima, utas baru ditetapkan untuk menangani utas baru (tugas baru (soket)). Start (); }} / **? tugas publik (soket soket) {this.socket = socket; } public void run () {coba {handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Berkomunikasi dengan soket klien* @throws Exception* / private void handlesocket () melempar pengecualian {reader reader = inputStreamReader baru (socket.getInputStream ()); char chars [] = char baru [64]; int len; StringBuilder SB = StringBuilder baru (); String temp; indeks int; while ((len = reader.read (chars))! = -1) {temp = string baru (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// Resepsi berakhir ketika EOF ditemui SB.Append (Temp.SubString (0, index)); merusak; } SB.Append (temp); } System.out.println ("Dari Klien:" + SB); // Tulis kalimat setelah membaca penulis penulis = outputStreamWriter baru (socket.getoutputStream ()); writer.write ("Hello Client."); writer.flush (); writer.close (); reader.close (); socket.close (); }}} Dalam kode di atas, setiap kali ServerSocket menerima permintaan koneksi soket baru, utas baru akan dihasilkan untuk berkomunikasi dengan soket saat ini, yang akan mencapai pemrosesan komunikasi asinkron dengan soket klien.
Saat menerima data dari InputStream Socket, membaca sedikit seperti di atas terlalu rumit. Terkadang kita akan menggunakan BufferedReader untuk membaca satu baris pada satu waktu, seperti:
Kode Java
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); while (true) {// Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setiap kali soket diterima, utas baru ditetapkan untuk menangani utas baru (tugas baru (soket)). Start (); }} / **? tugas publik (soket soket) {this.socket = socket; } public void run () {coba {handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Berkomunikasi dengan soket klien* @throws Exception* / private void handlesocket () melempar Exception {bufferedReader br = new buferedReader (inputStreamReader baru (socket.getInputStream ())); StringBuilder SB = StringBuilder baru (); String temp; indeks int; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexOf ("eof"))! = -1) {// Akhiri resepsi ketika EOF ditemui SB.Append (temp.substring (0, index)); merusak; } SB.Append (temp); } System.out.println ("Dari Klien:" + SB); // Tulis kalimat setelah membaca penulis penulis = outputStreamWriter baru (socket.getoutputStream ()); writer.write ("Hello Client."); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); socket.close (); }}}Pada saat ini, perlu dicatat bahwa metode readline dari BufferedReader membaca satu baris pada satu waktu. Metode ini diblokir. Program tidak akan terus mengeksekusi sampai membaca satu baris data. Jadi kapan Readline akan membaca baris? Metode readline tidak akan berpikir bahwa itu telah dibaca satu baris sampai program menemukan garis baru atau karakter akhir dari aliran yang sesuai. Ini akan mengakhiri penyumbatannya dan membiarkan program terus mengeksekusi. Oleh karena itu, ketika kami menggunakan BufferedReader's Readline untuk membaca data, kita harus ingat untuk menulis jeda garis dalam aliran output yang sesuai (akan secara otomatis ditandai sebagai akhir setelah aliran berakhir, dan readline dapat dikenali). Setelah menulis garis istirahat, kita harus ingat untuk menyiram jika aliran output tidak segera ditutup, sehingga data akan benar -benar ditulis dari buffer. Sesuai dengan kode di atas, program klien kami harus ditulis seperti ini:
Kode Java
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung adalah int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream ()); writer.write ("Hello Server."); writer.write ("eof/n"); writer.flush (); // Baca Setelah Menulis BufferedReader BR = BufferedReader baru (inputStreamReader baru (client.getInputStream ())); StringBuffer SB = StringBuffer baru (); String temp; indeks int; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); merusak; } SB.Append (temp); } System.out.println ("Dari Server:" + SB); writer.close (); br.close (); client.close (); }}4. Tetapkan waktu batas waktu
Misalkan ada persyaratan sehingga klien kami perlu mendapatkan informasi xx dari server melalui soket dan kemudian menampilkannya kepada pengguna di halaman. Kami tahu bahwa soket memblokir saat membaca data, dan jika Anda tidak membaca data, program akan terus memblokir di sana. Saat menyinkronkan permintaan, kita tidak boleh membiarkan situasi seperti itu terjadi. Ini mengharuskan kami untuk mengontrol interupsi pemblokiran setelah permintaan mencapai waktu tertentu sehingga program dapat terus berjalan. Socket memberi kami metode setSoTimeout () untuk mengatur waktu batas waktu dari data yang diterima dalam milidetik. Ketika waktu batas waktu yang ditetapkan lebih besar dari 0 dan setelah ini soket belum menerima data yang dikembalikan, soket akan melempar socketTimeOutException.
Misalkan kita perlu mengontrol klien kita untuk mengganggu dan memblokir sebelum membaca data selama 10 detik setelah mulai membaca data, kita dapat melakukan ini:
Kode Java
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung adalah int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream ()); writer.write ("Hello Server."); writer.write ("eof/n"); writer.flush (); // Baca Setelah Menulis BufferedReader BR = BufferedReader baru (inputStreamReader baru (client.getInputStream ())); // atur timeout ke 10 detik klien.setsoTimeout (10*1000); StringBuffer SB = StringBuffer baru (); String temp; indeks int; coba {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); merusak; } SB.Append (temp); }} catch (SocketTimeOutException e) {System.out.println ("Data Read Timeout."); } System.out.println ("Dari Server:" + SB); writer.close (); br.close (); client.close (); }}5. Menerima Data Kode Kelahiran
Untuk kasus seperti itu ketika server atau klien menerima kode Cina yang kacau, biasanya karena pengkodean yang digunakan ketika data dikirim tidak konsisten dengan pengkodean yang digunakan saat data diterima. Misalnya, ada kode server seperti ini:
Kode Java
Server kelas publik {public static void main (string args []) melempar ioException {// untuk kesederhanaan, semua informasi pengecualian dibuang int port = 8899; // Tentukan server yang mendengarkan di port 8899 server server = server baru (port); while (true) {// Server mencoba menerima permintaan koneksi dari soket lain. Metode penerimaan server adalah soket soket pemblokiran = server.accept (); // Setiap kali soket diterima, utas baru ditetapkan untuk menangani utas baru (tugas baru (soket)). Start (); }} / **? tugas publik (soket soket) {this.socket = socket; } public void run () {coba {handlesocket (); } catch (Exception e) {E.PrintStackTrace (); }} / *** Berkomunikasi dengan soket klien* @throws Exception* / private void handlesocket () melempar Exception {bufferedReader br = new buferedReader (inputStreamReader baru (socket.getInputStream (), "gbk")); StringBuilder SB = StringBuilder baru (); String temp; indeks int; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// resepsi akhir ketika EOF ditemui SB.Append (Temp.SubString (0, index)); merusak; } SB.Append (temp); } System.out.println ("Klien:" + SB); // Tulis kalimat setelah membaca penulis penulis = outputStreamWriter baru (socket.getoutputStream (), "UTF-8"); writer.write ("Halo, klien."); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); socket.close (); }}}Saya sedikit bingung ketika saya menggunakannya di sini untuk pengujian. Dalam kode server di atas, kami dengan jelas mendefinisikan penggunaan pengkodean GBK untuk membaca data saat mendefinisikan aliran input, dan dengan jelas menentukan bahwa penggunaan pengkodean UTF-8 untuk mengirim data saat mendefinisikan aliran output. Jika klien tidak mengirim data dalam pengkodean GBK saat mengirim data pada klien, data yang diterima oleh server kemungkinan akan kacau; Demikian pula, jika klien tidak mengirim pengkodean data saat mengirim data di server, yaitu, pengkodean UTF-8 untuk menerima data, juga sangat mungkin bahwa data yang kacau akan terjadi. Oleh karena itu, untuk kode server di atas, untuk memungkinkan program kami membaca data yang dikirim oleh pihak lain tanpa kode yang kacau, klien kami harus seperti ini:
Kode Java
klien kelas publik {public static void main (string args []) melempar pengecualian {// untuk kesederhanaan, semua pengecualian dibuang secara langsung host = "127.0.0.1"; // Alamat IP server yang akan terhubung int port = 8899; // port mendengarkan yang sesuai dari server yang akan terhubung // koneksi dibuat dengan klien server soket = soket baru (host, port); // Setelah membuat koneksi, Anda dapat menulis data ke penulis server penulis = outputStreamWriter baru (client.getoutputStream (), "gbk"); writer.write ("Halo, server."); writer.write ("eof/n"); writer.flush (); // Baca Setelah Menulis BufferedReader BR = BufferedReader baru (inputStreamReader baru (client.getInputStream (), "UTF-8")); // atur timeout ke 10 detik klien.setsoTimeout (10*1000); StringBuffer SB = StringBuffer baru (); String temp; indeks int; coba {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); merusak; } SB.Append (temp); }} catch (SocketTimeOutException e) {System.out.println ("Data Read Timeout."); } System.out.println ("Server:" + SB); writer.close (); br.close (); client.close (); }}Artikel ini telah dikompilasi menjadi "Ringkasan Teknik Operasi Upload Java", dan semua orang dipersilakan untuk belajar dan membaca.
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.