[Débutant] Communication entre deux applications en utilisant les sockets
bonjour,
J'ai deux applications java A et B installées sur le même PC. Je souhaite qu'elles échangent des informations entre elles.
Pour cela j'ai créé un ServerSocket sur une application et un Socket sur la seconde. Tout se passe en local.
J'ai un impératif de fonctionnement :
les applications A et B ne sont pas nécessairement lancées dans un ordre précis : A peut être lancée avant B et réciproquement.
Du coup, l'application client doit attendre le serveur ou le serveur doit attendre le client.
Je pense que mon code est loin d'être optimisé...
Pourriez-vous corriger mon code si nécessaire et me donner vos avis ?
Côté 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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package miniserveur;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
*
* @author
*/
public class Serveur extends Thread
{
private final int port = 14000;
private ServerSocket server;
private Socket socket;
private ObjectOutputStream out = null;
private ObjectInputStream in = null;
private boolean stopThread;
public Serveur()
{
try
{
stopThread = false;
server = new ServerSocket(port);
server.setSoTimeout(2000);
}
catch (IOException ex)
{
stopThread = true;
}
}
@Override
public void run()
{
while (!stopThread)
{
if (openConnection())
{
System.out.println("Connecté");
try
{
out.writeObject("--Ici le serveur--");
out.flush();
System.out.println((String)in.readObject());
}
catch (ClassNotFoundException ex)
{}
catch (IOException ex)
{}
}
else
{
System.out.println("Pas connecté");
}
}
}
public void closeConnection()
{
try
{
this.join();
out.close();
in.close();
socket.close();
out = null;
in = null;
socket = null;
}
catch (IOException ex)
{}
catch (InterruptedException ex)
{}
}
private boolean openConnection()
{
boolean status;
status = false;
try
{
socket = server.accept();
if (socket!=null)
{
if (socket.isConnected())
{
out = new ObjectOutputStream(socket.getOutputStream());
out.flush();
in = new ObjectInputStream(socket.getInputStream());
}
status = socket.isConnected();
}
}
catch (IOException ex)
{
System.out.println(ex.getMessage());
}
return status;
}
} |
Côté client
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
|
package miniclient;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author
*/
public class Client extends Thread
{
private Socket client;
private ObjectOutputStream out;
private ObjectInputStream in;
private boolean stopThread;
public Client()
{
}
private boolean createClient()
{
boolean status;
status = false;
try
{
stopThread = false;
client = new Socket("localhost", 14000);
if (client!=null)
{
if (client.isConnected())
{
out = new ObjectOutputStream(client.getOutputStream());
out.flush();
in = new ObjectInputStream(client.getInputStream());
}
status = client.isConnected();
}
}
catch (UnknownHostException ex)
{
System.out.println(ex.getMessage());
}
catch (IOException ex)
{}
return status;
}
@Override
public void run()
{
long t;
t = System.currentTimeMillis();
while (!stopThread)
{
if (System.currentTimeMillis() > t+2000)
{
if (createClient())
{
System.out.println("Connecté");
try
{
out.writeObject("--Ici le client--");
out.flush();
System.out.println((String)in.readObject());
}
catch (ClassNotFoundException ex)
{}
catch (IOException ex)
{}
}
else
{
System.out.println("Pas connecté");
}
t = System.currentTimeMillis();
}
}
}
public void closeConnection()
{
try
{
stopThread = true;
this.join();
in.close();
out.close();
client.close();
}
catch (IOException ex)
{}
catch (InterruptedException ex)
{}
}
} |
Comme vous pouvez le constater, côté serveur j'appelle dans une boucle while() la méthode openConnection(), qui va vérifier si un client est connecté et le cas échéant créer les buffer d'entrée et de sortie.
Côté client, le dispositif est similaire : je crée un socket jusqu'à ce que je détecte un serveur.
Le code fonctionne très bien comme ça : je peux lancer d'abord le serveur puis le client ou l'inverse. Et si une application se ferme, je peux la rouvrir, la communication reprend normalement.
Ce qui me gêne c'est je crée un Socket ou un SocketServer et mes buffer à chaque itération :? Du coup, je pense que mes codes sont loin d'être optimisés :(
