Sockets

Apa itu Soket?

Biasanya, server berjalan pada komputer tertentu dan memiliki soket yang terikat ke nomor port tertentu. Server hanya menunggu, mendengarkan soket untuk klien untuk membuat permintaan koneksi.
Di sisi klien: Klien tahu nama host dari mesin yang menjalankan server dan nomor port di mana server mendengarkan. Untuk membuat permintaan koneksi, klien mencoba untuk bertemu dengan server pada mesin dan port server. Klien juga perlu mengidentifikasi dirinya ke server sehingga mengikat ke nomor port lokal yang akan digunakan selama koneksi ini. Ini biasanya ditugaskan oleh sistem.

Jika semuanya berjalan dengan baik, server menerima koneksi. Setelah diterima, server mendapatkan soket baru yang terikat ke port lokal yang sama dan juga memiliki endpoint jarak jauh yang diatur ke alamat dan port klien. Diperlukan soket baru sehingga dapat terus mendengarkan soket asli untuk permintaan koneksi sambil merawat kebutuhan klien yang terhubung.

Di sisi klien, jika koneksi diterima, soket berhasil dibuat dan klien dapat menggunakan soket untuk berkomunikasi dengan server.
Klien dan server sekarang dapat berkomunikasi dengan menulis ke atau membaca dari soket mereka.

---

Definisi:
Soket adalah salah satu titik akhir dari tautan komunikasi dua arah antara dua program yang berjalan di jaringan. Soket terikat ke nomor port sehingga lapisan TCP dapat mengidentifikasi aplikasi tempat data akan dikirim.

---

Endpoint adalah kombinasi dari alamat IP dan nomor port. Setiap koneksi TCP dapat diidentifikasi secara unik oleh dua titik akhir. Dengan begitu Anda dapat memiliki beberapa koneksi antara host dan server.
Paket java.net di platform Java menyediakan kelas, Socket , yang mengimplementasikan satu sisi koneksi dua arah antara program Java Anda dan program lain di jaringan. Kelas Socket berada di atas implementasi yang bergantung pada platform, menyembunyikan detail sistem apa pun dari program Java Anda. Dengan menggunakan kelas java.net.Socket alih-alih mengandalkan kode asli, program Java Anda dapat berkomunikasi melalui jaringan dengan cara yang bebas platform.
Selain itu, java.net menyertakan kelas ServerSocket , yang mengimplementasikan soket yang dapat digunakan server untuk mendengarkan dan menerima koneksi ke klien. Pelajaran ini menunjukkan kepada Anda bagaimana menggunakan kelas Socket dan ServerSocket .
Jika Anda mencoba untuk terhubung ke Web, kelas URL dan kelas terkait ( URLConnection , URLEncoder ) mungkin lebih sesuai daripada kelas soket. Faktanya, URL adalah koneksi tingkat tinggi ke Web dan menggunakan soket sebagai bagian dari implementasi yang mendasarinya. Lihat Bekerja dengan URL untuk informasi tentang menghubungkan ke Web melalui URL.

 

Membaca dari dan Menulis ke Soket

Mari kita lihat contoh sederhana yang menggambarkan bagaimana suatu program dapat membangun koneksi ke program server menggunakan kelas Socket dan kemudian, bagaimana klien dapat mengirim data ke dan menerima data dari server melalui soket. Contoh program mengimplementasikan klien, EchoClient , yang menghubungkan ke server gema. Server gema menerima data dari kliennya dan mengulanginya kembali. Contoh EchoServer mengimplementasikan server gema. (Atau, klien dapat terhubung ke host yang mendukung Protokol Echo .) Contoh EchoClient membuat soket, sehingga mendapatkan koneksi ke server gema. Bunyinya input dari pengguna pada aliran input standar, dan kemudian meneruskan teks itu ke server gema dengan menulis teks ke soket. Server menggaungkan input kembali melalui soket ke klien. Program klien membaca dan menampilkan data yang dikembalikan ke sana dari server. Perhatikan bahwa contoh EchoClient menulis dan membaca dari soketnya, sehingga mengirim data ke dan menerima data dari server gema. Mari kita berjalan melalui program dan menyelidiki bagian-bagian yang menarik. Pernyataan berikut dalam pernyataan try -dengan-sumber daya dalam contoh EchoClient sangat penting. Baris-baris ini membangun koneksi socket antara klien dan server dan membuka PrintWriter dan BufferedReader pada socket:

 String hostName = args [0];
 int portNumber = Integer.parseInt (args [1]);

 coba (
     Socket echoSocket = Socket baru (hostName, portNumber);
     PrintWriter out =
         PrintWriter baru (echoSocket.getOutputStream (), true);
     BufferedReader di =
         BufferedReader baru (
             InputStreamReader baru (echoSocket.getInputStream ()));
     BufferedReader stdIn =
         BufferedReader baru (
             InputStreamReader baru (System.in))
 )

