Problème Swing / socket bloquant
bonjour a tous
Je suis en train de développer une application de tchat pour cela j'ai creer un serveur ainsi que des clients.
J'ai voulu utiliser une interface graphique mais le souci c'est que lorsque je lance le serveur il me bloque la page en swing et pareil lorsque je lance un client.
En fait ce que je souhaiterai c'est lorsque je clik sur Serveur, le serveur se lance et m'ouvre une nouvelle fenetre (qui ne soit pas inutilisable) et pareil pour le client.
voici le code pour l'accueil
Code:
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
|
public Accueil() {
// setTitle("Client & Serveur");
setLocation(100,50);
setSize(200,200);
//Initialisation du Layout
GridLayout grid = new GridLayout();
setLayout(grid);
JPanel panel=new JPanel();
ActionListener eb = new EcouteurBouton();
panel.add(bclient);
panel.add(bserveur);
add(panel);
bserveur.addActionListener(eb);
bclient.addActionListener(eb);
/* setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
quit();
}
});*/
setVisible(true);
}
protected void quit() {
if (
JOptionPane.showConfirmDialog(
this,
"Quitter Client & Serveur? ",
"",
JOptionPane.YES_NO_OPTION) == 0) {
System.exit(0);
}
}
class EcouteurBouton implements ActionListener{
public void actionPerformed(ActionEvent e){
String commande = e.getActionCommand();
if (commande.equals("Mode Serveur")){
JDialog d1 = new JDialog();
JOptionPane.showMessageDialog(d1,"Le serveur est lancé");
try {
new Serveur();
Serveur.lancerS();
//setVisible(false);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}else if (commande.equals("Mode Client")){
JDialog d2 = new JDialog();
JOptionPane.showMessageDialog(d2,"Vous avez appuyer sur le bouton 2");
SwingUtilities.invokeLater(new Runnable() {
public void run() {
//JFrame appli = new Accueil();
new Test(new Application());
Client c= new Client();
c.lancerC();}
}
);}}
}
/**
* main d'application principale
* @param args
*/
public static void main(String args[]) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
JFrame appli = new Accueil();
}
});
} |
celui du serveur
Code:
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
|
public Serveur() throws IOException {
super();
// TODO Auto-generated constructor stub
}
private static final int PORT = 8254; //ceci est le port par d�faut, susc�ptible d'�tre modif� par la suite
private static int numero = 1;
@SuppressWarnings("unchecked")
public static Vector mesClients = new Vector();
private static Serveur monServeur;
// classe principale -> main
//public static void main(String[] args) throws Exception
//{
public synchronized static void lancerS(){
Serveur monServeur = Serveur.getInstance();
//ici le try g�re l'arriv�e de chaque nouveau client
//il re�oit la socket et la conn�cte sur le port du serveur par d�faut
//dans le while, il indique l'arriv�e de chaque nouveau client et affiche ce que chaque client �crit sServerSocket service = new ServerSocket(PORT);ur la page
try {
new Commandes(monServeur);
ServerSocket service = new ServerSocket(PORT);
printWelcome(PORT);
while (true)
{ new ThreadServeur(service.accept(), monServeur);
ThreadServeur.currentThread().isInterrupted();
}
}catch (Exception e){}
}
static private void printWelcome(Integer port)
{
System.out.println("--------");
System.out.println("Bienvenur sur le serveur ");
System.out.println("");
System.out.println("--------");
System.out.println("Demarre sur le port : "+PORT);
System.out.println("--------");
System.out.println("Quitter : tapez \"quitter\"");
System.out.println("Nombre de connectes : tapez \"total\"");
System.out.println("--------");
}
public static void main(String[] args){
lancerS();
}
@SuppressWarnings("unchecked")
public void insererClient(Client client)
{
this.mesClients.add(client);
}
public void retirerClient(Client client) {
this.mesClients.remove(client);
}
public static Serveur getInstance()
{
if (null == monServeur)
{
try {
monServeur = new Serveur();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return monServeur;
}
// M�thode qui prend en parametres une chaine et l'affiche aux clients
synchronized public static void envoieATous(String message)
{
PrintWriter out; // declaration d'une variable permettant l'envoie de texte vers le client
for (int i = 0; i < mesClients.size(); i++) // parcours de la table des connectés
{
out = (PrintWriter) mesClients.elementAt(i); // extraction de l'élément courant (type PrintWriter)
if (out != null) // sécurité, l'élément ne doit pas être vide
{
// ecriture du texte passé en paramètre (et concaténation d'ue string de fin de chaine si besoin)
out.print(message);
out.flush(); // envoi dans le flux de sortie
}
}
}
public static void Affichage(){
System.out.println("************************************************************");
} |
et celui du threadserveur
Code:
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
|
class ThreadServeur extends Thread implements Runnable
{
private Thread t;
private Socket connexion;
private String pseudo;
private Client client;
private Application ap;
private Serveur serv;
PrintWriter sortie;
BufferedReader entree;
//constructeur prend en parametre une socket, un pseudo et le Client
public ThreadServeur(Socket connexion, String pseudo, Client monClient){
this.connexion = connexion;
this.pseudo = pseudo;
this.client=monClient;
System.out.println("Nouveau socket : " + connexion);
}
public ThreadServeur(Socket connexion, Serveur serv)
{
serv=serv;
connexion=connexion;
try{
sortie = new PrintWriter(connexion.getOutputStream());
entree = new BufferedReader(new InputStreamReader(
connexion.getInputStream()));
}catch (IOException e){}
t = new Thread(this);
t.start();
}
//methode principale, run()
public void run()
{boolean continuer = true;
String message ="";
try
{
//tant que l'utilisateur n'a pas inscrit "quitter" le serveur prendra toujours en compte les donn�es d'entr�es/sorties du clavier
char charCur[]=new char[1];
while (/*continuer*/entree.read(charCur,0,1)!= -1)
{
if (charCur[0] != '\u0000' && charCur[0] != '\n' && charCur[0] != '\r')
message += charCur[0];
else if(!message.equalsIgnoreCase("")) // juste une vérification de principe
{
if(charCur[0]=='\u0000')
serv.envoieATous(message+" " + charCur[0]);
else serv.envoieATous(message);
message = "";
String ligne = entree.readLine();
{
Serveur.mesClients.remove(this.client);
Serveur.envoieATous(pseudo+" a quitter le chat");
System.out.println(pseudo+" a quitter le chat");
break;
}
if (ligne.equalsIgnoreCase(pseudo +" >verif")){
System.out.print("c'est ok!!!");
Serveur.envoieATous("c'est ok");
}
//si je n'ai rien recu, la boucle a boucler indefiniment
if (ligne == null)
{
continuer = false;
}
else
{
//affiche le message d'un client sur le serveur et sur tous les terminaux des clients
String chaine=pseudo + " >" + ligne;
System.out.println(chaine);
Serveur.envoieATous(chaine);
}
}//fermeture de la connexion
}
connexion.close();
}
//s'il y a une erreur genere, je l'affiche
catch (IOException e)
{
System.err.println(e);
}
}
} |
merci pour votre aide ça fait vraiment un moment ou je suis bloqué
