Panduan untuk Soket Java

1. Ikhtisar

Istilah pemrograman soket mengacu pada menulis program yang dijalankan di banyak komputer di mana semua perangkat terhubung satu sama lain menggunakan jaringan.

Ada dua protokol komunikasi yang dapat digunakan untuk pemrograman soket: User Datagram Protocol (UDP) dan Transfer Control Protocol (TCP) .

Perbedaan utama antara keduanya adalah bahwa UDP tidak memiliki koneksi, artinya tidak ada sesi antara klien dan server sementara TCP berorientasi pada koneksi, yang berarti koneksi eksklusif harus terlebih dahulu dibuat antara klien dan server agar komunikasi berlangsung.

Tutorial ini menyajikan pengantar pemrograman soket melalui jaringan TCP / IP dan mendemonstrasikan cara menulis aplikasi klien / server di Java. UDP bukanlah protokol utama dan karenanya mungkin tidak sering ditemui.

2. Pengaturan Proyek

Java menyediakan sekumpulan kelas dan antarmuka yang menangani detail komunikasi tingkat rendah antara klien dan server.

Ini sebagian besar terdapat dalam paket java.net , jadi kita perlu melakukan impor berikut:

import java.net.*;

Kita juga membutuhkan paket java.io yang memberi kita aliran input dan output untuk menulis dan membaca saat berkomunikasi:

import java.io.*;

Demi kesederhanaan, kami akan menjalankan program klien dan server kami di komputer yang sama. Jika kami menjalankannya di komputer jaringan yang berbeda, satu-satunya hal yang akan berubah adalah alamat IP, dalam hal ini, kami akan menggunakan localhost di 127.0.0.1 .

3. Contoh Sederhana

Mari kita mengotori tangan kita dengan contoh paling dasar yang melibatkan klien dan server . Ini akan menjadi aplikasi komunikasi dua arah di mana klien menyapa server dan server merespons.

Mari buat aplikasi server di kelas yang disebut GreetServer.java dengan kode berikut.

Kami menyertakan metode utama dan variabel global untuk menarik perhatian tentang bagaimana kami akan menjalankan semua server di artikel ini. Di contoh lainnya di artikel, kami akan menghilangkan jenis kode yang lebih berulang ini:

public class GreetServer { private ServerSocket serverSocket; private Socket clientSocket; private PrintWriter out; private BufferedReader in; public void start(int port) { serverSocket = new ServerSocket(port); clientSocket = serverSocket.accept(); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String greeting = in.readLine(); if ("hello server".equals(greeting)) { out.println("hello client"); } else { out.println("unrecognised greeting"); } } public void stop() { in.close(); out.close(); clientSocket.close(); serverSocket.close(); } public static void main(String[] args) { GreetServer server=new GreetServer(); server.start(6666); } }

Mari juga buat klien bernama GreetClient.java dengan kode ini:

public class GreetClient { private Socket clientSocket; private PrintWriter out; private BufferedReader in; public void startConnection(String ip, int port) { clientSocket = new Socket(ip, port); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); } public String sendMessage(String msg) { out.println(msg); String resp = in.readLine(); return resp; } public void stopConnection() { in.close(); out.close(); clientSocket.close(); } }

Mari mulai server; di IDE Anda, Anda melakukan ini hanya dengan menjalankannya sebagai aplikasi Java.

Dan sekarang mari kita mengirim salam ke server menggunakan tes unit, yang mengonfirmasi bahwa server benar-benar mengirim salam sebagai tanggapan:

@Test public void givenGreetingClient_whenServerRespondsWhenStarted_thenCorrect() { GreetClient client = new GreetClient(); client.startConnection("127.0.0.1", 6666); String response = client.sendMessage("hello server"); assertEquals("hello client", response); }

Jangan khawatir jika Anda tidak sepenuhnya memahami apa yang terjadi di sini, karena contoh ini dimaksudkan untuk memberi kita gambaran tentang apa yang diharapkan nanti dalam artikel.

Di bagian berikut, kami akan membedah komunikasi soket menggunakan contoh sederhana ini dan menyelami detailnya lebih dalam dengan lebih banyak contoh.

4. Bagaimana Soket Bekerja

Kami akan menggunakan contoh di atas untuk melangkah melalui bagian yang berbeda dari bagian ini.

