[Java] - Remote et Observable

package jeu;
 
import java.rmi.*;
import java.util.*;
 
public interface Client extends Remote {
    // ici, il faut définir toutes les méthodes que le serveur doit pouvoir appeler
 
    public String getName () throws RemoteException;
    public void informerListeClients(Collection clients) throws RemoteException;
}

package jeu;
 
import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.*;
import java.util.*;
 
public class ClientImpl  
    extends UnicastRemoteObject  
    implements Client {
 
    protected String name;
    protected Serveur serveur;
 
    // constructeur obligatoire
    public ClientImpl(String name) throws RemoteException {
 this.name = name;  
    }  
 
    public String getName () throws RemoteException {
 return name;
    }
 
    public void informerListeClients(Collection clients) throws RemoteException {
 Iterator it = clients.iterator();
 System.out.println("liste des clients connectés : " );
 while (it.hasNext()) {
     System.out.println(" - " + it.next());
 }  
    }
 
 
    protected void connecter() throws Exception {
 try {
     serveur = (Serveur) Naming.lookup("//localhost/Serveur" );
 } catch(Exception e) {
     System.err.println("Impossible de trouver le serveur" );
     throw e;
 }
 try {
     serveur.connecter(this);
 } catch(RemoteException e) {
     System.err.println("Impossible de se connecter au serveur" );
     throw e;
 }
 
    }
 
    protected void deConnecter() throws RemoteException {
 try {
     serveur.deConnecter(this);
 } catch(RemoteException e) {
     System.err.println("Impossible de se déconnecter du serveur" );
     throw e;
 }
    }
 
 
    public static void main(String[] args) throws Exception {
 if ((args.length==0) || (args[0].equals("-?" ))) {
     System.err.println("usage : \n java jeu.ClientImpl nomDuClient\n" );      
 }
 String name = args[0];
 ClientImpl client = new ClientImpl(name);
 
 client.connecter();
 System.out.println("client " + name + " connecté\n" );
 
 System.out.println("<< Appuyez sur Entrée pour déconnecter le client >>" );
 System.in.read();
 
 client.deConnecter();
 System.out.println("client " + name + " déconnecté\n" );
 
 System.exit(0);
    }
     
}

package jeu;
 
import java.rmi.*;
 
public interface Serveur extends Remote {
    // ici, il faut définir toutes les méthodes que les clients doivent pouvoir appeler
 
    public void connecter(Client c) throws RemoteException;
    public void deConnecter(Client c) throws RemoteException;
}

package jeu;
 
import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.*;
import java.util.*;
 
public class ServeurImpl  
    extends UnicastRemoteObject  
    implements Serveur {
 
    protected Collection clients;
    protected Collection nomsClients;
 
    // constructeur obligatoire
    public ServeurImpl() throws RemoteException {
 clients = new ArrayList();
 nomsClients = new ArrayList();
    }  
 
    public void connecter(Client c) throws RemoteException {
 String nom = c.getName();
 clients.add(c);
 nomsClients.add(nom);
 System.out.println(nom + " est connecté" );
 diffuserListeClients();
    }
 
    public void deConnecter(Client c) throws RemoteException {
 String nom = c.getName();
 clients.remove(c);
 nomsClients.remove(nom);
 System.out.println(nom + " s'est déconnecté" );
 diffuserListeClients();
    }
 
    protected void diffuserListeClients() {  
 try {
     Iterator it = clients.iterator();
     while (it.hasNext()) {
  ((Client) it.next()).informerListeClients(nomsClients);
     }  
 } catch (RemoteException  e) {
     System.err.println("Erreur RMI lors de la diffusion de la liste des clients connectés : " + e);
     e.printStackTrace(System.err);
 }  
    }
 
    public static void main(String[] args) throws Exception {
 //System.setSecurityManager(new RMISecurityManager());
 
 // lance le registre sur le port (1099 par defaut)
 LocateRegistry.createRegistry(1099);
 
 // créé et enregistre le serveur dans le registre
 Serveur serveur = new ServeurImpl();
 Naming.bind("//localhost/Serveur", serveur);
 System.out.println("Serveur en attante ..." );
    }
     
}

rmic jeu.ServeurImpl
rmic jeu.ClientImpl

java jeu.ServeurImpl
java jeu.ClientImpl toto
java jeu.ClientImpl titi
java jeu.ClientImpl tutu

Résumons. Tu veux que tes clients recçoivent la liste des autres joueurs connectés au serveur, et que celles-ci se mette à jour lorsqu'un nouveau joueur se connecte.
 
Dans ce problème, l'objet Observé est le serveur, qui contient la liste des clients. Les clients sont les observeurs : ils observent une modification du serveur (un nouveau joueur se connecte).
 
Pour être au courant des évenements du serveur, les clients vont devoir s'abonner au serveur. Il faut donc qu'il y ait une méthode d'abonnement sur ton objet serveur, et que le serveur gère une liste des clients abonnés. :
 
 
 
import java.util.*;
 
public class Serveur {
 protected Collection clientsAbonnes = new ArrayList();
 ...  
 public abonner(Client client) {
    clientsAbonnes.add(client);
 }
 ...
}
 
remarque : pour faire propre il faudrait aussi gérer les désabonnement, mais bon ...    
 
On va dire que ton Client possède une méthode qui lui permet de remettre  jour la liste des joueur connectés :
 
 
public class Client {
  ...
  public void mettreAJourListeJoueurs(String[] joueurs) {
      ...
  }
  ...
}
 
 
ce qu'il suffit ensuite de faire c'est que lorsque le Serveur reçoit une nouvelle connection d'un de tes clients, il met à jour sa liste interne de joueurs puis la diffuse à tous les clients abonnés.
 
 
 
  ...
  Iterator it = clientsAbonnes.iterator();
  while (it.hasNext()) {
     ((Client)it.next()).mettreAJourListeJoueurs(listeInterneDeJoueurs);
  }
  ...