En guide till Java-uttag

1. Översikt

Termen socket programmering hänvisar till att skriva program som utför på flera datorer där enheterna är alla anslutna till varandra med hjälp av ett nätverk.

Det finns två kommunikationsprotokoll som man kan använda för sockelprogrammering: User Datagram Protocol (UDP) och Transfer Control Protocol (TCP) .

Huvudskillnaden mellan de två är att UDP är anslutningsfritt, vilket innebär att det inte finns någon session mellan klienten och servern medan TCP är anslutningsorienterad, vilket innebär att en exklusiv anslutning måste upprättas först mellan klient och server för att kommunikation ska kunna ske.

Denna handledning presenterar en introduktion till sockets programmering över TCP / IP- nätverk och visar hur man skriver klient / serverapplikationer i Java. UDP är inte ett vanligt protokoll och kan därför inte förekomma ofta.

2. Projektinställning

Java tillhandahåller en samling klasser och gränssnitt som tar hand om kommunikationsdetaljer på låg nivå mellan klienten och servern.

Dessa finns mestadels i paketet java.net , så vi måste göra följande import:

import java.net.*;

Vi behöver också paketet java.io som ger oss in- och utgångsströmmar att skriva till och läsa från medan vi kommunicerar:

import java.io.*;

För enkelhets skull kör vi våra klient- och serverprogram på samma dator. Om vi ​​skulle köra dem på olika nätverksdatorer är det enda som skulle ändras IP-adressen, i det här fallet använder vi localhost den 127.0.0.1 .

3. Enkelt exempel

Låt oss göra våra händer smutsiga med de mest grundläggande exemplen som involverar en klient och en server . Det kommer att bli en tvåvägs kommunikationsapplikation där klienten hälsar på servern och servern svarar.

Låt oss skapa serverapplikationen i en klass som heter GreetServer.java med följande kod.

Vi inkluderar huvudmetoden och globala variabler för att uppmärksamma hur vi kommer att köra alla servrar i den här artikeln. I resten av exemplen i artiklarna utelämnar vi den här typen av mer repetitiv kod:

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

Låt oss också skapa en klient som heter GreetClient.java med den här koden:

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

Låt oss starta servern; i din IDE gör du detta genom att helt enkelt köra det som ett Java-program.

Och nu ska vi skicka en hälsning till servern med hjälp av ett enhetstest, som bekräftar att servern faktiskt skickar en hälsning som svar:

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

Oroa dig inte om du inte helt förstår vad som händer här, eftersom detta exempel är tänkt att ge oss en känsla av vad vi kan förvänta oss senare i artikeln.

I följande avsnitt kommer vi att dissekera sockelkommunikation med hjälp av detta enkla exempel och dyka djupare in i detaljerna med fler exempel.

4. Hur uttag fungerar

Vi kommer att använda exemplet ovan för att gå igenom olika delar av detta avsnitt.

Per definition är ett uttag en slutpunkt för en tvåvägs kommunikationslänk mellan två program som körs på olika datorer i ett nätverk. Ett uttag är bundet till ett portnummer så att transportskiktet kan identifiera den applikation som data är avsedd att skickas till.

4.1. Servern

Vanligtvis körs en server på en specifik dator i nätverket och har ett uttag som är bundet till ett visst portnummer. I vårt fall använder vi samma dator som klienten och startade servern på port 6666 :

ServerSocket serverSocket = new ServerSocket(6666);

Servern väntar bara och lyssnar på uttaget för en klient att göra en anslutningsförfrågan. Detta händer i nästa steg:

Socket clientSocket = serverSocket.accept();

När serverkoden möter acceptmetoden blockeras den tills en klient gör en anslutningsförfrågan till den.

Om allt går bra accepterar servern anslutningen. Efter godkännande får servern ett nytt uttag, clientSocket , bundet till samma lokala port, 6666 , och har också sin fjärranslutning inställd på adress och port för klienten.

Vid det här tillfället sätter det nya Socket- objektet servern i direkt anslutning till klienten, vi kan sedan komma åt ut- och inmatningsströmmarna för att skriva och ta emot meddelanden till respektive från klienten:

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

Härifrån och framåt kan servern utbyta meddelanden med klienten oändligt tills sockeln är stängd med sina strömmar.

Men i vårt exempel kan servern bara skicka ett hälsningssvar innan den stänger anslutningen, det betyder att om vi kör vårt test igen skulle anslutningen vägras.

För att möjliggöra kontinuitet i kommunikation, måste vi läsa från ingångsströmmen i en stund loop och endast exit när klienten skickar en begäran avslutning kommer vi att se detta i aktion i följande avsnitt.

För varje ny klient behöver servern ett nytt uttag som returneras av godkännande- samtalet. Det Server används för att fortsätta att lyssna efter anslutningsbegäranden samtidigt tenderar att behoven hos de anslutna kunder. Vi har inte tillåtit detta ännu i vårt första exempel.

4.2. Klienten

Klienten måste känna till värdnamnet eller IP-adressen för den maskin som servern körs på och det portnummer som servern lyssnar på.

För att göra en anslutningsförfrågan försöker klienten att möta servern på serverns maskin och port:

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

Klienten behöver också identifiera sig mot servern så att den binder till ett lokalt portnummer, tilldelat av systemet, som det kommer att använda under denna anslutning. Vi hanterar inte detta själva.

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.

Vi kommer fortfarande att använda EchoClient för att testa servern, den här gången skapar vi flera klienter som varje skickar och tar emot flera meddelanden från servern.

Låt oss starta vår server med dess huvudmetod på port 5555 .

För tydlighetens skull kommer vi fortfarande att testa i en ny svit:

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

Vi kan skapa så många av dessa testfall som vi vill, var och en gyter en ny klient och servern kommer att betjäna dem alla.

7. Slutsats

I den här handledningen har vi fokuserat på en introduktion till sockets-programmering över TCP / IP och skrivit en enkel klient / serverapplikation i Java.

Den fullständiga källkoden för artikeln finns - som vanligt - i GitHub-projektet.