Salta el contingut
 

Exemple: Enviament d'objectes

Joan Puigcerver Ibáñez

j.puigcerveribanez@edu.gva.es

Llicència: CC BY-NC-SA 4.0

(Reconeixement - NoComercial - CompartirIgual) 🅭

License

Objectius

Aquest exemple mostra com es pot crear un servidor i un client capaços de comunicar-se mitjançant l'enviament d'objectes.

Codi font

ud3.examples.cinema

  • Models:

    Film.java
    package ud3.examples.cinema.models;

import java.io.Serializable;

/**
 * Classe que representa una pel·licula.
 * <p>
 * Aquesta classe implementa Serialitzable per poder ser convertida a
 * bytes i poder ser enviada mitjançant sockets.
 */
public class Film implements Serializable {
    /**
     * Nom de la pel·licula
     */
    private String name;
    /**
     * Any de publiacació
     */
    private int releaseYear;
    /**
     * Duració de la pel·lícula en minuts
     */
    private int duration;

    /**
     * Constructor
     * @param name Nom de la pel·lícula
     * @param releaseYear Any de publicació
     * @param duration Duració de la pel·lícula
     */
    public Film(String name, int releaseYear, int duration) {
        this.name = name;
        this.releaseYear = releaseYear;
        this.duration = duration;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getReleaseYear() {
        return releaseYear;
    }

    public void setReleaseYear(int releaseYear) {
        this.releaseYear = releaseYear;
    }

    public int getDuration() {
        return duration;
    }

    public void setDuration(int duration) {
        this.duration = duration;
    }

    /**
     * Obté la representació de la pel·lícula en String
     * @return Representació de la pel·lícula
     */
    @Override
    public String toString() {
        return "Film{" +
                "name='" + name + '\'' +
                ", releaseYear=" + releaseYear +
                ", duration=" + duration +
                '}';
    }
}
    CinemaMessage.java
    package ud3.examples.cinema.models;

import java.io.Serializable;

/**
 * Classe que representa una petició o resposta entre el servidor i el client.
 * <p>
 * Aquesta classe implementa Serialitzable per poder ser convertida a
 * bytes i poder ser enviada mitjançant sockets.
 *
 * @see CinemaMessageType
 * @param type Tipus de petició (GET/POST/SUCCESS/ERROR)
 * @param object Objecte que es pot adjuntar a la comunicació
 * @param message Missatge opcional que es pot adjuntar a la comunicació
 */
public record CinemaMessage(
        CinemaMessageType type,
        Object object,
        String message
) implements Serializable {
}
    CinemaMessageType.java
    package ud3.examples.cinema.models;

import java.io.Serializable;

/**
 * Enumeració amb els diferents tipus de peticions que podem trobar
 * <p>
 * Aquesta classe implementa Serialitzable per poder ser convertida a
 * bytes i poder ser enviada mitjançant sockets.
 */
public enum CinemaMessageType implements Serializable {
    /**
     * El tipus GET s'utilitza per sol·licitar algun element del servidor
     */
    GET,
    /**
     * El tipus POST s'utilitza per enviar algun element al servidor
     */
    POST,
    /**
     * El tipus SUCCESS s'utilitza per indicar que l'acció s'ha dut a terme correctament
     */
    SUCCESS,
    /**
     * El tipus ERROR s'utilitza per indicar que l'acció no s'ha dut a terme correctament
     */
    ERROR
}

  • Servidor:

    CinemaServer.java
    package ud3.examples.cinema.server;

import ud3.examples.cinema.models.Film;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * CinemaServer és un servidor TCP/IP que gestiona pel·lícules.
 * <p>
 * Actualment perme't obtindre pel·licules del servidor mitbançant la petició "GET"
 * i afegir pel·licules mitjançant la petició "POST"
 *
 * @author Joan Puigcerver
 */
public class CinemaServer {
    private final ServerSocket server;
    private final List<CinemaServerHandler> clients;
    private final List<Film> films;
    private boolean running;

