Activation d'une seule fenêtre

**zpico** · 14/03/2012, 14h14

Bonjour,

j'ai un petit problème sur la fenêtre client , en faite je veux empêcher l'ouverture de la même fenêtre client quand y a déja une ouverte est connecté pour le meme client ... bref limité chaque client par une seul fenetre ...ne pas créer double fenetre pour le meme client.j'espère que ma question est claire

merci encore

A+

**wax78** · 14/03/2012, 14h19

De quelle fenêtre client nous parles tu la ?

Tu parles de n'instancier qu'une seule et unique fois une application ?

Si ce n'est que ca, ceci feras ton bonheur : http://rom.developpez.com/java-instance-unique/

**Proxy** · 14/03/2012, 15h01

Je pense qu'un client est un objet dans son cas. Et qu'il peut ouvrir une fenêtre avec les informations de chaque client, mais qu'un client ne peut être ouvert 2x.

Dans ce cas, ajoute un attribut de type boolean à l'objet client pour savoir si c'est déjà ouvert ou pas.
Genre :

private boolean frameOpen;

Tu initialises à false, tu mets true quand tu ouvres et tu remets false quand tu fermes. Avec un petit if à l'appel de la fenêtre et ça devrait marcher.

Maintenant il y a peut-être une méthode qui permet de faire cela plus simplement, mais je n'en sais pas plus.

**zpico** · 15/03/2012, 08h20

Envoyé par wax78

De quelle fenêtre client nous parles tu la ?

Tu parles de n'instancier qu'une seule et unique fois une application ?

Si ce n'est que ca, ceci feras ton bonheur : http://rom.developpez.com/java-instance-unique/

OK merci je vais testé ça. et voire ..

A+

**deathness** · 15/03/2012, 09h00

Il faut simplement une liste de client déjà co sur le serveur, et la regarder à chaque demande d'ouverture.

**zpico** · 15/03/2012, 10h19

Envoyé par wax78

De quelle fenêtre client nous parles tu la ?

Tu parles de n'instancier qu'une seule et unique fois une application ?

Si ce n'est que ca, ceci feras ton bonheur : http://rom.developpez.com/java-instance-unique/

Bonjour,

Effectivement c'est ça ce que je cherche mais je n'arrive pas à mettre en place la classe qui empache d'autre instanciation voici un exemple didactique pour essayé de mettre la classe cité sur le document (du lien):
le but est d'empêcher l'instanciation de la fenêtre plusieurs fois :

le code de la classe fenetre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class fenetre_unique extends JFrame
{
 
		public fenetre_unique()
		{			
          this.setTitle("Ma première fenêtre java");          //Définit un titre pour votre fenêtre        
          this.setSize(400, 500);                             //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut      
          this.setLocationRelativeTo(null);                    //Nous allons maintenant dire à notre objet de se positionner au centre       
          this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //Ferme-toi lorsqu'on clique sur "Fermer" !           
          this.setVisible(true);
		}           
 
}

le code de la classe qui empahe d'autre instancition de la classe fenetre (celui du lien)

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
 
// Port à utiliser pour communiquer avec l'instance de l'application lancée.
final int PORT = 32145;
// Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.
final String MESSAGE = "nomDeMonApplication";
// Actions à effectuer lorsqu'une autre instance essaye de démarrer.
final Runnable RUN_ON_RECEIVE = new Runnable() {
    public void run() {
        // On exécute ce runnable dans l'EDT
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                if(mainFrame != null) {
                    // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
                    if(!mainFrame.isVisible())
                        mainFrame.setVisible(true);
                    // On demande à la mettre au premier plan.
                    mainFrame.toFront();
                }
            }
        });
    }                   
});
 
UniqueInstance uniqueInstance = new UniqueInstance(PORT, MESSAGE, RUN_ON_RECEIVE);
// Si aucune autre instance n'est lancée...
if(uniqueInstance.launch()) {
    // On démarre l'application.
    new MonApplication();
}