Pernyataan pertama dalam try dengan pernyataan sumber daya membuat objek Socket baru dan echoSocket nama echoSocket . Konstruktor Socket digunakan di sini memerlukan nama komputer dan nomor port yang ingin Anda sambungkan. Program contoh menggunakan argumen baris perintah pertama sebagai nama komputer (nama host) dan argumen baris perintah kedua sebagai nomor port. Ketika Anda menjalankan program ini di komputer Anda, pastikan bahwa nama host yang Anda gunakan adalah nama IP komputer yang memenuhi syarat yang ingin Anda sambungkan. Misalnya, jika server gema Anda berjalan di komputer echoserver.example.com dan sedang mendengarkan pada port nomor 7, pertama jalankan perintah berikut dari komputer echoserver.example.com jika Anda ingin menggunakan contoh EchoServer sebagai gema Anda server:

 java EchoServer 7

Setelah itu, jalankan contoh EchoClient dengan perintah berikut:

 java EchoClient echoserver.example.com 7

Pernyataan kedua dalam pernyataan try -dengan sumber daya mendapatkan aliran output soket dan membuka PrintWriter di atasnya. Demikian pula, pernyataan ketiga mendapatkan aliran input soket dan membuka BufferedReader di atasnya. Contoh ini menggunakan pembaca dan penulis sehingga dapat menulis karakter Unicode melalui soket. Untuk mengirim data melalui soket ke server, contoh EchoClient perlu menulis ke PrintWriter . Untuk mendapatkan respons server, EchoClient membaca dari objek BufferedReader stdIn , yang dibuat dalam pernyataan keempat di try dengan pernyataan sumber daya. Jika Anda belum terbiasa dengan kelas I / O platform Java, Anda mungkin ingin membaca I / O Dasar . Bagian menarik berikutnya dari program ini adalah loop while . Loop membaca garis pada satu waktu dari aliran input standar dan segera mengirimkannya ke server dengan menulisnya ke PrintWriter terhubung ke soket:

 String userInput;
 while ((userInput = stdIn.readLine ())! = null) {
     out.println (userInput);
     System.out.println ("echo:" + in.readLine ());
 }

Pernyataan terakhir di loop while membaca baris informasi dari BufferedReader terhubung ke soket. Metode readLine menunggu hingga server mengulang kembali informasi ke EchoClient . Ketika readline kembali, EchoClient mencetak informasi ke output standar. Loop while berlanjut sampai pengguna mengetik karakter end-of-input. Yaitu, contoh EchoClient membaca input dari pengguna, mengirimkannya ke server Echo, mendapat respons dari server, dan menampilkannya, hingga mencapai akhir input. (Anda dapat mengetik karakter end-of-input dengan menekan Ctrl-C .) Loop while kemudian berakhir, dan runtime Java secara otomatis menutup pembaca dan penulis yang terhubung ke soket dan ke aliran input standar, dan itu menutup soket koneksi ke server. Java runtime menutup sumber daya ini secara otomatis karena mereka dibuat dalam pernyataan try -with-resources. Java runtime menutup sumber daya ini dalam urutan terbalik yang dibuat. (Ini bagus karena aliran yang terhubung ke soket harus ditutup sebelum soket itu sendiri ditutup.) Program klien ini mudah dan sederhana karena server gema mengimplementasikan protokol sederhana. Klien mengirim teks ke server, dan server mengulanginya. Ketika program klien Anda berbicara dengan server yang lebih rumit seperti server HTTP, program klien Anda juga akan lebih rumit. Namun, dasarnya sama dengan yang ada di program ini:

