Discussion :

[damic]

Salut,

j'ai un soucis de compréhension concernant le RMI et la possibilité de simuler plusieurs clients

Pour résumer j'ai un annuaire (objet distant) et je dois simuler plusieurs clients pouvant ajouter (put) ou retrouver (get) un numéro

je vous présente mon code

interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public interface Directory extends Remote {
    void put(String nom, String num) throws RemoteException;
    String get(String nomCherche) throws RemoteException;
}

class implementant l'interface

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class DirectoryImpl extends UnicastRemoteObject implements Directory {
 
    HashMap<String, String> annuaire = new HashMap<String, String>();
 
    protected DirectoryImpl() throws RemoteException {
        super();
    }
 
    //ajout dans la map
    public void put(String nom, String num) throws RemoteException {
        annuaire.put(nom, num);
    }
 
    //methode renvoyant le resultat d'une recherche
    public String get(String nomCherche) throws RemoteException {
        String num = annuaire.get(nomCherche);
        return num;
    }
}

serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ServerImpl {
 
    public static void main(String[] args) {
        try {
            //creation registre
            Registry r = LocateRegistry.createRegistry(1099);
            //instance de la class
            DirectoryImpl dI = new DirectoryImpl();
            //instance enregistré dans le registre
            r.rebind("directory", dI);
 
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
 
}

et enfin client

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Client1 { 
    public static void main(String[] args) {
        try {
 
 
            Directory d = ((Directory)Naming.lookup("rmi://localhost/directory"));
            Directory d2 = ((Directory)Naming.lookup("rmi://localhost/directory"));
            d.put("Pierre", "0608");
            d2.put("Gerrard", "0609");
            System.out.println(d2.get("Pierre"));
 
        } catch (MalformedURLException | RemoteException | NotBoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
 
}

Je suppose que ce code ne simule pas du tout plusieurs clients, je me demande comment faire, je suppose qu'il doit y avoir une histoire de thread mais je n'arrive pas à comprendre.
Pour commencer j'aimerai simuler plusieurs clients mais de manière séquentielle, sans concurrence voir déjà si j'arrive a comprendre

Si vous pouvez m'aider

ps : il n'y a pas d'erreur de fonctionnement, tout marche et Pierre est bien trouvé dans le hashMap

[Gugelhupf]

Pour commencer j'aimerai simuler plusieurs clients mais de manière séquentielle, sans concurrence voir déjà si j'arrive a comprendre

Je pense que c'est ce que tu fais déjà dans ton exemple, les méthodes exécutés par tes deux objets (d et d2) sont synchrones, donc tu fais du séquentiel.

La première chose à laquelle tu dois faire gaffe, c'est que RMI est une architecture SOA, ton implémentation de la classe Directory n'est pas censé avoir d'attribut car ton objet peut potentiellement être détruit et ré-instancié par le serveur si le service n'est pas sollicité. A la limite tu peux utiliser un attribut static. Ensuite, comme tu es toujours dans une architecture SOA, il faut faire gaffe à ton environnement qui est multithread, HashMap n'est pas threadsafe (c'est-à-dire que tu ne doit pas l'utiliser dans un environnement multithread), mais tu peux le rendre threadsafe.

Je pense que si tu souhaites "simuler" plusieurs clients "à la fois", tu peux juste utiliser un stub et exécuter des actions via un pool de thread :

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.*;
import java.util.concurrent.*;
import java.lang.*;
import java.io.*;
 
// J'ai mocké ta classe Directory
class Directory {
    private static Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
 
    public void put(String key, String value){
        map.put(key, value);
    }
 
    public Map<String, String> getMap(){
        return map;
    }
}
 
class DemoClients {
    public final static int SIZE = 3; // Nombre de client
 
    public static void main (String[] args) throws java.lang.Exception {
        Directory d = new Directory(); // <=> Naming.lookup("rmi://localhost/directory");
 
        // L'action que doit effectuer chacun de tes clients est représenté par un callable
        Callable<Object>[] callables = new Callable[SIZE];
        for(int i = 0; i < SIZE; i++){
            final int i2 = i; 
            callables[i] = () -> {
                d.put("name"+i2, "value"+i2);
                return null;
            };
        }
 
        // Exécution des actions de tes clients via un pool de thread (cf: non-séquentiel)
        ExecutorService es = Executors.newFixedThreadPool(SIZE);
        es.invokeAll(Arrays.asList(callables));
        es.shutdown();
 
        // Affichage 
        for (Map.Entry<String, String> e : d.getMap().entrySet()) {
            System.out.println("Key : " + e.getKey() + " Value : " + e.getValue());
        }
    }
}

Lien de la démo : http://ideone.com/bEFtQO

J'ai essayé de commenter pour que tu comprennes mieux, mais si tu as des questions n'hésite pas