1- ma question est comment faire pour fonctionner ça ? (désolé si ma question est un peu bête mais je n'arrive pas à voir la chose)

A+

**wax78** · 15/03/2012, 14h28

Ne sachant trop ce qui te bloque, j'imagine que

Code :

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

new MonApplication();

c'est l'equivalent de ce que tu fais quand tu crée ta frame et l'affiche, donc c'est la qu'il faut chippoter.

**zpico** · 15/03/2012, 15h51

Envoyé par wax78

Ne sachant trop ce qui te bloque, j'imagine que

Code :

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

new MonApplication();

c'est l'equivalent de ce que tu fais quand tu crée ta frame et l'affiche, donc c'est la qu'il faut chippoter.

voila comment j'ai fait mais sa ne marche pas :
dans ma classe main voila comment j'ai fait pour lancer ma fenetre mais sa ne marche pas (des erreurs)

:

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
 
public class classmain 
{
 
	public static void main(String[] args) 
	{
 
		final int PORT = 32145;
		// Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.
		final String MESSAGE = "nomDeMonApplication";
		// Actions à effectuer lorsqu'une autre instance essaye de démarrer.
		final Runnable RUN_ON_RECEIVE = new Runnable() {
		    public void run() {
		        // On exécute ce runnable dans l'EDT
		        SwingUtilities.invokeLater(new Runnable() {
		            public void run() {
		                if(mainFrame != null) {
		                    // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
		                    if(!mainFrame.isVisible())
		                        mainFrame.setVisible(true);
		                    // On demande à la mettre au premier plan.
		                    mainFrame.toFront();
		                }
		            }
		        });
		    }                   
		});
 
		UniqueInstance uniqueInstance = new UniqueInstance(32145, classmain , RUN_ON_RECEIVE);
		// Si aucune autre instance n'est lancée...
		if(uniqueInstance.launch()) {
		    // On démarre l'application.
			new fenetre_unique();
		}		
	}
 
}

quel est l'erreur comment peut on corrigé ça???:

merci encore de m'avoir aidé

A+

**wax78** · 15/03/2012, 15h57

Envoyé par zpico

quel est l'erreur comment peut on corrigé ça???:

Bah a la non vue de l'erreur, impossible de te répondre. Poste l'erreur

**zpico** · 15/03/2012, 16h22

Envoyé par wax78

Bah a la non vue de l'erreur, impossible de te répondre. Poste l'erreur

voir jièce jointe s'il vous plais capture écran (l'editeur eclipse)

merci encore pour la réponse

A+

**Proxy** · 15/03/2012, 16h33

C'est simplement un soucis de ")"...

Il faut effacer celle ci :

Code :

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

1
2
3
4
5
6
7
		                    mainFrame.toFront();
		                }
		            }
		        });
		    }                   
		});

J'espère que ça ira ainsi.

**zpico** · 19/03/2012, 15h30

Envoyé par Proxy

C'est simplement un soucis de ")"...

Il faut effacer celle ci :

Code :

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

1
2
3
4
5
6
7
		                    mainFrame.toFront();
		                }
		            }
		        });
		    }                   
		});

J'espère que ça ira ainsi.

je ne sais pas mais je n'arrive toujours pas à la faire fonctionné ...je tourne en rond là

si quelqu'un peut m'aider à trouver qu'est se qui ne va pas sa sera trés sympa.. pour résumer voici mon exemple didactique :

1- le code fentre là je vais creé une simple fenetre pour dasn le but est de l'instancier qu'une seul .. bref la voici:

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
 
import javax.swing.JFrame;
 
public class fenetreunique extends JFrame
{
 
     public fenetreunique()
     {       
         this.setTitle("Ma première fenêtre java");         
         this.setSize(400, 500);        
         this.setLocationRelativeTo(null);        
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            
         this.setVisible(true);
     }                       
 
}

2- le code que je veux l'utiliser qui sert un empêcher d'autre instanciation de ma fenêtre .. bref le voici (ce code est le meme que celui du docuemnt du lien ci-dessus)

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.logging.Logger;
 
