Java Networking beheersen: Robuuste Netwerkapplicaties bouwen met java.net

Wat is Netwerkprogrammeren?

De term netwerkprogrammeren verwijst naar het schrijven van programma's die uitgevoerd worden op meerdere apparaten (computers), die allemaal met elkaar verbonden zijn via een netwerk.

Het java.net-pakket van de J2SE API's bevat een verzameling klassen en interfaces die de low-level communicatiedetails afhandelen, zodat je programma's kunt schrijven die zich richten op het oplossen van het probleem.

Het java.net-pakket biedt ondersteuning voor de twee gangbare netwerkprotocollen:

• TCP – Transmission Control Protocol, wat betrouwbare communicatie tussen twee applicaties toestaat. TCP wordt typisch gebruikt over het Internet Protocol, aangeduid als TCP/IP.
• UDP – User Datagram Protocol, een connectionless protocol dat toestaat dat pakketten data tussen applicaties worden getransporteerd.

Dit hoofdstuk geeft een goed begrip van de volgende twee onderwerpen:

• Socket Programmeren – Dit is het meest gebruikte concept in Networking en wordt in detail uitgelegd.
• URL Verwerken – Dit wordt apart behandeld. Klik hier om te leren over URL Processing in Java.

Socket Programmeren

Sockets bieden het communicatiemechanisme tussen twee computers via TCP. Een clientprogramma creëert een socket aan zijn einde van de communicatie en probeert die socket te verbinden met een server.

Wanneer de verbinding tot stand is gekomen, creëert de server een socket-object aan zijn einde van de communicatie. De client en de server kunnen nu communiceren door naar de socket te schrijven en eruit te lezen.

De java.net.Socket-klasse vertegenwoordigt een socket, en de java.net.ServerSocket-klasse biedt een mechanisme voor het serverprogramma om te luisteren naar clients en verbindingen met hen tot stand te brengen.

Stappen bij het tot stand brengen van een TCP-verbinding

1. De server instantieert een ServerSocket-object, waarmee aangegeven wordt op welk poortnummer de communicatie moet plaatsvinden.
2. De server roept de accept()-methode van de ServerSocket-klasse aan. Deze methode wacht tot een client verbindt met de server op de gegeven poort.
3. Nadat de server wacht, instantieert een client een Socket-object, waarbij de servernaam en het poortnummer worden opgegeven om te verbinden.
4. De constructor van de Socket-klasse probeert de client te verbinden met de gespecificeerde server en poort. Als communicatie tot stand komt, heeft de client nu een Socket-object dat kan communiceren met de server.
5. Aan de serverkant retourneert de accept()-methode een referentie naar een nieuwe socket op de server die verbonden is met de client-socket.

Nadat de verbindingen tot stand zijn gekomen, kan communicatie plaatsvinden via I/O streams. Elke socket heeft zowel een OutputStream als een InputStream. De OutputStream van de client is verbonden met de InputStream van de server, en de InputStream van de client is verbonden met de OutputStream van de server.

TCP is een tweerichtingscommunicatieprotocol, dus data kan tegelijkertijd over beide streams worden verzonden.

ServerSocket Klasse Methodes

De java.net.ServerSocket-klasse wordt door serverapplicaties gebruikt om een poort te verkrijgen en te luisteren naar clientverzoeken.

De ServerSocket-klasse heeft vier constructors:

Als de ServerSocket-constructor geen uitzondering gooit, betekent dit dat je applicatie met succes gebonden is aan de gespecificeerde poort en klaar is voor clientverzoeken.

Veelgebruikte ServerSocket Methodes

Wanneer ServerSocket accept() aanroept, keert de methode niet terug tot een client verbindt. Nadat een client verbindt, creëert ServerSocket een nieuwe Socket op een ongespecificeerde poort en retourneert een referentie naar deze nieuwe Socket. Er bestaat nu een TCP-verbinding tussen client en server, en communicatie kan beginnen.

Socket Klasse Methodes

De java.net.Socket-klasse vertegenwoordigt de socket die zowel de client als de server gebruiken om met elkaar te communiceren. De client verkrijgt een Socket-object door er een te instantiëren, terwijl de server een Socket-object verkrijgt van de retourwaarde van de accept()-methode.

De Socket-klasse heeft vijf constructors die een client gebruikt om te verbinden met een server:

Wanneer de Socket-constructor terugkeert, instantiëert het niet zomaar een Socket-object, maar het probeert daadwerkelijk te verbinden met de gespecificeerde server en poort.

Interessante Socket Methodes

InetAddress Klasse Methodes

Deze klasse vertegenwoordigt een Internet Protocol (IP) adres. Hier zijn nuttige methodes voor socket programmeren:

Socket Client Voorbeeld

De volgende GreetingClient is een clientprogramma dat verbindt met een server via een socket, een groeting stuurt, en wacht op een reactie.

// Bestandsnaam: GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {
    public static void main(String[] args) {
        String serverName = args[0];
        int port = Integer.parseInt(args[1]);
        try {
            System.out.println("Verbinden met " + serverName + " op poort " + port);
            Socket client = new Socket(serverName, port);
            System.out.println("Zojuist verbonden met " + client.getRemoteSocketAddress());
            OutputStream outToServer = client.getOutputStream();
            DataOutputStream out = new DataOutputStream(outToServer);
            out.writeUTF("Hello from " + client.getLocalSocketAddress());
            InputStream inFromServer = client.getInputStream();
            DataInputStream in = new DataInputStream(inFromServer);
            System.out.println("Server zegt " + in.readUTF());
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Socket Server Voorbeeld

De volgende GreetingServer is een voorbeeld van een serverapplicatie die de Socket-klasse gebruikt om te luisteren naar clients op een poortnummer gespecificeerd als command-line argument:

// Bestandsnaam: GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
    private ServerSocket serverSocket;
    public GreetingServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        serverSocket.setSoTimeout(10000);
    }
    public void run() {
        while (true) {
            try {
                System.out.println("Wachten op client op poort " + serverSocket.getLocalPort() + "...");
                Socket server = serverSocket.accept();
                System.out.println("Zojuist verbonden met " + server.getRemoteSocketAddress());
                DataInputStream in = new DataInputStream(server.getInputStream());
                System.out.println(in.readUTF());
                DataOutputStream out = new DataOutputStream(server.getOutputStream());
                out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress() + "\nGoodbye!");
                server.close();
            } catch (SocketTimeoutException s) {
                System.out.println("Socket timed out!");
                break;
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
    }
    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        try {
            Thread t = new GreetingServer(port);
            t.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Compileer de client en server en start de server als volgt:

$ java GreetingServer 6066
Wachten op client op poort 6066...

Test de client:

$ java GreetingClient localhost 6066
Verbinden met localhost op poort 6066
Zojuist verbonden met localhost/127.0.0.1:6066
Server zegt Thank you for connecting to /127.0.0.1:6066
Goodbye!