    /**
     * Crea un servidor CinemaServer en el port port especificat.
     *
     * @param port Port on escoltarà el servidor
     * @throws IOException Excepcions del constructor ServerSocket
     */
    public CinemaServer(int port) throws IOException {
        server = new ServerSocket(port);
        clients = new ArrayList<>();
        films = new ArrayList<>();
        running = true;
    }

    /**
     * Afig una pel·licula al servidor.
     * @param film Pel·licula que s'afegirà
     */
    public void addFilms(Film film){
        films.add(film);
    }

    /**
     * Obté les pel·licules disponibles en el servidor
     * @return Llista de pel·licules en el servidor
     */
    public List<Film> getFilms(){
        return films;
    }

    /**
     * Obté la pel·lícula identificada per un id. Actualment l'id és
     * la posició en la llista.
     * @param id id de la pel·lícula
     * @return Pel·lícula amb l'id especificada.
     */
    public Film getFilm(int id){
        return films.get(id);
    }

    /**
     * Esborra un client de la llista de clients
     * @param client Client que es vol esborrar
     */
    public void removeClient(CinemaServerHandler client){
        clients.remove(client);
    }

    /**
     * Fil d'execució del servidor.
     * <p>
     * El servidor escolta el port i espera noves connexions.
     * Quan una nou client es connecta, es crea un objecte CinemaServerHandler,
     * que gestionarà la comunicació amb aquest client en un fil distint.
     * <p>
     * D'aquesta manera, el servidor pot continuar escoltant i esperant
     * noves connexions mentres cada fil gestiona la comunicació
     * amb cada client.
     */
    public void run() {
        while (running){
            try {
                // Escolta i esperà una nova connexió.
                Socket client = server.accept();
                // Quan un client es connecta, es crea un objecte CinemaServerHandler que
                // gestionarà la comunicació amb el client connectat.
                System.out.println("Nou client acceptat.");
                CinemaServerHandler handler = new CinemaServerHandler(client, this);
                clients.add(handler);
                // S'inicia CinemaServerHandler en un fil independent
                handler.start();
            } catch (IOException e) {
                System.err.println("Error while accepting new connection");
                System.err.println(e.getMessage());
            }
        }
    }