/**
 * Cette classe permet d'assurer l'unicité de l'instance de l'application. Deux applications ne peuvent pas être lancées
 * simultanément. Voici un exemple typique d'utilisation :
 * 
 * <pre>
 * // Port à utiliser pour communiquer avec l'instance de l'application lancée.
 * final int PORT = 32145;
 * // Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.
 * final String MESSAGE = &quot;nomDeMonApplication&quot;;
 * // Actions à effectuer lorsqu'une autre instance essaye de démarrer.
 * final Runnable RUN_ON_RECEIVE = new Runnable() {
 *     public void run() {
 *         if(mainFrame != null) {
 *             // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
 *             if(!mainFrame.isVisible())
 *                 mainFrame.setVisible(true);
 *             // On demande à la mettre au premier plan.
 *             mainFrame.toFront();
 *         }
 *     }                   
 * });
 *                 
 * UniqueInstance uniqueInstance = new UniqueInstance(PORT, MESSAGE, RUN_ON_RECEIVE);
 * // Si aucune autre instance n'est lancée...
 * if(uniqueInstance.launch()) {
 *     // On démarre l'application.
 *     new MonApplication();
 * }
 * </pre>
 * 
 * @author rom1v
 */
public class UniqueInstance 
{    
    private int port;      // Port d'écoute utilisé pour l'unique instance de l'application.    
    private String message;  // Message à envoyer à l'éventuelle application déjà lancée. 
 
 
    private Runnable runOnReceive;  // Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle avait essayé de démarrer. 
 
    /**
     * Créer un gestionnaire d'instance unique de l'application.
     * 
     * @param port
     *            Port d'écoute utilisé pour l'unique instance de l'application.
     * @param message
     *            Message à envoyer à l'éventuelle application déjà lancée, {@code null} si aucune action.
     * @param runOnReceive
     *            Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle avait essayé de
     *            démarrer, {@code null} pour aucune action.
     * @param runOnReceive
     *            Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle
     *            avait essayé de démarrer, {@code null} pour aucune action.
     * @throws IllegalArgumentException
     *             si le port n'est pas compris entre 1 et 65535, ou si
     *             {@code runOnReceive != null && message == null} (s'il y a des actions à
     *             effectuer, le message ne doit pas être {@code null}.
     */
    public UniqueInstance(int port, String message, Runnable runOnReceive) 
    {
        if (port == 0 || (port & 0xffff0000) != 0)
            throw new IllegalArgumentException("Le port doit être compris entre 1 et 65535 : " + port + ".");
        if (runOnReceive != null && message == null)
            throw new IllegalArgumentException("runOnReceive != null ==> message == null.");
        this.port = port;
        this.message = message;
        this.runOnReceive = runOnReceive;
    }
 
    /**
     * Créer un gestionnaire d'instance unique de l'application. Ce constructeur désactive la communication entre
     * l'instance déjà lancée et l'instance qui essaye de démarrer.
     * 
     * @param port
     *            Port d'écoute utilisé pour l'unique instance de l'application.
     */
    public UniqueInstance(int port) 
    {
        this(port, null, null);
    }
 
    /**
     * Essaye de démarrer le gestionnaire d'instance unique. Si l'initialisation a réussi, c'est que l'instance est
     * unique. Sinon, c'est qu'une autre instance de l'application est déjà lancée. L'appel de cette méthode prévient
     * l'application déjà lancée qu'une autre vient d'essayer de se connecter.
     * 
     * @return {@code true} si l'instance de l'application est unique.
     */
    public boolean launch() 
    {
 
        boolean unique;  // Indique si l'instance du programme est unique. 
 
        try {
 
            final ServerSocket server = new ServerSocket(port); // On crée une socket sur le port défini. 
 
            unique = true;  // Si la création de la socket réussit, c'est que l'instance du programme est unique, aucune autre n'existe. */
 
            if(runOnReceive != null) // S'il y a des actions à faire lorsqu'une autre instance essaye de démarrer... 
            {
 
                Thread portListenerThread = new Thread("UniqueInstance-PortListenerThread")// On lance un Thread d'écoute sur ce port. 
                {
                    {
                        setDaemon(true);
                    }
 
                    @Override public void run() 
                    {
 
                        while(true) // Tant que l'application est lancée... 
                        {
                            try {
 
                                final Socket socket = server.accept(); // On attend qu'une socket se connecte sur le serveur. 
 
 
                                new Thread("UniqueInstance-SocketReceiver") // Si une socket est connectée, on écoute le message envoyé dans un nouveau Thread. 
                                {
 
                                    {
                                        setDaemon(true);
                                    }
 
                                    @Override public void run() {
                                        receive(socket);
                                    }
                                }.start();
                            } catch(IOException e) {
                                Logger.getLogger("UniqueInstance").warning("Attente de connexion de socket échouée.");
                            }
                        }
                    }
                };
 
                portListenerThread.start();    // On démarre le Thread. 
            }
        } catch(IOException e) {
 
            unique = false;  //Si la création de la socket échoue, c'est que l'instance n'est pas unique, une autre n'existe. 
 
 
            if(runOnReceive != null) // Si des actions sont prévues par l'instance déjà lancée... 
            {
                /*
                 * Dans ce cas, on envoie un message à l'autre instance de l'application pour lui demander d'avoir le
                 * focus (par exemple).
                 */
                send();
            }
        }
        return unique;
    }
 
