Руководство по сокетам Java

1. Обзор

Термин « программирование сокетов» относится к написанию программ, которые выполняются на нескольких компьютерах, в которых все устройства подключены друг к другу с помощью сети.

Существует два протокола связи, которые можно использовать для программирования сокетов: протокол дейтаграмм пользователя (UDP) и протокол управления передачей (TCP) .

Основное различие между ними заключается в том, что UDP не имеет соединения, то есть между клиентом и сервером нет сеанса, в то время как TCP ориентирован на соединение, что означает, что сначала должно быть установлено эксклюзивное соединение между клиентом и сервером для связи.

Это руководство представляет собой введение в программирование сокетов в сетях TCP / IP и демонстрирует, как писать клиент-серверные приложения на Java. UDP не является основным протоколом и поэтому встречается нечасто.

2. Настройка проекта

Java предоставляет набор классов и интерфейсов, которые заботятся о деталях низкоуровневой связи между клиентом и сервером.

В основном они содержатся в пакете java.net , поэтому нам нужно сделать следующий импорт:

import java.net.*;

Нам также нужен пакет java.io , который предоставляет нам потоки ввода и вывода для записи и чтения во время общения:

import java.io.*;

Для простоты мы будем запускать наши клиентские и серверные программы на одном компьютере. Если бы мы выполняли их на разных сетевых компьютерах, единственное, что изменилось бы, - это IP-адрес, в этом случае мы будем использовать localhost на 127.0.0.1 .

3. Простой пример

Давайте разберемся с самыми простыми примерами, включающими клиент и сервер . Это будет приложение для двусторонней связи, в котором клиент приветствует сервер, а сервер отвечает.

Давайте создадим серверное приложение в классе GreetServer.java со следующим кодом.

Мы включаем основной метод и глобальные переменные, чтобы привлечь внимание к тому, как мы будем запускать все серверы в этой статье. В остальных примерах статей мы опустим этот более повторяющийся код:

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

Давайте также создадим клиента с именем GreetClient.java с этим кодом:

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

Запустим сервер; в вашей IDE вы делаете это, просто запуская его как приложение Java.

А теперь давайте отправим приветствие на сервер с помощью модульного теста, который подтверждает, что сервер действительно отправляет приветствие в ответ:

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

Не волнуйтесь, если вы не совсем понимаете, что здесь происходит, поскольку этот пример предназначен для того, чтобы дать нам почувствовать, чего ожидать позже в статье.

В следующих разделах мы рассмотрим обмен данными через сокеты на этом простом примере и углубимся в детали с другими примерами.

4. Как работают сокеты

Мы будем использовать приведенный выше пример, чтобы пройтись по различным частям этого раздела.

По определению, сокет - это одна из конечных точек двустороннего канала связи между двумя программами, работающими на разных компьютерах в сети. Сокет привязан к номеру порта, чтобы транспортный уровень мог идентифицировать приложение, в которое должны быть отправлены данные.

4.1. Сервер

Обычно сервер работает на определенном компьютере в сети и имеет сокет, привязанный к определенному номеру порта. В нашем случае мы используем тот же компьютер, что и клиент, и запускаем сервер на порту 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Сервер просто ждет, слушая сокет, чтобы клиент сделал запрос на соединение. Это происходит на следующем этапе:

Socket clientSocket = serverSocket.accept();

Когда код сервера встречает метод accept , он блокируется, пока клиент не запросит подключение к нему.

Если все идет хорошо, сервер принимает соединение. После принятия сервер получает новый сокет clientSocket , привязанный к тому же локальному порту, 6666 , а также устанавливает для своей удаленной конечной точки адрес и порт клиента.

На этом этапе новый объект Socket устанавливает прямое соединение сервера с клиентом, после чего мы можем получить доступ к потокам вывода и ввода для записи и получения сообщений от клиента и от него соответственно:

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

С этого момента сервер может бесконечно обмениваться сообщениями с клиентом, пока сокет не будет закрыт со своими потоками.

Однако в нашем примере сервер может отправить только приветственный ответ до того, как он закроет соединение, это означает, что если мы снова запустим наш тест, в соединении будет отказано.

Для того, чтобы обеспечить преемственность в общении, мы будем читать из входного потока внутри во время цикла , и только выход , когда клиент отправляет запрос на завершение, мы увидим это в действии в следующем разделе.

Для каждого нового клиента серверу нужен новый сокет, возвращаемый вызовом accept . ServerSocket используется для продолжать прослушивать запросы на подключение , а стремящийся к потребностям подключенных клиентов. В нашем первом примере мы еще не учли этого.

4.2. Клиент

Клиент должен знать имя хоста или IP-адрес машины, на которой работает сервер, и номер порта, на котором сервер прослушивает.

Чтобы сделать запрос на соединение, клиент пытается встретиться с сервером на машине сервера и порте:

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

Клиент также должен идентифицировать себя для сервера, чтобы он привязался к номеру локального порта, назначенному системой, который он будет использовать во время этого соединения. Мы сами этим не занимаемся.

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.

Мы по-прежнему будем использовать EchoClient для тестирования сервера, на этот раз мы создадим несколько клиентов, каждый из которых будет отправлять и получать несколько сообщений с сервера.

Давайте запустим наш сервер, используя его основной метод на порту 5555 .

Для наглядности мы по-прежнему будем помещать тесты в новый набор:

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

Мы можем создать столько тестовых примеров, сколько захотим, каждый из которых порождает нового клиента, и сервер будет обслуживать их все.

7. Заключение

В этом руководстве мы сосредоточились на введении в программирование сокетов через TCP / IP и написали простое клиент-серверное приложение на Java.

Полный исходный код статьи можно найти, как обычно, в проекте GitHub.