    /**
     * Inicia un servidor CinemaServer en el port 1234
     * @param args Arguments del programa. No se'n utilitza cap.
     */
    public static void main(String[] args) {
        try {
            CinemaServer server = new CinemaServer(1234);
            server.run();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}
    CinemaServerHandler.java
    package ud3.examples.cinema.server;

import ud3.examples.cinema.models.CinemaMessageType;
import ud3.examples.cinema.models.Film;
import ud3.examples.cinema.models.CinemaMessage;

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

/**
 * Classe que gestiona la comunicació del servidor
 * amb un únic client en un fil d'execució independent.
 */
public class CinemaServerHandler extends Thread {
    /**
     * Socket que permet comunicar-se amb el client.
     */
    private final Socket client;
    /**
     * Servidor CinemaServer
     */
    private final CinemaServer server;
    /**
     * Objecte ObjectInputStream que permet rebre objectes pel Socket.
     */
    private final ObjectInputStream objIn;
    /**
     * Objecte ObjectOutputStream que permet enviar objectes pel Socket.
     */
    private final ObjectOutputStream objOut;

    /**
     * Constructor que inicialitza els canals de comunicació a partir de l'objecte Socket.
     * @param client Socket per comunicar-se amb el client.
     * @param server Servidor
     * @throws IOException Llançada si hi ha algun error creant els canals de comunicació
     */
    public CinemaServerHandler(Socket client, CinemaServer server) throws IOException {
        this.client = client;
        this.server = server;
        objIn = new ObjectInputStream(client.getInputStream());
        objOut = new ObjectOutputStream(client.getOutputStream());
    }

    /**
     * Fil d'execució independent per cada client.
     * <p>
     * El servidor espera peticions (CinemaMessage) i contesta a elles.
     * <p>
     * Si es del tipus POST, afegirà la pel·licula rebuda al servidor.
     * Si es del tipus GET, enviarà la pel·licula sol·licitada al client.
     */
    @Override
    public void run() {
        try {
            // Obtenim objectes del tipus CinemaMessage del client fins que aquest es desconnecte.
            CinemaMessage req;
            while((req = (CinemaMessage) objIn.readObject()) != null){
                if (req.type() == CinemaMessageType.POST){
                    // Si la petició és del tipus POST
                    // Recuperem la pel·licula de la petició
                    Film film = (Film) req.object();
                    // Afegim la pel·lícula al servidor
                    server.addFilms(film);

                    // Enviem una resposta del tipus SUCCESS al client
                    // indicant que la pel·licula s'ha afegit correctament
                    String message = String.format("Film %s added.", film);
                    CinemaMessage response = new CinemaMessage(CinemaMessageType.SUCCESS, null, message);
                    System.out.println(message);
                    objOut.writeObject(response);

                } else if (req.type() == CinemaMessageType.GET) {
                    // Si la petició és del tipus GET
                    // Recuperem la ID de pel·licula de la petició
                    int id = (Integer) req.object();

                    // Enviem una resposta al client
                    CinemaMessage response;
                    if(id >= server.getFilms().size())
                        // Si no existeix la pel·licula, enviem una resposta del tipus ERROR
                        response = new CinemaMessage(CinemaMessageType.ERROR, null,
                                String.format("No s'ha trobat cap pel·licula amb id %d", id));
                    else
                        // Si existeix la pel·licula, enviem una resposta del tipus SUCCESS amb la pel·licula solicitada
                        response = new CinemaMessage(CinemaMessageType.SUCCESS, server.getFilm(id), "");

                    // Enviem la resposta
                    objOut.writeObject(response);
                }
            }
            client.close();
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("Error while handling client.");
            System.err.println(e.getMessage());
        } finally {
            this.server.removeClient(this);
        }
    }
}

  • Client:

    CinemaClient.java
    package ud3.examples.cinema.client;

import ud3.examples.cinema.models.CinemaMessage;
import ud3.examples.cinema.models.CinemaMessageType;
import ud3.examples.cinema.models.Film;

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

/**
 * Client que es connecta a un CinemaServer
 * i permet realitzar les accions de afegir o obtenir
 * pel·lícules del servidor
 */
public class CinemaClient {
    /**
     * Socket que permet connectar-se amb el servidor
     */
    private final Socket socket;
    /**
     * Scanner per interactuar amb l'usuari
     */
    private final Scanner scanner;
    /**
     * Canal de comuncació per rebre objectes del servidor mitjançant el socket.
     */
    private final ObjectInputStream objIn;
    /**
     * Canal de comuncació per enviar objectes al servidor mitjançant el socket.
     */
    private final ObjectOutputStream objOut;

    /**
     * Constructor del client.
     * Es connecta al servidor indicat i inicialitza els cannals de comunicació i el Scanner.
     * @param host Direciió del servidor
     * @param port Port on escolta el servidor
     * @throws IOException Llançada si hi ha algun error connectant-se al servidor.
     */
    public CinemaClient(String host, int port) throws IOException {
        this.scanner = new Scanner(System.in);

        this.socket = new Socket(host, port);
        this.objOut = new ObjectOutputStream(socket.getOutputStream());
        this.objIn = new ObjectInputStream(socket.getInputStream());
    }

    /**
     * Envia una pel·licula al servidor
     * @param f Pel·lícula
     * @throws IOException Llançada si hi ha un error al enviar la pel·lícula o rebent una resposta
     * @throws ClassNotFoundException Llançada si l'objecte rebut pel servidor no és d'una classe coneguda.
     */
    private void sendFilm(Film f) throws IOException, ClassNotFoundException {
        // Creem una petició POST amb la pel·lícula
        CinemaMessage req = new CinemaMessage(CinemaMessageType.POST, f, "");
        // Enviem la petició
        objOut.writeObject(req);

        // Esperem una resposta del servidor
        CinemaMessage response = (CinemaMessage) objIn.readObject();

        // Comprovem si hi ha hagut algun error i mostrem el missatge de reposta
        if(response.type() == CinemaMessageType.ERROR)
            System.err.printf("ERROR: %s\n", response.message());
        else if(response.type() == CinemaMessageType.SUCCESS)
            System.out.printf("%s\n", response.message());
    }
    /**
     * Reb una pel·lícula del servidor a partir de la seua ID
     * @param id ID de la pel·lícula
     * @return Pel·licula rebuda pel servidor; null si hi hagut algun error.
     * @throws IOException Llançada si hi ha un error al rebre la pel·lícula
     * @throws ClassNotFoundException Llançada si l'objecte rebut pel servidor no és d'una classe coneguda.
     */
    private Film receiveFilm(int id) throws IOException, ClassNotFoundException {
        // Creem una petició del tipus GET amb la ID
        CinemaMessage req = new CinemaMessage(CinemaMessageType.GET, id, "");
        // Enviem la petició
        objOut.writeObject(req);

        // Esperem una resposta del servidor
        CinemaMessage in = (CinemaMessage) objIn.readObject();

        // Si hi ha hagut algun error, mostrem el missatge
        if(in.type() == CinemaMessageType.ERROR)
            System.err.printf("ERROR: %s\n", in.message());

        // Retornem l'objecte rebut
        return (Film) in.object();
    }

    /**
     * Mostra les accions del menú
     */
    private void printMenuActions(){
        System.out.println("1. Afegir pel·lícula.");
        System.out.println("2. Obtenir pel·lícula.");
        System.out.println("0. Eixir.");
    }

    /**
     * Demana una elecció vàlida a l'usuari (0 fins max incluït)
     * Si l'usuari no indica una elecció vàlida, li tornarà a preguntar.
     * @param max Elecció màxima
     * @return Elecció de l'usuari
     */
    private int askUserAction(int max){
        System.out.print("Introdueix la teua elecció: ");
        int action = scanner.nextInt();
        scanner.nextLine();

        while (action < 0 || action > max){
            System.out.print("La elecció introduida no està entre els valors vàlids.");
            System.out.print("Introdueix la teua elecció: ");
            action = scanner.nextInt();
            scanner.nextLine();
        }

        return action;
    }

    /**
     * Mostra el menu principal de l'aplicació.
     */
    public void menu(){
        boolean exit = false;
        while(!exit) {
            printMenuActions();
            int action = askUserAction(2);
            switch (action){
                case 0 -> {
                    exit = true;
                }
                case 1 -> {
                    try {
                        addFilm();
                    } catch (IOException | ClassNotFoundException e) {
                        System.err.println("Error afegint una pel·lícula.");
                    }
                }
                case 2 -> {
                    try {
                        getFilm();
                    } catch (IOException | ClassNotFoundException e) {
                        System.err.println("Error obtenint una pel·lícula.");
                    }
                }
            }
        }
        try {
            this.socket.close();
        } catch (IOException ignored) {
        }
    }

    /**
     * Interactua amb l'usuari per afegir una pel·lícula al servidor.
     * @throws IOException Llançada si hi ha un error al afegir la pel·lícula
     * @throws ClassNotFoundException Llançada si l'objecte rebut pel servidor no és d'una classe coneguda.
     */
    private void addFilm() throws IOException, ClassNotFoundException {
        System.out.println("AFEGIR PEL·LÍCULA");
        System.out.print("Introdueix el nom de la pel·lícula: ");
        String nom = scanner.nextLine();
        System.out.print("Introdueix el any de publicació de la pel·lícula: ");
        int year = scanner.nextInt();
        System.out.print("Introdueix la duració de la pel·lícula: ");
        int duration = scanner.nextInt();
        Film film = new Film(nom, year, duration);
        sendFilm(film);
    }

    /**
     * Interactua amb l'usuari per obtindre una pel·lícula al servidor.
     * @throws IOException Llançada si hi ha un error al obtindre la pel·lícula
     * @throws ClassNotFoundException Llançada si l'objecte rebut pel servidor no és d'una classe coneguda.
     */
    private void getFilm() throws IOException, ClassNotFoundException {
        System.out.println("OBTENIR PEL·LÍCULA");
        System.out.print("Introdueix la id de la pel·lícula: ");
        int id = scanner.nextInt();
        Film film = receiveFilm(id);
        if (film != null)
            System.out.printf("S'ha obtingut la pel·lícula %s.\n", film);
    }

    /**
     * Inicia el client
     * @param args Arguments del programa. No s'utilitzen.
     */
    public static void main(String[] args) {
        System.out.println("Connectant-se amb el servidor...");
        try {
            CinemaClient cinema = new CinemaClient("localhost", 1234);
            cinema.menu();
        } catch (IOException e){
            System.err.println("Error connectant-se amb el servidor.");
        }
    }
}

Models: CinemaMessage, CinemaMessageType i Film

L'objectiu principal de l'aplicació és gestionar pel·lícules. Per això s'ha creat la classe Film, que representa una pel·lícula. L'aplicació ha de permetre enviar pel·lícules en els dos sentits i, per indicar al servidor quina acció es vol realitzar, s'ha creat l'enumeració CinemaMessageType, que classifica cada petició en els tipus següents:

  • GET: el client envia una petició d'aquest tipus al servidor per sol·licitar-li una pel·lícula.
  • POST: el client envia una petició d'aquest tipus al servidor per enviar-li una pel·lícula.
  • SUCCESS: el servidor respon amb aquest tipus si l'acció sol·licitada s'ha portat a terme correctament.
  • ERROR: el servidor respon amb aquest tipus si hi ha hagut algun error en processar l'acció sol·licitada.

Per últim, s'ha creat l'objecte CinemaMessage, que representa una petició al servidor o una resposta al client. Està implementat com un record de Java i conté el tipus de missatge (CinemaMessageType), un Object que es pot adjuntar i un missatge (String).

Aquesta classe està pensada per ser enviada mitjançant un ObjectOutputStream i rebuda per un ObjectInputStream, que es poden crear amb el OutputStream i el InputStream del Socket, respectivament.

  • Client:

    ObjectOutputStream objOut = new ObjectOutputStream(socket.getOutputStream());
CinemaMessage req = new CinemaMessage(
    CinemaMessageType.POST, new Film("La vida es bella", 1997, 116)
);
objOut.writeObject(req);

  • Servidor:

    ObjectInputStream objIn = new ObjectInputStream(socket.getInputStream());
CinemaMessage req = (CinemaMessage) objIn.readObject();
if (req.getType() == CinemaMessageType.POST) {
    Film film = (Film) req.getObject();
}

Perquè es puguen enviar mitjançant sockets, les classes han d'implementar la interfície Serializable.

Els objectes s'han de poder convertir a un array de bytes, i la interfície Serializable ho indica.

Client: CinemaClient

Aquesta classe implementa un programa que es connecta al servidor i proporciona un menú per afegir i rebre pel·lícules del servidor.

Servidor: CinemaServer i CinemaServerHandler

La classe CinemaServer implementa un servidor que gestiona pel·lícules. Aquest servidor escolta en el port especificat i espera que els clients es connecten. Cada vegada que un client es connecta, es crea un objecte CinemaServerHandler, que s'executa en un fil independent i gestiona la comunicació amb el client.

La classe CinemaServerHandler s'encarrega de gestionar les peticions del client:

  • Si la petició és del tipus POST, rep una pel·lícula i l'afig al servidor.
  • Si la petició és del tipus GET, busca la pel·lícula sol·licitada i la retorna al client.

Ampliacions

Si has acabat l'exemple anterior, pots aprofundir amb aquestes propostes:

  • Permet que el client puga demanar al servidor la llista de pel·lícules disponibles.
  • Permet que el client puga eliminar una pel·lícula existent al servidor.

Totes les funcionalitats han de ser tolerants a tots els possibles errors, que cal gestionar.

📌 Aquest document pot quedar desactualitzat després d’imprimir-lo. Pots consultar la versió més recent a la pàgina web.
🌿 Abans d’imprimir aquest document, considera si és realment necessari. Redueix el consum de paper i ajuda a protegir el nostre entorn.
 
CC BY-NC-SA 4.0 (Reconeixement - NoComercial - CompartirIgual) 🅭 Joan Puigcerver Ibáñez