Hướng dẫn về Java Sockets

1. Khái quát chung

Thuật ngữ lập trình socket đề cập đến việc viết các chương trình thực thi trên nhiều máy tính trong đó các thiết bị được kết nối với nhau bằng mạng.

Có hai giao thức truyền thông mà người ta có thể sử dụng để lập trình socket: Giao thức Dữ liệu Người dùng (UDP) và Giao thức Điều khiển Truyền (TCP) .

Sự khác biệt chính giữa cả hai là UDP là không kết nối, nghĩa là không có phiên giữa máy khách và máy chủ trong khi TCP là hướng kết nối, có nghĩa là một kết nối độc quyền trước tiên phải được thiết lập giữa máy khách và máy chủ để giao tiếp diễn ra.

Hướng dẫn này giới thiệu về lập trình socket qua mạng TCP / IP và trình bày cách viết các ứng dụng client / server trong Java. UDP không phải là một giao thức chính thống và như vậy có thể không thường xuyên gặp phải.

2. Thiết lập dự án

Java cung cấp một tập hợp các lớp và giao diện xử lý các chi tiết giao tiếp cấp thấp giữa máy khách và máy chủ.

Chúng hầu hết được chứa trong gói java.net , vì vậy chúng ta cần thực hiện việc nhập sau:

import java.net.*;

Chúng tôi cũng cần gói java.io cung cấp cho chúng tôi các luồng đầu vào và đầu ra để ghi và đọc trong khi giao tiếp:

import java.io.*;

Để đơn giản hơn, chúng tôi sẽ chạy các chương trình máy khách và máy chủ của mình trên cùng một máy tính. Nếu chúng tôi thực thi chúng trên các máy tính nối mạng khác nhau, điều duy nhất sẽ thay đổi là địa chỉ IP, trong trường hợp này, chúng tôi sẽ sử dụng localhost trên 127.0.0.1 .

3. Ví dụ đơn giản

Chúng ta hãy làm bẩn tay chúng ta với những ví dụ cơ bản nhất liên quan đến máy khách và máy chủ . Nó sẽ là một ứng dụng giao tiếp hai chiều trong đó máy khách chào hỏi máy chủ và máy chủ phản hồi.

Hãy tạo ứng dụng máy chủ trong một lớp có tên GreetServer.java với đoạn mã sau.

Chúng tôi bao gồm phương thức chính và các biến toàn cục để thu hút sự chú ý về cách chúng tôi sẽ chạy tất cả các máy chủ trong bài viết này. Trong phần còn lại của các ví dụ trong bài viết, chúng tôi sẽ bỏ qua loại mã lặp lại nhiều hơn này:

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); } }

Cũng hãy tạo một ứng dụng khách có tên GreetClient.java với mã này:

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(); } }

Hãy khởi động máy chủ; trong IDE của bạn, bạn thực hiện việc này bằng cách đơn giản chạy nó như một ứng dụng Java.

Và bây giờ chúng ta hãy gửi lời chào đến máy chủ bằng cách sử dụng bài kiểm tra đơn vị, điều này xác nhận rằng máy chủ thực sự gửi lời chào đáp lại:

@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); }

Đừng lo lắng nếu bạn không hoàn toàn hiểu những gì đang xảy ra ở đây, vì ví dụ này nhằm cung cấp cho chúng ta cảm giác về những gì sẽ xảy ra ở phần sau của bài viết.

Trong các phần tiếp theo, chúng ta sẽ phân tích giao tiếp socket bằng ví dụ đơn giản này và đi sâu hơn vào chi tiết với nhiều ví dụ hơn.

4. Cách thức hoạt động của ổ cắm

Chúng ta sẽ sử dụng ví dụ trên để xem qua các phần khác nhau của phần này.

Theo định nghĩa, socket là một điểm cuối của liên kết giao tiếp hai chiều giữa hai chương trình chạy trên các máy tính khác nhau trong mạng. Một ổ cắm được liên kết với một số cổng để lớp truyền tải có thể xác định ứng dụng mà dữ liệu được gửi đến.

4.1. Máy chủ

Thông thường, một máy chủ chạy trên một máy tính cụ thể trong mạng và có một ổ cắm được liên kết với một số cổng cụ thể. Trong trường hợp của chúng tôi, chúng tôi sử dụng cùng một máy tính với máy khách và khởi động máy chủ trên cổng 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Máy chủ chỉ đợi, lắng nghe socket để máy khách thực hiện yêu cầu kết nối. Điều này xảy ra trong bước tiếp theo:

Socket clientSocket = serverSocket.accept();

Khi mã máy chủ gặp phương thức chấp nhận , nó sẽ chặn cho đến khi máy khách đưa ra yêu cầu kết nối với nó.

Nếu mọi thứ diễn ra tốt đẹp, máy chủ chấp nhận kết nối. Sau khi chấp nhận, máy chủ nhận được một ổ cắm mới, clientSocket , được liên kết với cùng một cổng cục bộ, 6666 và cũng có điểm cuối từ xa được đặt thành địa chỉ và cổng của máy khách.

Tại thời điểm này, đối tượng Socket mới đặt máy chủ kết nối trực tiếp với máy khách, sau đó chúng ta có thể truy cập các luồng đầu ra và đầu vào để viết và nhận các thông báo đến và từ máy khách tương ứng:

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

From here onwards, the server is capable of exchanging messages with the client endlessly until the socket is closed with its streams.

However, in our example the server can only send a greeting response before it closes the connection, this means that if we ran our test again, the connection would be refused.

To allow continuity in communication, we will have to read from the input stream inside a while loop and only exit when the client sends a termination request, we will see this in action in the following section.

For every new client, the server needs a new socket returned by the accept call. The serverSocket is used to continue to listen for connection requests while tending to the needs of the connected clients. We have not allowed for this yet in our first example.

4.2. The Client

The client must know the hostname or IP of the machine on which the server is running and the port number on which the server is listening.

To make a connection request, the client tries to rendezvous with the server on the server's machine and port:

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

The client also needs to identify itself to the server so it binds to a local port number, assigned by the system, that it will use during this connection. We don't deal with this ourselves.

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.

Chúng tôi vẫn sẽ sử dụng EchoClient để kiểm tra máy chủ, lần này chúng tôi sẽ tạo nhiều máy khách mỗi lần gửi và nhận nhiều tin nhắn từ máy chủ.

Hãy khởi động máy chủ của chúng tôi bằng phương thức chính của nó trên cổng 5555 .

Để rõ ràng, chúng tôi vẫn sẽ đặt các thử nghiệm trong một bộ phần mềm mới:

@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"); }

Chúng tôi có thể tạo bao nhiêu trong số các trường hợp thử nghiệm này tùy thích, mỗi trường hợp tạo ra một ứng dụng khách mới và máy chủ sẽ phục vụ tất cả chúng.

7. Kết luận

Trong hướng dẫn này, chúng tôi đã tập trung vào phần giới thiệu về lập trình socket qua TCP / IP và viết một ứng dụng Client / Server đơn giản bằng Java.

Bạn có thể tìm thấy mã nguồn đầy đủ của bài viết - như thường lệ - trong dự án GitHub.