Menurut definisi, soket adalah salah satu titik akhir dari tautan komunikasi dua arah antara dua program yang berjalan pada komputer yang berbeda di jaringan. Soket terikat ke nomor port sehingga lapisan transport dapat mengidentifikasi aplikasi tujuan pengiriman data.

4.1. Server

Biasanya, server berjalan pada komputer tertentu di jaringan dan memiliki soket yang terikat ke nomor port tertentu. Dalam kasus kami, kami menggunakan komputer yang sama dengan klien dan memulai server pada port 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Server hanya menunggu, mendengarkan soket untuk klien membuat permintaan koneksi. Ini terjadi pada langkah berikutnya:

Socket clientSocket = serverSocket.accept();

Ketika kode server menemukan metode terima , itu memblokir sampai klien membuat permintaan koneksi ke sana.

Jika semuanya berjalan dengan baik, server menerima koneksi. Setelah diterima, server mendapatkan soket baru, clientSocket , terikat ke port lokal yang sama, 6666 , dan juga memiliki titik akhir jarak jauh yang disetel ke alamat dan port klien.

Pada titik ini, objek Socket baru menempatkan server dalam koneksi langsung dengan klien, kita kemudian dapat mengakses arus keluaran dan masukan untuk menulis dan menerima pesan ke dan dari klien masing-masing:

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

Dari sini dan seterusnya, server mampu bertukar pesan dengan klien tanpa henti sampai soket ditutup dengan alirannya.

Namun, dalam contoh kami, server hanya dapat mengirim tanggapan salam sebelum menutup koneksi, ini berarti jika kami menjalankan pengujian kami lagi, koneksi akan ditolak.

Untuk memungkinkan kontinuitas dalam komunikasi, kita harus membaca dari aliran input di dalam loop sementara dan hanya keluar ketika klien mengirimkan permintaan penghentian, kita akan melihat ini beraksi di bagian berikut.

Untuk setiap klien baru, server membutuhkan soket baru yang dikembalikan oleh panggilan terima . The ServerSocket digunakan untuk terus mendengarkan permintaan sambungan sementara cenderung kebutuhan klien yang terhubung. Kami belum mengizinkan untuk ini di contoh pertama kami.

4.2. Klien

Klien harus mengetahui nama host atau IP mesin tempat server berjalan dan nomor port tempat server mendengarkan.

Untuk membuat permintaan koneksi, klien mencoba untuk bertemu dengan server di mesin dan port server:

Socket clientSocket = new Socket("127.0.0.1", 6666);

Klien juga perlu mengidentifikasi dirinya ke server sehingga mengikat ke nomor port lokal, yang ditetapkan oleh sistem, yang akan digunakan selama sambungan ini. Kami tidak menangani ini sendiri.

The above constructor only creates a new socket when the server has accepted the connection, otherwise, we will get a connection refused exception. When successfully created we can then obtain input and output streams from it to communicate with the server:

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

The input stream of the client is connected to the output stream of the server, just like the input stream of the server is connected to the output stream of the client.

5. Continuous Communication

Our current server blocks until a client connects to it and then blocks again to listen to a message from the client, after the single message, it closes the connection because we have not dealt with continuity.

So it is only helpful in ping requests, but imagine we would like to implement a chat server, continuous back and forth communication between server and client would definitely be required.

We will have to create a while loop to continuously observe the input stream of the server for incoming messages.

Let's create a new server called EchoServer.java whose sole purpose is to echo back whatever messages it receives from clients:

