Discussion :

[alex2746]

Bonjour,
Je voudrais écrire un petit programme de chat en utilisant RMI.
Le but est de mettre en communication 2 personnes entre elles (une personne étant un professeur et l'autre étant un élève).

L'élève lancera donc son programme PgmEleve et le professeur son programme de professeur: PgmProfesseur et un système s'occupera de mettre n'importe quel élève disponible en communication chat avec n'importe quel professeur disponible (en sachant qu'un élève ne peut parler qu'avec un seul professeur et un professeur avec un seul élève).

Je voulais donc implémenter de la façon suivante:
1/ Au début l'élève et le professeur sont considérés comme des CLIENTS.
2/ Une fois qu'ils ont lancé lancé leur programme, l'élève devient un client et le professeur devient un serveur. (ils sont mis en communication grâce à leur adresse ip par exemple)

La seule chose que j'ai réussi à faire pour le moment est d'avoir un petit chat en mode console qui me permet de lancer le serveur et ensuite de lancer plusieurs clients (mais qui sont de même type). Cela fonctionne, mais ce n'est pas un chat entre seulement 2 personnes, c'est un chat entre plusieurs Clients...

Voila le code:

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
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
public interface ChatClient extends Remote {
 
    void receive(String s) throws RemoteException;
}
 
public class ChatClientImpl extends UnicastRemoteObject implements ChatClient, Runnable {
 
    private ChatServer mycs;
 
    public ChatClientImpl(ChatServer cs) throws RemoteException {
        mycs = cs;
        mycs.register(this);
    }
 
    public synchronized void receive(String s) throws RemoteException {
        System.out.println("Message :" + s);
    }
 
    public void run() {
        Scanner in = new Scanner(System.in);
        String msg;
 
        while (true) {
            try {
                msg = in.nextLine();
                mycs.broadcast(msg);
            } catch (Exception e) {
                System.err.println("problem");
            }
        }
    }
 
    public static void main(String[] args) {
        String url = "rmi://localhost/ChatServer";
        try {
            ChatServer cs = (ChatServer) Naming.lookup(url);
            new Thread(new ChatClientImpl(cs)).start();
        } catch (Exception e) {
            System.err.println("Problem");
        }
    }
}
 
public interface ChatServer extends Remote {
 
    void register(ChatClient c) throws RemoteException;
 
    void broadcast(String s) throws RemoteException;
}
 
public class ChatServerImpl extends UnicastRemoteObject implements ChatServer {
 
    private LinkedList <ChatClient> myclients ;
 
    public ChatServerImpl() throws RemoteException {
        myclients = new LinkedList();
    }
 
    public synchronized void register(ChatClient c) throws RemoteException {
        myclients.add(c);
    }
 
    public synchronized void broadcast(String s) throws RemoteException {
        for (int i = 0; i < myclients.size(); i++) {
            myclients.get(i).receive(s);
        }
    }
 
    public static void main(String[] args) {
        try {
            Naming.rebind("ChatServer", new ChatServerImpl());
        } catch (Exception e) {
            System.err.println("Problem");
        }
    }
}

Pourriez vous m'aider à l'améliorer?

Merci d'avance.

[benratti]

Comment souhaites tu que l'on t'aide? Peux tu préciser ta demande?

[alex2746]

Dans un premier temps j'aimerais savoir si mon code vous semble correct.
Ensuite j'aurais besoin d'aide pour transformer mon code en un code qui distingue bien l'élève du professeur et qui ne permet de faire parler que deux personnes entre elles (un prof + un élève).

[benratti]

Ton cas s'adapte très bien à l'héritage de classe. Je définirais les classes suivantes

• AbstractClient : classe abstraite qui intègre les mécanismes de connexion au serveur, ainsi que les mécanismes de communication entre deux clients (dialogue du chat)
• EtudiantClient : classe qui hérite de AbstractClient et qui implémente en plus des mécanismes de connexion directe ) un professeur
• ProfesseurClient : classe qui hérite également de AbstractClient et qui implémente l'ouverture de la partie serveur qui attend la connexion d'un client