1. Buka soket.
2. Buka aliran input dan aliran output ke soket.
3. Baca dari dan tulis ke aliran sesuai dengan protokol server.
4. Tutup alirannya.
5. Tutup soketnya.

Hanya langkah 3 yang berbeda dari klien ke klien, tergantung pada server. Langkah-langkah lain sebagian besar tetap sama.

Menulis Sisi Server dari Soket

Bagian ini menunjukkan kepada Anda bagaimana menulis server dan klien yang menyertainya. Server dalam pasangan klien / server menyajikan lelucon Knock Knock. Mengetuk Mengetuk lelucon disukai oleh anak-anak dan biasanya kendaraan untuk permainan kata-kata buruk. Mereka pergi seperti ini: Server : "Ketuk ketukan!" Klien : "Siapa di sana?" Server : "Dexter." Klien : "Dexter siapa?" Server : "Aula Dexter dengan dahan holly." Klien : "Mengerang." Contoh terdiri dari dua program Java yang berjalan secara independen: program klien dan program server. Program klien diimplementasikan oleh satu kelas, KnockKnockClient , dan sangat mirip dengan contoh EchoClient dari bagian sebelumnya. Program server diimplementasikan oleh dua kelas: KnockKnockServer dan KnockKnockProtocol . KnockKnockServer , yang mirip dengan EchoServer , berisi metode main untuk program server dan melakukan pekerjaan mendengarkan port, membangun koneksi, dan membaca dari dan menulis ke soket. Kelas KnockKnockProtocol menyajikan lelucon. Ini melacak lelucon saat ini, keadaan saat ini (ketukan ketukan terkirim, petunjuk kirim, dan sebagainya), dan mengembalikan berbagai potongan teks lelucon tergantung pada kondisi saat ini. Objek ini mengimplementasikan protokol — bahasa yang telah disetujui oleh klien dan server untuk digunakan untuk berkomunikasi. Bagian berikut ini terlihat secara rinci di setiap kelas di klien dan server dan kemudian menunjukkan kepada Anda bagaimana menjalankannya.

Server Knock Knock

Bagian ini membahas kode yang mengimplementasikan program server Knock Knock, KnockKnockServer . Program server dimulai dengan membuat objek ServerSocket baru untuk mendengarkan pada port tertentu (lihat pernyataan dalam huruf tebal di segmen kode berikut). Saat menjalankan server ini, pilih port yang belum didedikasikan untuk beberapa layanan lain. Sebagai contoh, perintah ini memulai program server KnockKnockServer sehingga ia mendengarkan pada port 4444:

 java KnockKnockServer 4444