    /**
     * Envoie un message à l'instance de l'application déjà ouverte.
     */
    private void send() 
    {
        PrintWriter pw = null;
        try 
        {
 
            Socket socket = new Socket("localhost", port);    // On se connecte sur la machine locale.            
            pw = new PrintWriter(socket.getOutputStream());   // On définit un PrintWriter pour écrire sur la sortie de la socket.      
            pw.write(message);                                // On écrit le message sur la socket.
 
        } catch(IOException e) 
        {
            Logger.getLogger("UniqueInstance").warning("Écriture sur flux de sortie de la socket échouée.");
        } finally 
        {
            if(pw != null)
            pw.close();
        }
    }
 
    /**
     * Reçoit un message d'une socket s'étant connectée au serveur d'écoute. Si ce message est le message de l'instance
     * unique, l'application demande le focus.
     * 
     * @param socket
     *            Socket connectée au serveur d'écoute.
     */
    private synchronized void receive(Socket socket) 
    {
        Scanner sc = null;
 
        try 
        {           
            socket.setSoTimeout(5000);                  // On n'écoute que 5 secondes, si aucun message n'est reçu, tant pis...           
            sc = new Scanner(socket.getInputStream());  // On définit un Scanner pour lire sur l'entrée de la socket. */
 
            String s = sc.nextLine();  // On ne lit qu'une ligne.             
            if(message.equals(s))     // Si cette ligne est le message de l'instance unique... 
            {
 
                runOnReceive.run();   // On exécute le code demandé. 
            }
        } catch(IOException e) {
            Logger.getLogger("UniqueInstance").warning("Lecture du flux d'entrée de la socket échoué.");
        } finally {
            if(sc != null)
                sc.close();
        }
    }
}

et pour utiliser se code voila comment j'ai fait

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
 
public class lancement 
{
	public static void main(String[] args) 
	{
 
		final int PORT = 32145;                          // Port à utiliser pour communiquer avec l'instance de l'application lancée.		
		final String MESSAGE = "nomDeMonApplication";    // Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.		
		final Runnable RUN_ON_RECEIVE = new Runnable()   // Actions à effectuer lorsqu'une autre instance essaye de démarrer.
		{
		    public void run() 
		    {
 
		        SwingUtilities.invokeLater(new Runnable()          // On exécute ce runnable dans l'EDT
		        {
		            public void run() 
		            {
		                if(mainFrame != null) 
		                {
 
		                    if(!mainFrame.isVisible())             // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
		                        mainFrame.setVisible(true);		                    
		                        mainFrame.toFront();              // On demande à la mettre au premier plan.
		                }
		            }
		        });
		    }
 
		});
 
 
		UniqueInstance uniqueInstance = new UniqueInstance(PORT, MESSAGE, RUN_ON_RECEIVE);
		// Si aucune autre instance n'est lancée...
		if(uniqueInstance.launch()) // On démarre l'application.
		{		    		    
		  new fenetreunique();
		}
 
	}				
}

1- est-ce que c'est comme ça qu'il faut faire.
2-si c'est comme ça et ben j'ai une erreur que je j'ai signalé déjà ci_dessus et je n'arrive pas à la corriger...?(voir pièce jointe)

Merci pour l'aide.

A+

**zpico** · 20/03/2012, 15h29

Envoyé par zpico

je ne sais pas mais je n'arrive toujours pas à la faire fonctionné ...je tourne en rond là

si quelqu'un peut m'aider à trouver qu'est se qui ne va pas sa sera trés sympa.. pour résumer voici mon exemple didactique :