public class EchoServer { public void start(int port) { serverSocket = new ServerSocket(port); clientSocket = serverSocket.accept(); out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String inputLine; while ((inputLine = in.readLine()) != null) { if (".".equals(inputLine)) { out.println("good bye"); break; } out.println(inputLine); } }

Notice that we have added a termination condition where the while loop exits when we receive a period character.

We will start EchoServer using the main method just as we did for the GreetServer. This time, we start it on another port such as 4444 to avoid confusion.

The EchoClient is similar to GreetClient, so we can duplicate the code. We are separating them for clarity.

In a different test class, we shall create a test to show that multiple requests to the EchoServer will be served without the server closing the socket. This is true as long as we are sending requests from the same client.

Dealing with multiple clients is a different case, which we shall see in a subsequent section.

Let's create a setup method to initiate a connection with the server:

@Before public void setup() { client = new EchoClient(); client.startConnection("127.0.0.1", 4444); }

We will equally create a tearDown method to release all our resources, this is best practice for every case where we use network resources:

@After public void tearDown() { client.stopConnection(); }

Let's then test our echo server with a few requests:

@Test public void givenClient_whenServerEchosMessage_thenCorrect() { String resp1 = client.sendMessage("hello"); String resp2 = client.sendMessage("world"); String resp3 = client.sendMessage("!"); String resp4 = client.sendMessage("."); assertEquals("hello", resp1); assertEquals("world", resp2); assertEquals("!", resp3); assertEquals("good bye", resp4); }

This is an improvement over the initial example, where we would only communicate once before the server closed our connection; now we send a termination signal to tell the server when we're done with the session.

6. Server With Multiple Clients

Much as the previous example was an improvement over the first one, it is still not that great a solution. A server must have the capacity to service many clients and many requests simultaneously.

Handling multiple clients is what we are going to cover in this section.

Another feature we will see here is that the same client could disconnect and reconnect again, without getting a connection refused exception or a connection reset on the server. Previously we were not able to do this.

This means that our server is going to be more robust and resilient across multiple requests from multiple clients.

How we will do this is to create a new socket for every new client and service that client's requests on a different thread. The number of clients being served simultaneously will equal the number of threads running.

The main thread will be running a while loop as it listens for new connections.

Enough talk, let's create another server called EchoMultiServer.java. Inside it, we will create a handler thread class to manage each client's communications on its socket:

public class EchoMultiServer { private ServerSocket serverSocket; public void start(int port) { serverSocket = new ServerSocket(port); while (true) new EchoClientHandler(serverSocket.accept()).start(); } public void stop() { serverSocket.close(); } private static class EchoClientHandler extends Thread { private Socket clientSocket; private PrintWriter out; private BufferedReader in; public EchoClientHandler(Socket socket) { this.clientSocket = socket; } public void run() { out = new PrintWriter(clientSocket.getOutputStream(), true); in = new BufferedReader( new InputStreamReader(clientSocket.getInputStream())); String inputLine; while ((inputLine = in.readLine()) != null) { if (".".equals(inputLine)) { out.println("bye"); break; } out.println(inputLine); } in.close(); out.close(); clientSocket.close(); } }

Notice that we now call accept inside a while loop. Every time the while loop is executed, it blocks on the accept call until a new client connects, then the handler thread, EchoClientHandler, is created for this client.

What happens inside the thread is what we previously did in the EchoServer where we handled only a single client. So the EchoMultiServer delegates this work to EchoClientHandler so that it can keep listening for more clients in the while loop.

Kami masih akan menggunakan EchoClient untuk menguji server, kali ini kami akan membuat beberapa klien yang masing-masing mengirim dan menerima banyak pesan dari server.

Mari mulai server kita menggunakan metode utamanya pada port 5555 .

Untuk kejelasan, kami masih akan menguji di suite baru:

@Test public void givenClient1_whenServerResponds_thenCorrect() { EchoClient client1 = new EchoClient(); client1.startConnection("127.0.0.1", 5555); String msg1 = client1.sendMessage("hello"); String msg2 = client1.sendMessage("world"); String terminate = client1.sendMessage("."); assertEquals(msg1, "hello"); assertEquals(msg2, "world"); assertEquals(terminate, "bye"); } @Test public void givenClient2_whenServerResponds_thenCorrect() { EchoClient client2 = new EchoClient(); client2.startConnection("127.0.0.1", 5555); String msg1 = client2.sendMessage("hello"); String msg2 = client2.sendMessage("world"); String terminate = client2.sendMessage("."); assertEquals(msg1, "hello"); assertEquals(msg2, "world"); assertEquals(terminate, "bye"); }

Kita dapat membuat sebanyak mungkin kasus uji ini sesuka kita, masing-masing menghasilkan klien baru dan server akan melayani semuanya.

7. Kesimpulan

Dalam tutorial ini, kami telah fokus pada pengenalan pemrograman soket melalui TCP / IP dan menulis aplikasi Klien / Server sederhana di Java.

Kode sumber lengkap untuk artikel tersebut dapat ditemukan - seperti biasa - di proyek GitHub.