Program server membuat objek ServerSocket dalam pernyataan try -dengan-sumber daya:

 int portNumber = Integer.parseInt (args [0]);

 coba ( 
     ServerSocket serverSocket = ServerSocket baru (portNumber);
     Socket clientSocket = serverSocket.accept ();
     PrintWriter out =
         PrintWriter baru (clientSocket.getOutputStream (), true);
     BufferedReader di = BufferedReader baru (
         InputStreamReader baru (clientSocket.getInputStream ()));
 ) { 

 ServerSocket adalah kelas java.net yang menyediakan implementasi sistem-independen dari sisi server dari koneksi soket klien / server.  Konstruktor untuk ServerSocket melempar pengecualian jika tidak dapat mendengarkan pada port yang ditentukan (misalnya, port sudah digunakan).  Dalam hal ini, KnockKnockServer tidak punya pilihan selain keluar. 

Jika server berhasil mengikat ke port-nya, maka objek ServerSocket berhasil dibuat dan server melanjutkan ke langkah berikutnya — menerima koneksi dari klien (pernyataan berikutnya dalam pernyataan try -with-resources):

 clientSocket = serverSocket.accept ();

Metode accept menunggu hingga klien memulai dan meminta koneksi pada host dan port server ini. (Mari kita asumsikan bahwa Anda menjalankan program server knockknockserver.example.com di komputer bernama knockknockserver.example.com .) Dalam contoh ini, server menjalankan nomor port yang ditentukan oleh argumen baris perintah pertama. Ketika suatu koneksi diminta dan berhasil dibuat, metode accept mengembalikan objek Socket baru yang terikat ke port lokal yang sama dan memiliki alamat jarak jauh dan port jarak jauh diatur ke klien. Server dapat berkomunikasi dengan klien melalui Socket baru ini dan terus mendengarkan permintaan koneksi klien pada ServerSocket asli. Versi khusus program ini tidak mendengarkan permintaan koneksi klien yang lebih banyak. Namun, versi program yang dimodifikasi disediakan di Mendukung Banyak Klien . Setelah server berhasil membuat koneksi dengan klien, itu berkomunikasi dengan klien menggunakan kode ini:

 coba (
     // ...
     PrintWriter out =
         PrintWriter baru (clientSocket.getOutputStream (), true);
     BufferedReader di = BufferedReader baru (
         InputStreamReader baru (clientSocket.getInputStream ()));
 ) {
     InputLine string, outputLine;
            
     // Memulai percakapan dengan klien 
      KnockKnockProtocol kkp = KnockKnockProtocol baru (); 
      outputLine = kkp.processInput (null); 
      out.println (outputLine);

     while ((inputLine = in.readLine ())! = null) {
         outputLine = kkp.processInput (inputLine);
         out.println (outputLine);
         if (outputLine.equals ("Bye."))
             istirahat;
     }

 Kode ini melakukan hal berikut: 

1. Mendapat aliran input dan output soket dan membuka pembaca dan penulis di dalamnya.
2. Memulai komunikasi dengan klien dengan menulis ke soket (ditunjukkan dengan huruf tebal).
3. Berkomunikasi dengan klien dengan membaca dari dan menulis ke soket (loop while ).

Langkah 1 sudah tidak asing lagi. Langkah 2 ditunjukkan dengan huruf tebal dan bernilai beberapa komentar. Pernyataan tebal di segmen kode di atas memulai percakapan dengan klien. Kode menciptakan objek KnockKnockProtocol — objek yang melacak lelucon saat ini, keadaan saat ini dalam lelucon, dan sebagainya. Setelah KnockKnockProtocol dibuat, kode tersebut memanggil metode processInput untuk mendapatkan pesan pertama yang dikirimkan server ke klien. Untuk contoh ini, hal pertama yang dikatakan server adalah "Knock! Knock!" Selanjutnya, server menulis informasi ke PrintWriter terhubung ke soket klien, sehingga mengirim pesan ke klien. Langkah 3 dikodekan dalam loop while . Selama klien dan server masih memiliki sesuatu untuk dikatakan satu sama lain, server membaca dari dan menulis ke soket, mengirim pesan bolak-balik antara klien dan server. Server memulai percakapan dengan "Knock! Knock!" jadi setelah itu server harus menunggu klien untuk mengatakan "Siapa di sana?" Akibatnya, loop while berulang pada membaca dari aliran input. Metode readLine menunggu hingga klien merespons dengan menulis sesuatu ke aliran outputnya (aliran input server). Ketika klien merespons, server meneruskan respons klien ke objek KnockKnockProtocol dan meminta objek KnockKnockProtocol untuk jawaban yang sesuai. Server segera mengirim balasan ke klien melalui aliran output yang terhubung ke soket, menggunakan panggilan ke println. Jika respons server yang dihasilkan dari objek KnockKnockServer adalah "Sampai jumpa." ini menunjukkan bahwa klien tidak ingin ada lagi lelucon dan loop berhenti. Java runtime secara otomatis menutup aliran input dan output, soket klien, dan soket server karena semuanya telah dibuat dalam pernyataan try -with-resources.

Protokol Knock Knock

Kelas KnockKnockProtocol mengimplementasikan protokol yang digunakan klien dan server untuk berkomunikasi. Kelas ini melacak di mana klien dan server berada dalam percakapan mereka dan menyajikan respons server terhadap pernyataan klien. Objek KnockKnockProtocol berisi teks dari semua lelucon dan memastikan bahwa klien memberikan respons yang tepat terhadap pernyataan server. Tidak akan ada gunanya membuat klien mengatakan "Dexter siapa?" ketika server mengatakan "Ketuk! Ketuk!" Semua pasangan klien / server harus memiliki beberapa protokol yang dengannya mereka berbicara satu sama lain; jika tidak, data yang bolak-balik akan menjadi tidak berarti. Protokol yang digunakan klien dan server Anda sepenuhnya bergantung pada komunikasi yang diperlukan oleh mereka untuk menyelesaikan tugas.

Klien Knock Knock

Kelas KnockKnockClient mengimplementasikan program klien yang berbicara kepada KnockKnockServer . EchoClient didasarkan pada program EchoClient di bagian sebelumnya, Membaca dari dan Menulis ke Soket dan seharusnya sudah tidak asing lagi bagi Anda. Tetapi bagaimanapun juga, kita akan membahas program dan melihat apa yang terjadi di klien dalam konteks apa yang terjadi di server. Ketika Anda memulai program klien, server seharusnya sudah berjalan dan mendengarkan port, menunggu klien untuk meminta koneksi. Jadi, hal pertama yang dilakukan oleh program klien adalah membuka soket yang terhubung ke server yang berjalan pada nama host dan port yang ditentukan:

 String hostName = args [0];
 int portNumber = Integer.parseInt (args [1]);

 coba (
     Socket kkSocket = Socket baru (hostName, portNumber);
     PrintWriter out = PrintWriter baru (kkSocket.getOutputStream (), true);
     BufferedReader di = BufferedReader baru (
         InputStreamReader baru (kkSocket.getInputStream ()));
 )

Saat membuat soketnya, contoh KnockKnockClient menggunakan nama host argumen baris perintah pertama, nama komputer di jaringan Anda yang menjalankan program server KnockKnockServer . Contoh KnockKnockClient menggunakan argumen baris perintah kedua sebagai nomor port saat membuat soketnya. Ini adalah nomor port jarak jauh — nomor port pada komputer server — dan merupakan port yang didengar KnockKnockServer . Sebagai contoh, perintah berikut menjalankan contoh knockknockserver.example.com dengan knockknockserver.example.com sebagai nama komputer yang menjalankan program server KnockKnockServer dan 4444 sebagai nomor port jarak jauh:

 java KnockKnockClient knockknockserver.example.com 4444

Soket klien terikat ke porta lokal yang tersedia — porta pada komputer klien. Ingatlah bahwa server mendapatkan soket baru juga. Jika Anda menjalankan contoh KnockKnockClient dengan argumen baris perintah pada contoh sebelumnya, maka soket ini terikat ke nomor port lokal 4444 di komputer tempat Anda menjalankan contoh KnockKnockClient . Soket server dan soket klien terhubung. Selanjutnya adalah loop while yang mengimplementasikan komunikasi antara klien dan server. Server berbicara terlebih dahulu, sehingga klien harus mendengarkan terlebih dahulu. Klien melakukan ini dengan membaca dari aliran input yang terpasang ke soket. Jika server berbicara, ia mengatakan "Sampai jumpa." dan klien keluar dari loop. Jika tidak, klien menampilkan teks ke output standar dan kemudian membaca respons dari pengguna, yang mengetik ke input standar. Setelah pengguna mengetik carriage return, klien mengirim teks ke server melalui aliran output yang terpasang ke soket.

 while ((fromServer = in.readLine ())! = null) {
     System.out.println ("Server:" + fromServer);
     if (fromServer.equals ("Bye."))
         istirahat;

     fromUser = stdIn.readLine ();
     if (fromUser! = null) {
         System.out.println ("Klien:" + fromUser);
         out.println (fromUser);
     }
 }

Komunikasi berakhir ketika server bertanya apakah klien ingin mendengar lelucon lain, klien mengatakan tidak, dan server mengatakan "Sampai jumpa." Klien secara otomatis menutup input dan output stream dan socketnya karena dibuat dalam pernyataan try -with-resources.

Menjalankan Program

Anda harus memulai program server terlebih dahulu. Untuk melakukan ini, jalankan program server menggunakan Java interpreter, sama seperti yang Anda lakukan pada aplikasi Java lainnya. Tentukan sebagai argumen baris perintah nomor port tempat program server mendengarkan:

 java KnockKnockServer 4444

Selanjutnya, jalankan program klien. Perhatikan bahwa Anda dapat menjalankan klien di komputer mana saja di jaringan Anda; tidak harus berjalan di komputer yang sama dengan server. Tentukan sebagai argumen baris perintah nama host dan nomor port komputer yang menjalankan program server KnockKnockServer :

 java KnockKnockClient knockknockserver.example.com 4444

Jika Anda terlalu cepat, Anda dapat memulai klien sebelum server memiliki kesempatan untuk menginisialisasi sendiri dan mulai mendengarkan pada port. Jika ini terjadi, Anda akan melihat jejak tumpukan dari klien. Jika ini terjadi, mulai ulang klien. Jika Anda mencoba untuk memulai klien kedua saat klien pertama terhubung ke server, klien kedua hanya hang. Bagian selanjutnya, Mendukung Banyak Klien , berbicara tentang mendukung banyak klien. Ketika Anda berhasil mendapatkan koneksi antara klien dan server, Anda akan melihat teks berikut ini ditampilkan di layar Anda:

 Server: Ketuk!  Ketukan!

Sekarang, Anda harus merespons dengan:

 Siapa disana?

Klien menggemakan apa yang Anda ketikkan dan mengirim teks ke server. Server merespons dengan baris pertama dari salah satu lelucon Knock Knock dalam repertoarnya. Sekarang layar Anda harus berisi ini (teks yang Anda ketik dicetak tebal):

 Server: Ketuk!  Ketukan!
 Siapa disana?
 Klien: Siapa disana?
 Server: Turnip

Sekarang, Anda merespons dengan:

 Lobak siapa?

Sekali lagi, klien menggemakan apa yang Anda ketikkan dan mengirim teks ke server. Server merespons dengan garis pukulan. Sekarang layar Anda harus berisi ini:

 Server: Ketuk!  Ketukan!
 Siapa disana?
 Klien: Siapa disana?
 Server: Turnip
 Lobak siapa?
 Klien: Turnip siapa?
 Server: Turnip panasnya, dingin di sini!  Ingin yang lain?  (y / n)   

Jika Anda ingin mendengar lelucon lain, ketik y ; jika tidak, ketik n . Jika Anda mengetik y , server mulai lagi dengan "Knock! Knock!" Jika Anda mengetik n , server mengatakan "Sampai jumpa." sehingga menyebabkan klien dan server untuk keluar. Jika suatu saat Anda membuat kesalahan pengetikan, objek KnockKnockServer menangkapnya dan server merespons dengan pesan yang mirip dengan ini:

 Server: Anda seharusnya mengatakan "Siapa di sana?"!

Server kemudian memulai lelucon lagi:

 Server: Coba lagi.  Ketukan!  Ketukan!

Perhatikan bahwa objek KnockKnockProtocol khusus tentang pengejaan dan tanda baca tetapi bukan tentang huruf besar.

Mendukung Banyak Klien

Untuk membuat contoh KnockKnockServer sederhana, kami mendesainnya untuk mendengarkan dan menangani satu permintaan koneksi. Namun, beberapa permintaan klien dapat masuk ke port yang sama dan, akibatnya, ke ServerSocket sama. Permintaan koneksi klien diantrekan di port, sehingga server harus menerima koneksi secara berurutan. Namun, server dapat melayani mereka secara bersamaan melalui penggunaan utas — satu utas per setiap koneksi klien. Alur dasar logika di server seperti ini adalah ini:

 while (true) {
     menerima koneksi;
     buat utas untuk berurusan dengan klien;
 } 

Sekian Dan Terimakasih:)