1- le code fentre là je vais creé une simple fenetre pour dasn le but est de l'instancier qu'une seul .. bref la voici:

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
 
import javax.swing.JFrame;
 
public class fenetreunique extends JFrame
{
 
     public fenetreunique()
     {       
         this.setTitle("Ma première fenêtre java");         
         this.setSize(400, 500);        
         this.setLocationRelativeTo(null);        
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            
         this.setVisible(true);
     }                       
 
}

2- le code que je veux l'utiliser qui sert un empêcher d'autre instanciation de ma fenêtre .. bref le voici (ce code est le meme que celui du docuemnt du lien ci-dessus)

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.logging.Logger;
 
/**
 * Cette classe permet d'assurer l'unicité de l'instance de l'application. Deux applications ne peuvent pas être lancées
 * simultanément. Voici un exemple typique d'utilisation :
 * 
 * <pre>
 * // Port à utiliser pour communiquer avec l'instance de l'application lancée.
 * final int PORT = 32145;
 * // Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.
 * final String MESSAGE = &quot;nomDeMonApplication&quot;;
 * // Actions à effectuer lorsqu'une autre instance essaye de démarrer.
 * final Runnable RUN_ON_RECEIVE = new Runnable() {
 *     public void run() {
 *         if(mainFrame != null) {
 *             // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
 *             if(!mainFrame.isVisible())
 *                 mainFrame.setVisible(true);
 *             // On demande à la mettre au premier plan.
 *             mainFrame.toFront();
 *         }
 *     }                   
 * });
 *                 
 * UniqueInstance uniqueInstance = new UniqueInstance(PORT, MESSAGE, RUN_ON_RECEIVE);
 * // Si aucune autre instance n'est lancée...
 * if(uniqueInstance.launch()) {
 *     // On démarre l'application.
 *     new MonApplication();
 * }
 * </pre>
 * 
 * @author rom1v
 */
public class UniqueInstance 
{    
    private int port;      // Port d'écoute utilisé pour l'unique instance de l'application.    
    private String message;  // Message à envoyer à l'éventuelle application déjà lancée. 
 
 
    private Runnable runOnReceive;  // Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle avait essayé de démarrer. 
 
    /**
     * Créer un gestionnaire d'instance unique de l'application.
     * 
     * @param port
     *            Port d'écoute utilisé pour l'unique instance de l'application.
     * @param message
     *            Message à envoyer à l'éventuelle application déjà lancée, {@code null} si aucune action.
     * @param runOnReceive
     *            Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle avait essayé de
     *            démarrer, {@code null} pour aucune action.
     * @param runOnReceive
     *            Actions à effectuer lorsqu'une autre instance de l'application a indiqué qu'elle
     *            avait essayé de démarrer, {@code null} pour aucune action.
     * @throws IllegalArgumentException
     *             si le port n'est pas compris entre 1 et 65535, ou si
     *             {@code runOnReceive != null && message == null} (s'il y a des actions à
     *             effectuer, le message ne doit pas être {@code null}.
     */
    public UniqueInstance(int port, String message, Runnable runOnReceive) 
    {
        if (port == 0 || (port & 0xffff0000) != 0)
            throw new IllegalArgumentException("Le port doit être compris entre 1 et 65535 : " + port + ".");
        if (runOnReceive != null && message == null)
            throw new IllegalArgumentException("runOnReceive != null ==> message == null.");
        this.port = port;
        this.message = message;
        this.runOnReceive = runOnReceive;
    }
 
    /**
     * Créer un gestionnaire d'instance unique de l'application. Ce constructeur désactive la communication entre
     * l'instance déjà lancée et l'instance qui essaye de démarrer.
     * 
     * @param port
     *            Port d'écoute utilisé pour l'unique instance de l'application.
     */
    public UniqueInstance(int port) 
    {
        this(port, null, null);
    }
 
