Discussion :

[Auteur]

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 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
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 :

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
 
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

[CodeMonkey]

Bonjour

bon je te suggère un truc pourquoi ne pas coder une seule application qui contient tout (un serveur + un client) tu lances 1 instance de l'application elle devient au début un serveur et attend un client qui va se connecter, tu relance une autre instance de l'application. c'est simple tu fais une classe abstraite Model et 2 classes concrètes Serveur et Client qui en héritent, comme j'ai dit tu lances une instance par défaut elle devient un objet serveur et attend un client , tu relance une 2em instance et tu saisies l'IP et Port sur le quel la 1er instance écoute les connexions une fois tu click sur connecter la 2em instance devient un client et se connecte à la 1er instance , et tu peux faire l'inverse, un truc du genre :

Code :

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

1
2
Model model = new Serveur(); // au début de l'exécution
model = new Client(); // au cas tu click sur connecter...

j'espère que je t'ai aidé un peu

[Auteur]

désolé CodeMonkey, mais je n'ai rien compris

[tchize_]

coté serveur, rien à dire, faire un appel sur accept est la bonne manière d'attendre le client. Coté client, au lieu de faire un boucle active qui controle le temps, utilise un Thread.sleep(2000) pour éviter de charger inutilement le proco et le réseau.

[Auteur]

Merci tchize_ pour cette réponse.

Mais le fait que je crée des socket et des buffer à chaque tour de boucle n'est pas préjudiciable en terme de performance ou de mémoire ?

Je crains d'empiler des Socket, ObjectOutputStream et ObjectInputStream inutilement côté serveur et côté client.

Pour le serveur je précise que j'ai fixé le timeout à 2 secondes, donc toutes les deux secondes, je fais un nouvel accept même si un client est connecté.

[tchize_]

ce n'est pas ce que fait sotimeout accept() ne retournera pas avant qu'un client se connecte.

Non tu ne vas pas saturer le client, les socket sont nettoyé par le GC, c'est pas 5 objets toutes les 2 secondes qui vont tuer ton process, il est capable d'en créer des 100aine de milliers par seconde et de traiter leur nettoyage sans broncher.