Ръководство за сокети на 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()));

Оттук нататък сървърът може да обменя безкрайно съобщения с клиента, докато сокетът не бъде затворен с потоците си.

В нашия пример обаче сървърът може да изпрати само поздравителен отговор, преди да затвори връзката, това означава, че ако повторно проверим нашия тест, връзката ще бъде отказана.

За да позволим приемственост в комуникацията, ще трябва да четем от входния поток в цикъл while и да излизаме само когато клиентът изпрати заявка за прекратяване, ще видим това в действие в следващия раздел.

За всеки нов клиент сървърът се нуждае от нов сокет, върнат от приемащото повикване. В 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.