    /**
     * Essaye de démarrer le gestionnaire d'instance unique. Si l'initialisation a réussi, c'est que l'instance est
     * unique. Sinon, c'est qu'une autre instance de l'application est déjà lancée. L'appel de cette méthode prévient
     * l'application déjà lancée qu'une autre vient d'essayer de se connecter.
     * 
     * @return {@code true} si l'instance de l'application est unique.
     */
    public boolean launch() 
    {
 
        boolean unique;  // Indique si l'instance du programme est unique. 
 
        try {
 
            final ServerSocket server = new ServerSocket(port); // On crée une socket sur le port défini. 
 
            unique = true;  // Si la création de la socket réussit, c'est que l'instance du programme est unique, aucune autre n'existe. */
 
            if(runOnReceive != null) // S'il y a des actions à faire lorsqu'une autre instance essaye de démarrer... 
            {
 
                Thread portListenerThread = new Thread("UniqueInstance-PortListenerThread")// On lance un Thread d'écoute sur ce port. 
                {
                    {
                        setDaemon(true);
                    }
 
                    @Override public void run() 
                    {
 
                        while(true) // Tant que l'application est lancée... 
                        {
                            try {
 
                                final Socket socket = server.accept(); // On attend qu'une socket se connecte sur le serveur. 
 
 
                                new Thread("UniqueInstance-SocketReceiver") // Si une socket est connectée, on écoute le message envoyé dans un nouveau Thread. 
                                {
 
                                    {
                                        setDaemon(true);
                                    }
 
                                    @Override public void run() {
                                        receive(socket);
                                    }
                                }.start();
                            } catch(IOException e) {
                                Logger.getLogger("UniqueInstance").warning("Attente de connexion de socket échouée.");
                            }
                        }
                    }
                };
 
                portListenerThread.start();    // On démarre le Thread. 
            }
        } catch(IOException e) {
 
            unique = false;  //Si la création de la socket échoue, c'est que l'instance n'est pas unique, une autre n'existe. 
 
 
            if(runOnReceive != null) // Si des actions sont prévues par l'instance déjà lancée... 
            {
                /*
                 * Dans ce cas, on envoie un message à l'autre instance de l'application pour lui demander d'avoir le
                 * focus (par exemple).
                 */
                send();
            }
        }
        return unique;
    }
 
    /**
     * Envoie un message à l'instance de l'application déjà ouverte.
     */
    private void send() 
    {
        PrintWriter pw = null;
        try 
        {
 
            Socket socket = new Socket("localhost", port);    // On se connecte sur la machine locale.            
            pw = new PrintWriter(socket.getOutputStream());   // On définit un PrintWriter pour écrire sur la sortie de la socket.      
            pw.write(message);                                // On écrit le message sur la socket.
 
        } catch(IOException e) 
        {
            Logger.getLogger("UniqueInstance").warning("Écriture sur flux de sortie de la socket échouée.");
        } finally 
        {
            if(pw != null)
            pw.close();
        }
    }
 
    /**
     * Reçoit un message d'une socket s'étant connectée au serveur d'écoute. Si ce message est le message de l'instance
     * unique, l'application demande le focus.
     * 
     * @param socket
     *            Socket connectée au serveur d'écoute.
     */
    private synchronized void receive(Socket socket) 
    {
        Scanner sc = null;
 
        try 
        {           
            socket.setSoTimeout(5000);                  // On n'écoute que 5 secondes, si aucun message n'est reçu, tant pis...           
            sc = new Scanner(socket.getInputStream());  // On définit un Scanner pour lire sur l'entrée de la socket. */
 
            String s = sc.nextLine();  // On ne lit qu'une ligne.             
            if(message.equals(s))     // Si cette ligne est le message de l'instance unique... 
            {
 
                runOnReceive.run();   // On exécute le code demandé. 
            }
        } catch(IOException e) {
            Logger.getLogger("UniqueInstance").warning("Lecture du flux d'entrée de la socket échoué.");
        } finally {
            if(sc != null)
                sc.close();
        }
    }
}

et pour utiliser se code voila comment j'ai fait

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
 
