An EchoService example written in Java to explain the basic concept of Java Networking APIs using a TCP connection.

README.md

• EchoServer Handle one request per EchoClient
• EchoClient Send a request to a EchoServer or EchoServerMultipleConnection
• EchoServerMultipleConnection Can handle multiple client request at the same time, but each client can send only one request.
• HandlerRequest Util class that process a client request.

You can found an explanation into Italian language here:

EchoClient.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

/**
 * Classe client che si interfaccia con EchoServer. Un client
 * può effettuare una sola richiesta del servizio per connessione.
 */

public class EchoClient {
    /*
        Nel client deve essere specificato sia l'hostname
        che la porta del server di destinazione.
     */
    private static final String HOSTNAME = "localhost";
    private static final int PORT = 65500;

    private final Socket clientSocket;
    private ObjectOutputStream output;
    private ObjectInputStream input;

    /**
     * La creazione dell'oggetto Socket crea automaticamente
     * una richiesta di connessione all'HOSTINAME e PORT
     * specificato nei parametri del costruttore.
     * @throws IOException
     */
    public EchoClient() throws IOException {
        this.clientSocket = new Socket(HOSTNAME, PORT);
    }

    /**
     * Invia il messaggio al server una volta effettuata la connessione.
     * @param message
     * @throws IOException
     */
    public void sendMessage(String message) throws IOException {
        output = new ObjectOutputStream(clientSocket.getOutputStream());
        output.writeObject(message); // vedi EchoServer
        output.flush();
    }

    /**
     * Riceve il messaggio di risposta del server.
     * @return message
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public String receiveMessage() throws IOException, ClassNotFoundException {
        input = new ObjectInputStream(clientSocket.getInputStream());
        String message = (String) input.readObject(); //Vedi EchoServer
        return message;
    }

    public static void main(String[] args) {
        try {
            EchoClient client = new EchoClient();
            client.sendMessage("Stringa");
            String message = client.receiveMessage();
            System.out.println(message);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

EchoServer.java

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;


/**
 * Classe server del servizio Echo. Questa classe restituisce al client
 * qualsiasi stringa inviata.
 */
public class EchoServer extends Thread {
    /**
     * Porta su cui il ServerSocket si lega.
     */
    private static final int PORT = 65500;

    /**
     * ServerSocket è un socket speciale, crea un nuovo Socket
     * ad ogni richiesta di connessione.
     */
    protected final ServerSocket serverSocket;

    /**
     * Il costruttore instanzia il ServerSocket su cui i client
     * effettueranno una richiesta di connessione.
     * @throws IOException
     */
    public EchoServer() throws IOException {
        this.serverSocket = new ServerSocket(PORT);
        start();
    }

    /**
     * Nel corpo del metodo run() i passaggi sono semplici:
     *  1. Viene creato un socket ad ogni richiesta di connessione.
     *  2. Viene letto il messaggio spedito.
     *  3. Lo stesso messaggio viene rispedito al mittende.
     *  4. Il server si rimette in ascolto per eventuali nuove richieste.
     */
    public void run() {
        while (true) {
            try {
                /*
                    serverSocket.accept() è una chiamata bloccante, ovvero
                    il server rimmarrà bloccato su questa chiamata di procedura
                    fintantoché non verrà effettuata una richiesta di connessione
                    da parte di un client.
                 */
                Socket clientSocket = serverSocket.accept();
                /*
                    I messaggi vengono scambiati tramite serializzazione di stringhe.
                    Per semplicità viene usata questa strategia, bisogna notare che è
                    possibile utilizzare qualsiasi classe Java che supporti la gestione
                    di un InputStream.
                 */
                ObjectInputStream input = new ObjectInputStream(clientSocket.getInputStream());
                String message = (String) input.readObject(); // lettura del messaggio
                /*
                    Vale come input.
                 */
                ObjectOutputStream output = new ObjectOutputStream(clientSocket.getOutputStream());
                System.out.println(message);
                output.writeObject(message);
                output.flush();
                // Richiesta gestita, poiché siamo in un ciclo infinito il server è pronto per gestire
                // una nuova connessione.
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            new EchoServer();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

EchoServerMultipleConnection.java

import java.io.IOException;
import java.net.Socket;

public class EchoServerMultipleConnection extends EchoServer {

    public EchoServerMultipleConnection() throws IOException {
        super();
    }

    @Override
    public void run() {
        while (true) {
            try {
                Socket clientSocket = serverSocket.accept();
                /*
                    Deleghiamo ad un Thread la gestione della richiesta da
                    parte del client. La JVM legherà automaticamente a livello
                    di sistema operativo il Socket al Thread.
                 */
                new Thread(new HandlerRequest(clientSocket)).start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            new EchoServerMultipleConnection();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HandlerRequest.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

/**
 * Classe di supporto per la gestione multipla di Client.
 */

public class HandlerRequest implements Runnable {
    /*
        Questo membro privato conserverà il riferimento
        del Socket restituito dalla chiamata
        serverSocket.accept()
     */
    private final Socket socket;

    public HandlerRequest(Socket socket) {
        this.socket = socket;
    }

    /*
        Il metodo run() si comporta allo stesso modo della gestione della richiesta
        di un client della classe EchoServer.
     */
    public void run() {
        try {
            ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
            String message = (String) input.readObject();
            ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
            System.out.println(message);
            output.writeObject(message);
            output.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}