Menulis kode yang dijalankan pada perangkat tertentu sangat memuaskan. Namun, menulis kode yang dijalankan pada beberapa perangkat yang berkomunikasi satu sama lain benar-benar menguatkan kehidupan. Artikel ini akan mengajarkan Anda cara menghubungkan dan bertukar pesan melalui jaringan menggunakan protokol kontrol transmisi (TCP).
Pada artikel ini, Anda akan menyiapkan aplikasi yang akan menghubungkan komputer Anda ke dirinya sendiri dan, pada dasarnya, membuatnya gila - berbicara dengan dirinya sendiri. Anda juga akan mempelajari perbedaan antara dua aliran yang paling banyak digunakan untuk jaringan di Java dan bagaimana fungsinya.
Aliran Data dan Objek
Sebelum menyelami kode, perbedaan antara dua aliran yang digunakan dalam artikel perlu dibedakan.
Aliran Data
Aliran data memproses tipe dan string data primitif. Data yang dikirim melalui aliran data perlu diserialisasikan dan dideserialisasi secara manual yang membuatnya lebih sulit untuk mentransfer data yang kompleks. Namun, aliran data dapat berkomunikasi dengan server dan klien yang ditulis dalam bahasa lain selain Java. Aliran mentah mirip dengan aliran data dalam aspek itu, tetapi aliran data memastikan data diformat dengan cara platform independen yang bermanfaat karena kedua belah pihak akan dapat membaca data yang dikirim.
Aliran Objek
Aliran objek memproses tipe data primitif dan objek yang mengimplementasikan
Serializable
antarmuka. Data yang dikirim melalui aliran objek secara otomatis diserialisasi dan dideserialisasi yang membuatnya lebih mudah untuk mentransfer data yang kompleks. Namun, aliran objek hanya dapat berkomunikasi dengan server dan klien yang ditulis dalam Java. Juga,
ObjectOutputStream
setelah inisialisasi, mengirimkan header ke
InputStream
dari pihak lain yang, setelah inisialisasi, memblokir eksekusi hingga header diterima.
Langkah
Langkah 1. Buat kelas
Buat kelas dan beri nama sesuka Anda. Dalam artikel ini, itu akan diberi nama
ContohAplikasi Jaringan
NetworkAppExample kelas publik {}
Langkah 2. Buat metode utama
Buat metode utama dan nyatakan itu mungkin melempar pengecualian dari
Pengecualian
ketik dan setiap subkelasnya - semua pengecualian. Ini dianggap sebagai praktik yang buruk, tetapi dapat diterima untuk contoh barebone.
public class NetworkAppExample { public static void main(String args) melempar Pengecualian { } }
Langkah 3. Deklarasikan alamat server
Contoh ini akan menggunakan alamat host lokal dan nomor port arbitrer. Nomor port harus dalam kisaran 0 hingga 65535 (inklusif). Namun, nomor port yang harus dihindari berkisar dari 0 hingga 1023 (inklusif) karena merupakan port sistem yang dicadangkan.
public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; } }
Langkah 4. Buat server
Server terikat ke alamat dan port dan mendengarkan koneksi masuk. Di Jawa,
ServerSocket
mewakili titik akhir sisi server dan fungsinya menerima koneksi baru.
ServerSocket
tidak memiliki aliran untuk membaca dan mengirim data karena tidak mewakili koneksi antara server dan klien.
impor java.net. InetAddress; impor java.net. ServerSocket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); } }
Langkah 5. Log awal server
Untuk tujuan pencatatan, cetak ke konsol bahwa server telah dimulai.
impor java.net. InetAddress; impor java.net. ServerSocket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); } }
Langkah 6. Buat klien
Klien terikat ke alamat dan port server dan mendengarkan paket (pesan) setelah koneksi dibuat. Di Jawa,
Stopkontak
mewakili titik akhir sisi klien yang terhubung ke server atau koneksi (dari server) ke klien dan digunakan untuk berkomunikasi dengan pihak di ujung lainnya.
impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); } }
Langkah 7. Coba koneksi log
Untuk tujuan pencatatan, cetak ke konsol bahwa koneksi telah dicoba.
impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); } }
Langkah 8. Buat koneksi
Klien tidak akan pernah terhubung kecuali server mendengarkan dan menerima, dengan kata lain membuat, koneksi. Di Jawa, koneksi dibuat menggunakan
menerima()
metode dari
ServerSocket
kelas. Metode ini akan memblokir eksekusi hingga klien terhubung.
impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); } }
Langkah 9. Log koneksi yang dibuat
Untuk tujuan pencatatan, cetak ke konsol bahwa koneksi antara server dan klien telah dibuat.
impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); } }
Langkah 10. Siapkan aliran komunikasi
Komunikasi dilakukan melalui aliran dan, dalam aplikasi ini, aliran mentah (koneksi dari) server (ke klien) dan klien perlu dirantai ke aliran data atau objek. Ingat, kedua belah pihak harus menggunakan jenis aliran yang sama.
-
Aliran data
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); } }
-
Aliran objek
Ketika beberapa aliran objek digunakan, aliran input harus diinisialisasi dalam urutan yang sama dengan aliran output karena:
ObjectOutputStream
mengirimkan header ke pihak lain dan
ObyekInputStream
memblokir eksekusi hingga membaca header.
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); } }
Urutan seperti yang ditentukan dalam kode di atas mungkin lebih mudah diingat - pertama-tama inisialisasi aliran keluaran kemudian aliran masukan dalam urutan yang sama. Namun, urutan lain untuk inisialisasi aliran objek adalah sebagai berikut:
ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
Langkah 11. Catat bahwa komunikasi sudah siap
Untuk tujuan pencatatan, cetak ke konsol bahwa komunikasi sudah siap.
// kode dihilangkan import java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); // kode dihilangkan System.out.println("Komunikasi siap."); } }
Langkah 12. Buat pesan
Dalam aplikasi ini,
Halo Dunia
teks akan dikirim ke server baik sebagai
byte
atau
Rangkaian
. Mendeklarasikan variabel dari jenis yang bergantung pada aliran yang digunakan. Menggunakan
byte
untuk aliran data dan
Rangkaian
untuk aliran objek.
-
Aliran data
Menggunakan aliran data, serialisasi dilakukan dengan mengubah objek menjadi tipe data primitif atau a
Rangkaian
. Pada kasus ini,
Rangkaian
diubah menjadi
byte
alih-alih ditulis menggunakan
tulisByte()
metode untuk menunjukkan bagaimana hal itu akan dilakukan dengan objek lain, seperti gambar atau file lain.
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); byte messageOut = "Halo Dunia".getBytes(); } }
-
Aliran objek
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); String pesanOut = "Halo Dunia"; } }
Langkah 13. Kirim pesan
Tulis data ke aliran keluaran dan siram aliran untuk memastikan data telah ditulis seluruhnya.
-
Aliran data
Panjang pesan harus dikirim terlebih dahulu sehingga pihak lain tahu berapa banyak byte yang perlu dibaca. Setelah panjang dikirim sebagai tipe integer primitif, byte dapat dikirim.
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); byte messageOut = "Halo Dunia".getBytes(); clientOut.writeInt(messageOut.length); clientOut.write(messageOut); clientOut.flush(); } }
-
Aliran objek
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); String pesanOut = "Halo Dunia"; clientOut.writeObject(messageOut); clientOut.flush(); } }
Langkah 14. Log pesan terkirim
Untuk tujuan pencatatan, cetak ke konsol bahwa pesan telah dikirim.
-
Aliran data
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); byte messageOut = "Halo Dunia".getBytes(); clientOut.writeInt(messageOut.length); clientOut.write(messageOut); clientOut.flush(); System.out.println("Pesan dikirim ke server: " + new String(messageOut)); } }
-
Aliran objek
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); String pesanOut = "Halo Dunia"; clientOut.writeObject(messageOut); clientOut.flush(); System.out.println("Pesan terkirim ke server: " + messageOut); } }
Langkah 15. Baca pesannya
Baca data dari aliran input dan konversikan. Karena kami tahu persis jenis data yang dikirim, kami akan membuat
Rangkaian
dari
byte
atau pemeran
Obyek
ke
Rangkaian
tanpa memeriksa, tergantung pada aliran yang digunakan.
-
Aliran data
Karena panjang dikirim terlebih dahulu dan byte sesudahnya, pembacaan harus dilakukan dalam urutan yang sama. Jika panjangnya nol, tidak ada yang bisa dibaca. Objek dideserialisasi ketika byte diubah kembali menjadi instance, dalam hal ini, dari
Rangkaian
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); byte messageOut = "Halo Dunia".getBytes(); clientOut.writeInt(messageOut.length); clientOut.write(messageOut); clientOut.flush(); System.out.println("Pesan dikirim ke server: " + new String(messageOut)); int panjang = serverIn.readInt(); if (panjang > 0) { byte messageIn = byte baru[panjang]; serverIn.readFully(messageIn, 0, messageIn.length); } } }
-
Aliran objek
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); String pesanOut = "Halo Dunia"; clientOut.writeObject(messageOut); clientOut.flush(); System.out.println("Pesan terkirim ke server: " + messageOut); String messageIn = (String) serverIn.readObject(); } }
Langkah 16. Masuk pesan baca
Untuk tujuan pencatatan, cetak ke konsol bahwa pesan telah diterima dan cetak isinya.
-
Aliran data
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); DataOutputStream clientOut = new DataOutputStream(client.getOutputStream()); DataInputStream clientIn = new DataInputStream(client.getInputStream()); DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream()); DataInputStream serverIn = new DataInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); byte messageOut = "Halo Dunia".getBytes(); clientOut.writeInt(messageOut.length); clientOut.write(messageOut); clientOut.flush(); System.out.println("Pesan dikirim ke server: " + new String(messageOut)); int panjang = serverIn.readInt(); if (panjang > 0) { byte messageIn = byte baru[panjang]; serverIn.readFully(messageIn, 0, messageIn.length); System.out.println("Pesan diterima dari klien: " + new String(messageIn)); } } }
-
Aliran objek
impor java.io. ObjectInputStream; impor java.io. ObjectOutputStream; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream()); ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream()); ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream()); ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream()); System.out.println("Komunikasi siap."); String pesanOut = "Halo Dunia"; clientOut.writeObject(messageOut); clientOut.flush(); System.out.println("Pesan terkirim ke server: " + messageOut); String messageIn = (String) serverIn.readObject(); System.out.println("Pesan diterima dari klien: " + messageIn); } }
Langkah 17. Putuskan koneksi
Koneksi terputus ketika salah satu pihak menutup alirannya. Di Java, dengan menutup aliran output, soket terkait dan aliran input juga ditutup. Setelah pihak di ujung lain mengetahui koneksi mati, ia perlu menutup aliran outputnya, juga, untuk mencegah kebocoran memori.
// kode dihilangkan import java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); // kode dihilangkan System.out.println("Komunikasi siap."); // kode dihilangkan clientOut.close(); serverOut.close(); } }
Langkah 18. Pemutusan log
Untuk tujuan pencatatan, koneksi cetak ke konsol telah diputuskan.
// kode dihilangkan import java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); // kode dihilangkan System.out.println("Komunikasi siap."); // kode dihilangkan clientOut.close(); serverOut.close(); System.out.println("Koneksi ditutup."); } }
Langkah 19. Hentikan server
Koneksi terputus, tetapi server masih aktif dan berjalan. Sebagai
ServerSocket
tidak terkait dengan aliran apa pun, itu perlu ditutup secara eksplisit dengan memanggil
Menutup()
metode.
// kode dihilangkan import java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); // kode dihilangkan System.out.println("Komunikasi siap."); // kode dihilangkan clientOut.close(); serverOut.close(); System.out.println("Koneksi ditutup."); server.tutup(); } }
Langkah 20. Log penghentian server
Untuk tujuan pencatatan, pencetakan ke server konsol telah dihentikan.
// kode dihilangkan import java.net. InetAddress; impor java.net. ServerSocket; impor java.net. Socket; public class NetworkAppExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; ServerSocket server = ServerSocket baru(port, 50, InetAddress.getByName(host)); System.out.println("Server dimulai."); Klien soket = Soket baru (host, port); System.out.println("Koneksi ke server…"); Koneksi soket = server.accept(); System.out.println("Koneksi berhasil."); // kode dihilangkan System.out.println("Komunikasi siap."); // kode dihilangkan clientOut.close(); serverOut.close(); System.out.println("Koneksi ditutup."); server.tutup(); System.out.println("Server dihentikan."); } }
Langkah 21. Kompilasi dan jalankan
Logging memungkinkan kami untuk mengetahui apakah aplikasi berhasil atau tidak. Keluaran yang diharapkan:
Server dimulai. Menghubungkan ke server… Koneksi dibuat. Komunikasi sudah siap. Pesan dikirim ke server: Hello World Pesan diterima dari klien: Hello World Connections ditutup. Server dihentikan.
Jika output Anda tidak seperti di atas, yang kemungkinan tidak akan terjadi, ada beberapa solusi:
-
Jika output berhenti di garis
Koneksi dibuat.
dan aliran objek digunakan, siram masing-masing
ObjectOutputStream
- segera setelah inisialisasi karena header, untuk beberapa alasan, tidak terkirim.
-
Jika output dicetak
java.net. BindException: Alamat sudah digunakan
- pilih nomor port yang berbeda karena yang ditentukan sudah digunakan.
Tips
- Menghubungkan ke server di jaringan yang berbeda dilakukan dengan menghubungkan ke alamat IP eksternal perangkat yang menjalankan server yang memiliki port yang diteruskan.
- Menghubungkan ke server di jaringan yang sama dilakukan dengan menghubungkan ke alamat IP pribadi perangkat yang menjalankan server atau meneruskan port dan menghubungkan ke alamat IP eksternal perangkat.
- Ada perangkat lunak, seperti Hamachi, yang memungkinkan koneksi ke server di jaringan yang berbeda tanpa meneruskan port, tetapi memerlukan instalasi perangkat lunak di kedua perangkat.
Contoh
Aplikasi jaringan yang menggunakan input/output pemblokiran perlu menggunakan utas. Contoh berikut menunjukkan implementasi server dan klien minimalis dengan utas. Kode jaringan pada dasarnya sama seperti di artikel kecuali beberapa cuplikan disinkronkan, dipindahkan ke utas dan pengecualian ditangani.
Server.java
impor java.io. IOException; impor java.net. InetAddress; impor java.net. ServerSocket; impor java.net. SocketException; impor java.net. UnknownHostException; impor java.util. ArrayList; impor java.util. Koleksi; impor java.util. List; /** * Kelas {@code Server} mewakili titik akhir server dalam jaringan. {@code Server} setelah terikat ke alamat dan port IP * tertentu, membuat koneksi dengan klien dan dapat berkomunikasi dengan mereka atau memutuskan hubungan mereka. *
* Kelas ini adalah threadsafe. * * @versi 1.0 * @lihat Klien * @lihat Koneksi */ kelas publik Server mengimplementasikan Runnable { server ServerSocket pribadi; daftar pribadi
koneksi; utas utas pribadi; koneksi Objek akhir pribadiLock = objek baru(); /** * Membangun {@code Server} yang berinteraksi dengan klien pada nama host dan port yang ditentukan dengan panjang maksimum antrian klien masuk yang * yang diminta. * * @param host Alamat host yang akan digunakan. * @param port Nomor port yang akan digunakan. * @param backlog Meminta panjang maksimum antrian klien yang masuk. * @throws NetworkException Jika terjadi kesalahan saat memulai server. */ Public Server(String host, int port, int backlog) throws NetworkException { try { server = new ServerSocket(port, backlog, InetAddress.getByName(host)); } catch (UnknownHostException e) { throw new NetworkException("Nama host tidak dapat diselesaikan: " + host, e); } catch (IllegalArgumentException e) { throw new NetworkException("Nomor port harus antara 0 dan 65535 (termasuk): " + port); } catch (IOException e) { throw new NetworkException("Server tidak dapat dijalankan.", e); } koneksi = Collections.synchronizedList(new ArrayList()); utas = Utas baru (ini); utas.mulai(); } /** * Membuat {@code Server} yang berinteraksi dengan klien pada nama dan port host yang ditentukan. * * @param host Alamat host untuk mengikat. * @param port Nomor port untuk diikat. * @throws NetworkException Jika terjadi kesalahan saat memulai server. */ Server publik(String host, int port) melempar NetworkException { this(host, port, 50); } /** * Mendengarkan, menerima, dan mendaftarkan koneksi masuk dari klien. */ @Override public void run() { while (!server.isClosed()) { coba { koneksi.add(Koneksi baru(server.accept())); } catch (SocketException e) { if (!e.getMessage().equals("Socket ditutup")) { e.printStackTrace(); } } catch (NetworkException | IOException e) { e.printStackTrace(); } } } /** * Mengirim data ke semua klien yang terdaftar. * * @param data Data yang akan dikirim. * @throws IllegalStateException Jika penulisan data dicoba saat server offline. * @throws IllegalArgumentException Jika data yang dikirim adalah null. */ public void broadcast(Data objek) { if (server.isClosed()) { throw new IllegalStateException("Data tidak terkirim, server offline."); } if (data == null) { throw new IllegalArgumentException("null data"); } disinkronkan (connectionsLock) { untuk (Koneksi koneksi: koneksi) { coba { connection.send(data); System.out.println("Data berhasil dikirim ke klien."); } catch (NetworkException e) { e.printStackTrace(); } } } } /** * Mengirim pesan pemutusan dan memutuskan klien tertentu. * * Koneksi @param Klien untuk memutuskan sambungan. * @throws NetworkException Jika terjadi kesalahan saat menutup koneksi. */ public void disconnect(Connection connection) throws NetworkException { if (connections.remove(connection)) { connection.close(); } } /** * Mengirim pesan pemutusan ke semua klien, memutuskan hubungan mereka dan menghentikan server. */ public void close() throws NetworkException { sinkron (connectionsLock) { for (Koneksi koneksi: koneksi) { try { connection.close(); } catch (NetworkException e) { e.printStackTrace(); } } } koneksi.clear(); coba { server.close(); } catch (IOException e) { throw new NetworkException("Error saat menutup server."); } akhirnya { thread.interrupt(); } } /** * Mengembalikan apakah server online atau tidak. * * @return Benar jika server online. Salah, sebaliknya. */ public boolean isOnline() { kembali !server.isClosed(); } /** * Mengembalikan array klien terdaftar. */ Koneksi publik getConnections() { tersinkronisasi (connectionsLock) { mengembalikan koneksi.toArray(Koneksi baru[koneksi.ukuran()]); } } }
klien.java
impor java.io. IOException; impor java.net. Socket; impor java.net. UnknownHostException; /** * Kelas {@code Client} mewakili titik akhir klien dalam jaringan. {@code Client}, setelah terhubung ke server * tertentu, dijamin hanya dapat berkomunikasi dengan server. Apakah klien lain menerima data * atau tidak tergantung pada implementasi server. *
* Kelas ini adalah threadsafe. * * @versi 1.0 * @lihat Server * @lihat Koneksi */ kelas publik Klien { koneksi Koneksi pribadi; /** * Membangun {@code Client} yang terhubung ke server pada host dan port yang ditentukan. * * @param host Alamat host untuk mengikat. * @param port Nomor port untuk diikat. * @throws NetworkException Jika terjadi kesalahan saat memulai server. */ Public Client(String host, int port) throws NetworkException { try { connection = new Connection(new Socket(host, port)); } catch (UnknownHostException e) { throw new NetworkException("Nama host tidak dapat diselesaikan: " + host, e); } catch (IllegalArgumentException e) { throw new NetworkException("Nomor port harus antara 0 dan 65535 (termasuk): " + port); } catch (IOException e) { throw new NetworkException("Server tidak dapat dijalankan.", e); } } /** * Mengirim data ke pihak lain. * * @param data Data yang akan dikirim. * @throws NetworkException Jika menulis ke aliran keluaran gagal. * @throws IllegalStateException Jika mencoba menulis data saat koneksi ditutup. * @throws IllegalArgumentException Jika data yang dikirim adalah null. * @throws UnsupportedOperationException Jika tipe data yang tidak didukung dicoba untuk dikirim. */ public void send(Object data) throws NetworkException { connection.send(data); } /** * Mengirim pesan pemutusan ke, dan menutup koneksi dengan, server. */ public void close() melempar NetworkException { connection.close(); } /** * Mengembalikan apakah klien terhubung ke server atau tidak. * * @return Benar jika klien terhubung. Salah, sebaliknya. */ public boolean isOnline() { mengembalikan koneksi.isConnected(); } /** * Mengembalikan instance {@link Connection} dari klien. */ koneksi publik getConnection() { koneksi kembali; } }
Connection.java
impor java.io. DataInputStream; impor java.io. DataOutputStream; impor java.io. IOException; impor java.net. Socket; impor java.net. SocketException; /** * Kelas {@code Connection} mewakili koneksi dari server ke klien atau titik akhir klien dalam jaringan * {@code Connection}, setelah terhubung, dapat bertukar data dengan pihak atau pihak lain, tergantung pada implementasi server *. *
* Kelas ini adalah threadsafe. * * @versi 1.0 * @lihat Server * @lihat Klien */ kelas publik Koneksi mengimplementasikan Runnable { soket soket pribadi; DataOutputStream keluar pribadi; DataInputStream pribadi di; utas utas pribadi; private final Object writeLock = new Object(); private terakhir Obyek readLock = new Object(); /** * Membangun {@code Connection} menggunakan aliran {@link Socket} yang ditentukan. * * @param socket Socket untuk mengambil aliran.*/ Public Connection(Socket socket) throws NetworkException { if (socket == null) { throw new IllegalArgumentException("null socket"); } this.socket = soket; coba { out = new DataOutputStream(socket.getOutputStream()); } catch (IOException e) { throw new NetworkException("Tidak dapat mengakses aliran keluaran.", e); } coba { di = new DataInputStream(socket.getInputStream()); } catch (IOException e) { throw new NetworkException("Tidak dapat mengakses aliran input.", e); } utas = Utas baru (ini); utas.mulai(); } /** * Membaca pesan saat koneksi dengan pihak lain masih hidup. */ @Override public void run() { while (!socket.isClosed()) { try { int identifier; byte byte; disinkronkan (readLock) { pengenal = in.readInt(); int panjang = in.readInt(); if (panjang > 0) { byte = byte baru[panjang]; in.readFully(bytes, 0, bytes.length); } lain { lanjutkan; } } switch (pengidentifikasi) { case Identifier. INTERNAL: String command = new String(bytes); if (command.equals("disconnect")) { if (!socket.isClosed()) { System.out.println("Paket pemutusan diterima."); coba { tutup(); } catch (NetworkException e) { kembali; } } } merusak; case Identifier. TEXT: System.out.println("Pesan diterima: " + new String(byte)); merusak; default: System.out.println("Data tidak dikenal diterima."); } } catch (SocketException e) { if (!e.getMessage().equals("Socket ditutup")) { e.printStackTrace(); } } catch (IOException e) { e.printStackTrace(); } } } /** * Mengirim data ke pihak lain. * * @param data Data yang akan dikirim. * @throws NetworkException Jika menulis ke aliran keluaran gagal. * @throws IllegalStateException Jika mencoba menulis data saat koneksi ditutup. * @throws IllegalArgumentException Jika data yang dikirim adalah null. * @throws UnsupportedOperationException Jika tipe data yang tidak didukung dicoba untuk dikirim. */ public void send(Object data) throws NetworkException { if (socket.isClosed()) { throw new IllegalStateException("Data tidak terkirim, koneksi ditutup."); } if (data == null) { throw new IllegalArgumentException("null data"); } int pengenal; byte byte; if (data instanceof String) { identifier = Identifier. TEXT; byte = ((String) data).getBytes(); } else { throw new UnsupportedOperationException("Tipe data tidak didukung: " + data.getClass()); } coba { sinkron (writeLock) { out.writeInt(identifier); out.writeInt(bytes.length); keluar.tulis(byte); keluar.flush(); } } catch (IOException e) { throw new NetworkException("Data tidak dapat dikirim.", e); } } /** * Mengirim pesan pemutusan ke, dan menutup koneksi dengan, pihak lain. */ public void close() throws NetworkException { if (socket.isClosed()) { throw new IllegalStateException("Koneksi sudah ditutup."); } coba { byte pesan = "putuskan".getBytes(); disinkronkan (writeLock) { out.writeInt(Identifier. INTERNAL); out.writeInt(pesan.panjang); keluar.tulis(pesan); keluar.flush(); } } catch (IOException e) { System.out.println("Pesan pemutusan tidak dapat dikirim."); } coba { disinkronkan (writeLock) { out.close(); } } catch (IOException e) { throw new NetworkException("Error saat menutup koneksi.", e); } akhirnya { thread.interrupt(); } } /** * Mengembalikan apakah koneksi ke pihak lain hidup atau tidak. * * @return Benar jika koneksi hidup. Salah, sebaliknya. */ public boolean isConnected() { kembali !socket.isClosed(); } }
pengenal.java
/** * Kelas {@code Identifier} berisi konstanta yang digunakan oleh {@link Connection} untuk membuat serial dan deserializing data * yang dikirim melalui jaringan. * * @versi 1.0 * @lihat Connection */ public final class Identifier { /** * Identifier untuk pesan internal. */ public static final int INTERNAL = 1; /** * Pengenal untuk pesan tekstual. */ public static final int TEXT = 2; }
NetworkException.java
/** * Kelas {@code NetworkException} menunjukkan kesalahan yang terkait dengan jaringan. */ public class NetworkException extends Exception { /** * Membangun {@code NetworkException} dengan {@code null} sebagai pesannya. */ public NetworkException() { } /** * Membuat {@code NetworkException} dengan pesan yang ditentukan. * * @param message Pesan untuk menjelaskan kesalahan. */ public NetworkException(Pesan string) { super(pesan); } /** * Membuat {@code NetworkException} dengan pesan dan penyebab yang ditentukan. * * @param message Pesan untuk menjelaskan kesalahan. * @param menyebabkan Penyebab kesalahan. */ public NetworkException(String message, Throwable cause) { super(message, cause); } /** * Membuat {@code NetworkException} dengan penyebab yang ditentukan. * * @param penyebab Penyebab kesalahan. */ public NetworkException(Penyebab yang dapat dibuang) { super(penyebab); } }
Contoh Penggunaan.java
/** * Kelas {@code UsageExample} menunjukkan penggunaan {@link Server} dan {@link Client}. Contoh ini menggunakan * {@link Thread#sleep(long)} untuk memastikan setiap segmen dieksekusi karena memulai dan menutup dengan cepat menyebabkan beberapa * segmen tidak dieksekusi. * * @versi 1.0 * @lihat Server * @lihat Klien */ public class UsageExample { public static void main(String args) throws Exception { String host = "localhost"; int port = 10430; Server server = Server baru (host, port); Klien klien = Klien baru (host, port); Thread.sleep(100L); client.send("Halo."); server.broadcast("Hai, sobat!"); Thread.sleep(100L); server.disconnect(server.getConnections()[0]); // atau client.close() untuk memutuskan sambungan dari server sisi klien.close(); } }