public class lancement 
{
	public static void main(String[] args) 
	{
 
		final int PORT = 32145;                          // Port à utiliser pour communiquer avec l'instance de l'application lancée.		
		final String MESSAGE = "nomDeMonApplication";    // Message à envoyer à l'application lancée lorsqu'une autre instance essaye de démarrer.		
		final Runnable RUN_ON_RECEIVE = new Runnable()   // Actions à effectuer lorsqu'une autre instance essaye de démarrer.
		{
		    public void run() 
		    {
 
		        SwingUtilities.invokeLater(new Runnable()          // On exécute ce runnable dans l'EDT
		        {
		            public void run() 
		            {
		                if(mainFrame != null) 
		                {
 
		                    if(!mainFrame.isVisible())             // Si la fenêtre n'est pas visible (uniquement dans le systray par exemple), on la rend visible.
		                        mainFrame.setVisible(true);		                    
		                        mainFrame.toFront();              // On demande à la mettre au premier plan.
		                }
		            }
		        });
		    }
 
		});
 
 
		UniqueInstance uniqueInstance = new UniqueInstance(PORT, MESSAGE, RUN_ON_RECEIVE);
		// Si aucune autre instance n'est lancée...
		if(uniqueInstance.launch()) // On démarre l'application.
		{		    		    
		  new fenetreunique();
		}
 
	}				
}

1- est-ce que c'est comme ça qu'il faut faire.
2-si c'est comme ça et ben j'ai une erreur que je j'ai signalé déjà ci_dessus et je n'arrive pas à la corriger...?(voir pièce jointe)

Merci pour l'aide.

A+

comme je me bloque sur cette méthode en cherchant sur la faq du forum j'ai trouvé une astuce interessante et simple il s'agit enfaite d'instancier une ServerSocket sur un port libre dés le lancement de l'application et quand on veut l'instancier une deuxiemme fois on trouve le port déja occupé on lève un exception et on ferme tout voici le code

Code :

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

1
2
3
4
5
6
7
8
9
10
 
try
	     {    	  
	        RDJ_Ext = new ServerSocket(12990);        // port possible libre entre 1024 au 65535
	     }catch (IOException e) 
	      {
	        JOptionPane.showMessageDialog(null,"Vous êtes déjà connecté ", " Attention ! ", JOptionPane.WARNING_MESSAGE);
	        System.out.println("Could not listen on port 12990");
	        System.exit(-1);
	      }

ma question est :

cette astuce marche trés bien mais je me demande si y'aura pas des effet car j'ai utilisé ça sur le code coté serveur mais maintenant je l'ai utilisé coté client ..() comme je tourne mes programmes sur l'editeur Eclipce donc je simule mon application clients / serveur ..je me demande si on instanciant une Serversocket coté client (juste pour empêcher d'autre instanciation de la fenetre client) il aura pas d'effets négatifs sur le bon fonctionnement de mon appli ??? en réel.

A+

encore merci pour vos réponses

**wax78** · 20/03/2012, 16h15

Bah c'est simple, si tu as sur la même machine, un client et un serveur qui veulent ouvrir le même port, une des deux ne démarrera jamais... (puisque port deja ouvert par l'autre programme).

Donc si tu veux vraiment faire ca, change le port pour le serveur qu'il soit different du client tout simplement.

**zpico** · 21/03/2012, 08h07

Envoyé par wax78

Bah c'est simple, si tu as sur la même machine, un client et un serveur qui veulent ouvrir le même port, une des deux ne démarrera jamais... (puisque port deja ouvert par l'autre programme).

Donc si tu veux vraiment faire ca, change le port pour le serveur qu'il soit different du client tout simplement.

Bonjour,

oui bien sur chaque client a un numéro de port diffèrent des autres clients (car je simule sur la même machine) je parle là sur le numéro du port choisi pour l'astuce que j'ai cité ci-dessus pour l'unicité de l'instanciation de la fenêtre du même client.
j'aimerais bien confirmer juste que cette astuce(instanciation d'un serversocket coté client ) n'influe pas sur le bon fonctionnement de mon application en réél.(souci d'un débutant en java

)

A+

**wax78** · 21/03/2012, 10h03

Je parlais bien du port pour l'instanciation, pas de celui utilisé pour la connection clients/serveurs.

Et non, ca ne devrait rien changer en théorie sur le fonctionnement du reste de l'application.

**zpico** · 21/03/2012, 11h11

Envoyé par wax78

Je parlais bien du port pour l'instanciation, pas de celui utilisé pour la connection clients/serveurs.

Et non, ca ne devrait rien changer en théorie sur le fonctionnement du reste de l'application.

OK wax78 ...si c'est comme ça mon problème est réglé ..

Merci

A+

Activation d'une seule fenêtre

avec Java

Discussions similaires

Partager

Partager