Problème de thread et socket : Affichage variables

**Gwendal2835** · 10/01/2020, 10h38

Bonjour à tous, meilleurs vœux à la communautés.

Actuellement en alternance dans un entreprise pour valider ma deuxième années de BTS, je développe une application web java de supervision pour un site de production.

N'ayant aucune connaissances dans le langage java EE, je m'amuse pour le moment à comprendre le principe d'une application web (servlets, jsp, beans, jstl..).

L'application communique avec un IPX 800 V3 qui est un automate contrôlable. Donc le but de l'appli est de pouvoir afficher les résultat d'une requête M2M ainsi que la réponse de l'ipx.

Donc j'arrive à me connecter à mon "Serveur" qui est l'ipx, j'arrive à lui envoyer une requête et je reçois bien la réponse mais le soucis c'est lorsque je souhaite renvoyer requête la réponse ne s'affiche plus.

J'utilise un socket pour la connexion ainsi que deux thread pour écrire et pour lire. (Je me doute que le soucis provient d'ici, mais je trouve pas après pas mal de recherches.)

Pour l'affichage j'ai utilisé un <c:if test="${ !empty ..... }, comme je vous l'ai dit plus haut lorsque je fais plusieurs requête je n'ai pas l'affichage de la réponse alors que dans la console de Eclipse il apparaît.

Voici mon code :

Page.jsp

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
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Application Web Simoldes Plasticos</title>
</head>
<body>
	<h1>Simoldes Plasticos France</h1>
	<h2>Application web de supervision</h2>
 
	<form method="post" action="bonjour">
	<p>
		<label for="commande">Afficher état des entrées : </label>
		<input type="text" id="commande" name="commande"/>
	</p>
 
 
	<input type="submit"/>
	</form>
	<c:if test="${ !empty form.resultat }"><p><c:out value="${ form.resultat }" /></p></c:if>
	<c:if test="${ !empty form.resultat2 }"><p><c:out value="${ form.resultat2 }" /></p></c:if>
 
</body>
</html>

Connection.java

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
package org.cochet.web.forms;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class ConnectionForm {
	private String resultat;
	private String resultat2;
	static final int port = 9870;
 
	public void connection( HttpServletRequest request) throws IOException {
		String commande = request.getParameter("commande");
 
		if(commande.equals(commande = "test")) {
			final Socket clientSocket;
		      final BufferedReader in;
		      final PrintWriter out;
		      final Scanner sc = new Scanner(System.in);//pour lire à partir du clavier
 
		      try {
		         /*
		         * les informations du serveur ( port et adresse IP ou nom d'hote
		         * 127.0.0.1 est l'adresse local de la machine
		         */
		         clientSocket = new Socket("***********" ,9870);
 
		         //flux pour envoyer
		         out = new PrintWriter(clientSocket.getOutputStream());
		         //flux pour recevoir
		         in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
 
 
 
		         Thread envoyer = new Thread(new Runnable() {
		             String msg = "GetInputs";
		              @Override
		              public void run() {
		                while(true){
		                 // msg = sc.nextLine();
		                  out.println(msg);
		                  out.flush();
		                  resultat = "commande envoyée : "+msg;
		                }
		             }
		         });
		         envoyer.start();
 
		        Thread recevoir = new Thread(new Runnable() {
		            String msg;
		            @Override
 
		            public void run() {
		               try {
		                 msg = in.readLine();
 
		                 //while(msg!=null){
		                 resultat2 = "Reponse : "+msg;
		                    System.out.println("Serveur : "+msg);
 
		                    msg = in.readLine();
 
		                // }
 
		                 System.out.println("Serveur déconnecté");
 
		                 out.close();
		                 clientSocket.close();
 
		               } catch (IOException e) {
		                   e.printStackTrace();
		               }
		            }
		        });
		        recevoir.start();
 
		      } catch (IOException e) {
		           e.printStackTrace();
		      }
 
 
 
		}else
			resultat = "Commande incorrect !";
	}
 
	public String getResultat() {
		return resultat;
	}
 
	public void setResultat(String resultat) {
		this.resultat = resultat;
	}
 
	public String getResultat2() {
		return resultat2;
	}
 
	public void setResultat2(String resultat2) {
		this.resultat2 = resultat2;
	}
}

Et la servlet :

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
package org.cochet.web.servlet;
 
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.cochet.web.beans.Auteur;
import org.cochet.web.forms.ConnectionForm;
 
 
@WebServlet("/bonjour")
public class bonjour extends HttpServlet {
	private static final long serialVersionUID = 1L;
 
 
    public bonjour() {
        super();
 
    }
 
 
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
				this.getServletContext().getRequestDispatcher("/WEB-INF/bonjour.jsp").forward(request, response);
	}
 
 
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		ConnectionForm form = new ConnectionForm();
		form.connection(request);
 
 
		request.setAttribute("form", form);
 
		this.getServletContext().getRequestDispatcher("/WEB-INF/bonjour.jsp").forward(request, response);
	}
 
 
}

Voici le résultat attendu :

Nom : Capture.PNG
Affichages : 440
Taille : 28,5 Ko

Lorsque je re-clique sur soumettre le requête voici le résultat (la réponse ne s'affiche pas)

Nom : Capture2.PNG
Affichages : 396
Taille : 25,6 Ko

Lorsque je continue de cliquer :

Nom : Capture3.PNG
Affichages : 398
Taille : 21,6 Ko

Merci d'avance de me lire.
Cordialement
Un novice

**joel.drigo** · 21/01/2020, 07h12

Salut,

Globalement, tu dois aborder la problématique comme des processus asynchrones.

Tu ne peux pas procéder comme ça, lancer 2 threads dans le thread d'exécution de la servlet.
Le principe des threads c'est qu'ils s'exécutent en parallèle. Le thread de la servlet continue de s'exécuter pendant que les deux autres s'exécutent. Le forward s'effectue alors que les threads d'échange avec l'automate tournent. Par chance, les deux threads peuvent modifier les variables de l'attribut "form" avant que le résultat de la jsp se génère, donc tu peux voir les valeurs de resultat et resultat2. Par chance, parce que cette génération prend à priori un peu plus de temps que le temps d'exécution de l'échange avec l'automate. De toute façon, tu n'auras qu'un seul "résultat".

Appelons S le thread de la servlet, E le thread d'envoi, R le thread de réception.
Il faut que S attende que R ait reçu son message avant de retourner un résultat. On pourrait procéder par join (pour attendre que l'échange avec l'automate soit effectué), mais le plus adapté est d'utiliser un AsyncServlet. C'est R qui sera exécuté via l'AsyncServlet, et qui lancera E, puis attend le résulat et "renvoie" le résultat comme résultat d'exécution de servlet.
Pourquoi envoyer en boucle une commande à l'automate si c'est pour fermer la socket dès la réception d'une réponse. Tu envoies une commande et tu reçois une réponse. Si le but est de pouvoir envoyer plusieurs commandes et pouvoir afficher chaque résultat, il faut que tu procèdes commande par commande. Fait une classe, mettons Automate qui a trois méthodes : une pour établir une connexion (connect() par exemple), une pour envoyer une commande (String send(String, PrintWriter)) par exemple), une méthode pour terminer la connexion (disconnect() par exemple).
Lors d'invocation de la servlet, tu crées un attribut de session automate pour une instance de Automate, seulement s'il n'y en a pas déjà un. Dans ce cas, tu le récupères et tu l'utilises : ainsi à chaque invocation, tu utilises la même instance.
Utilises un ExecutorService, pour pouvoir envoyer plusieurs commandes l'une après l'autre, à chaque invocation de la servlet.
Pour le résultat, plutôt que d'utiliser un attribut, j'écrirais un json (avec la commande et son résultat, en données) dans le flux de la réponse et je ferais l'invocation en ajax dans la page, en asynchrone (le principe est le même que pour l'AsyncServlet). Tu pourras lancer plusieurs commandes dans la page, à ton rythme, et chaque résultat pourra être affiché, sans que la page entière ne soit rechargée.

Si j'ai le temps, j'essayerais de te faire un petit POC.

**Gwendal2835** · 21/01/2020, 09h14

Salut a toi

D'abord merci beaucoup pour ta réponse construite, cela va beaucoup m'aider.

Aurais-tu une doc pour la AsyncServlets ?

Cela fait un petit moment que je suis bloqué, que je n'arrive pas a comprendre tous le fonctionnement. Je regarde tout ce que tu m'as donné, je vais sans doute revenir vers toi.

Je suis preneur pour un POC si tu as le temps.

Encore merci a toi.

**OButterlin** · 21/01/2020, 19h18

Ça me parait un peu compliqué les n threads...

Une servlet étant multi-thread par nature, n requêtes s'exécutent dans n thread, du coup, on peut très bien imaginer de faire l'envoi de la commande et la lecture du résultat séquentiellement.
Je ferais un appel ajax pour le cas où tu aurais besoin de passer plusieurs commandes sans attendre le résultat précédent.

**joel.drigo** · 21/01/2020, 19h20

Je pense que les threads sont nécessités par la communication asynchrone avec l'automate, comme cela se passerait avec un programme externe (cf ProcessBuilder). Exécuter n requêtes à la servlet ne garantit pas l'ordre d'exécution, et cela pourrait être nécessaire pour la communication avec un automate. Egalement si l'automate est monoprocess : séquentialiser les échanges permet d'éviter d'avoir à gérer le cas où l'automate refuse la connexion pendant qu'un échange est en cours. Maintenant, si on établit une connexion et une déconnexion à chaque échange, et l'automate répond directement une requête, et est capable de traiter plusieurs requêtes simultanées, oui on n'a ni besoin de threads, ni besoin de séquentialiser les différents échanges avec la servlet.

**Gwendal2835** · 22/01/2020, 13h33

Bonjour,

Cela me parait compliqué, surtout le manque de doc sur l'asyncServlet.

J'ai 26 automates et 26 ANDON(c'est un outil industriel et visuel qui permet de révéler d'un simple coup d'œil qu'un poste de travail rencontre une anomalie), j'aimerais lorsque je me connecte sur l'application que je puisse voir l'état de tout mes automates (Etat de led : Blanc / Vert / Rouge / Orange / Bleu).

L'automate répond directement après la requête. Donc il serait possible de ne pas utiliser les thread ?

Je suis totalement perdu et je ne sais plus sur quoi me pencher x)

**OButterlin** · 22/01/2020, 13h49

As-tu essayé ce genre de construction

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
    public void connection( HttpServletRequest request) throws IOException 
    {
        String commande = request.getParameter("commande");
 
        if(commande.equals(commande = "test")) {
            final Socket clientSocket;
            final BufferedReader in;
            final PrintWriter out;
 
            try {
                 clientSocket = new Socket("***********" ,9870);
 
                 out = new PrintWriter(clientSocket.getOutputStream());
                 in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
 
                 String msg = "GetInputs";
                 out.println(msg);
                 out.flush();
                 resultat = "commande envoyée : "+msg;
 
                String msg = in.readLine();
 
                out.close();
                clientSocket.close();
 
              } catch (IOException e) {
                   e.printStackTrace();
              }
        }
        else resultat = "Commande incorrect !";
    }

Je ne pense pas que tu ais besoin de thread pour enchainer l'envoi et la réception de la réponse... là c'est basique, aucun test ni détermination du type d'erreur mais bon, dans l'idée, ça devrait suffire...

**joel.drigo** · 22/01/2020, 13h55

Effectivement, en regardant la doc, les protocoles du IPX800-V3, c'est du M2M ou du HTTP, donc on peut très bien envoyer et recevoir dans le même thread. Il semble même qu'on puisse directement obtenir un état de l'automate en xml par l'url http://ipx800_v3/status.xml. Tu peux nous montrer la forme de cet état ?

Du coup, c'est tout simple : la servlet prend en paramètre un identifiant d'automate, l'interroge, convertit la réponse pour écrire du json dans la réponse. Côté client, de l'ajax pour invoquer la servlet et afficher le résultat.

**Gwendal2835** · 22/01/2020, 14h38

Envoyé par OButterlin

J'ai essayer cela fonctionne bien même après plusieurs requête. J'ai rajouter "resultat2 = "commande envoyée : "+msg;" pour pouvoir récupéré la réponse.

Envoyé par joel.drigo

Oui il est possible de récupéré les états de l'automate. Pour les tests j'utilise que 1 automate, mais pour l'application final il y aura bien 26 automates.

Voici a quoi cela ressemble

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
<response>
<led0>0</led0>
<led1>0</led1>
<led2>0</led2>
<led3>0</led3>
<led4>0</led4>
<led5>0</led5>
<led6>0</led6>
<led7>0</led7>
<led8>0</led8>
<led9>0</led9>
<led10>0</led10>
<led11>0</led11>
<led12>0</led12>
<led13>0</led13>
<led14>0</led14>
<led15>0</led15>
<led16>0</led16>
<led17>0</led17>
<led18>0</led18>
<led19>0</led19>
<led20>0</led20>
<led21>0</led21>
<led22>0</led22>
<led23>0</led23>
<led24>0</led24>
<led25>0</led25>
<led26>0</led26>
<led27>0</led27>
<led28>0</led28>
<led29>0</led29>
<led30>0</led30>
<led31>0</led31>
<btn0>up</btn0>
<btn1>up</btn1>
<btn2>up</btn2>
<btn3>up</btn3>
<btn4>up</btn4>
<btn5>up</btn5>
<btn6>up</btn6>
<btn7>up</btn7>
<btn8>up</btn8>
<btn9>up</btn9>
<btn10>up</btn10>
<btn11>up</btn11>
<btn12>up</btn12>
<btn13>up</btn13>
<btn14>up</btn14>
<btn15>up</btn15>
<btn16>up</btn16>
<btn17>up</btn17>
<btn18>up</btn18>
<btn19>up</btn19>
<btn20>up</btn20>
<btn21>up</btn21>
<btn22>up</btn22>
<btn23>up</btn23>
<btn24>up</btn24>
<btn25>up</btn25>
<btn26>up</btn26>
<btn27>up</btn27>
<btn28>up</btn28>
<btn29>up</btn29>
<btn30>up</btn30>
<btn31>up</btn31>
<day>22/01/2020 </day>
<time0>14:40:08</time0>
<analog0>0</analog0>
<analog1>0</analog1>
<analog2>0</analog2>
<analog3>0</analog3>
<analog4>0</analog4>
<analog5>0</analog5>
<analog6>0</analog6>
<analog7>0</analog7>
<analog8>0</analog8>
<analog9>0</analog9>
<analog10>0</analog10>
<analog11>0</analog11>
<analog12>0</analog12>
<analog13>0</analog13>
<analog14>0</analog14>
<analog15>0</analog15>
<anselect0>0</anselect0>
<anselect1>0</anselect1>
<anselect2>0</anselect2>
<anselect3>0</anselect3>
<anselect4>0</anselect4>
<anselect5>0</anselect5>
<anselect6>0</anselect6>
<anselect7>0</anselect7>
<anselect8>0</anselect8>
<anselect9>0</anselect9>
<anselect10>0</anselect10>
<anselect11>0</anselect11>
<anselect12>0</anselect12>
<anselect13>0</anselect13>
<anselect14>0</anselect14>
<anselect15>0</anselect15>
<count0>0</count0>
<count1>0</count1>
<count2>0</count2>
<count3>0</count3>
<count4>0</count4>
<count5>0</count5>
<count6>0</count6>
<count7>0</count7>
<tinfo>---</tinfo>
<version>3.05.70</version>
</response>

Voici lorsque les leds sont allumées :

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
<response>
<led0>1</led0>
<led1>1</led1>
<led2>1</led2>
<led3>1</led3>
<led4>1</led4>
<led5>0</led5>
<led6>0</led6>
<led7>0</led7>
<led8>0</led8>
<led9>0</led9>
<led10>0</led10>
<led11>0</led11>
<led12>0</led12>
<led13>0</led13>
<led14>0</led14>
<led15>0</led15>
<led16>0</led16>
<led17>0</led17>
<led18>0</led18>
<led19>0</led19>
<led20>0</led20>
<led21>0</led21>
<led22>0</led22>
<led23>0</led23>
<led24>0</led24>
<led25>0</led25>
<led26>0</led26>
<led27>0</led27>
<led28>0</led28>
<led29>0</led29>
<led30>0</led30>
<led31>0</led31>
<btn0>up</btn0>
<btn1>up</btn1>
<btn2>up</btn2>
<btn3>up</btn3>
<btn4>up</btn4>
<btn5>up</btn5>
<btn6>up</btn6>
<btn7>up</btn7>
<btn8>up</btn8>
<btn9>up</btn9>
<btn10>up</btn10>
<btn11>up</btn11>
<btn12>up</btn12>
<btn13>up</btn13>
<btn14>up</btn14>
<btn15>up</btn15>
<btn16>up</btn16>
<btn17>up</btn17>
<btn18>up</btn18>
<btn19>up</btn19>
<btn20>up</btn20>
<btn21>up</btn21>
<btn22>up</btn22>
<btn23>up</btn23>
<btn24>up</btn24>
<btn25>up</btn25>
<btn26>up</btn26>
<btn27>up</btn27>
<btn28>up</btn28>
<btn29>up</btn29>
<btn30>up</btn30>
<btn31>up</btn31>
<day>22/01/2020 </day>
<time0>14:47:29</time0>
<analog0>0</analog0>
<analog1>0</analog1>
<analog2>0</analog2>
<analog3>0</analog3>
<analog4>0</analog4>
<analog5>0</analog5>
<analog6>0</analog6>
<analog7>0</analog7>
<analog8>0</analog8>
<analog9>0</analog9>
<analog10>0</analog10>
<analog11>0</analog11>
<analog12>0</analog12>
<analog13>0</analog13>
<analog14>0</analog14>
<analog15>0</analog15>
<anselect0>0</anselect0>
<anselect1>0</anselect1>
<anselect2>0</anselect2>
<anselect3>0</anselect3>
<anselect4>0</anselect4>
<anselect5>0</anselect5>
<anselect6>0</anselect6>
<anselect7>0</anselect7>
<anselect8>0</anselect8>
<anselect9>0</anselect9>
<anselect10>0</anselect10>
<anselect11>0</anselect11>
<anselect12>0</anselect12>
<anselect13>0</anselect13>
<anselect14>0</anselect14>
<anselect15>0</anselect15>
<count0>0</count0>
<count1>0</count1>
<count2>0</count2>
<count3>0</count3>
<count4>0</count4>
<count5>0</count5>
<count6>0</count6>
<count7>0</count7>
<tinfo>---</tinfo>
<version>3.05.70</version>
</response>

**OButterlin** · 22/01/2020, 15h01

Dans la mesure où la réponse de l'IPX800 V3 à la requête getInputs est GetInputs=00000000000000000000000000000000, ce n'est pas vraiment nécessaire de passer par du Json ou xml, on a les valeurs directement par leur position... enfin, c'est ce que je pense... rien n'empêche d'utiliser autre chose bien sûr.

Pour ce qui est de la mise en œuvre, si je comprends bien, tu fais toujours la même requête mais sur plusieurs automates.
Donc, il suffirait de passer en paramètre à ta classe utilitaire l'adresse de l'automate et en retour passer un tableau contenant les 32 valeurs retournées par l'automate (avec une Exception en cas de problème).

**Gwendal2835** · 22/01/2020, 15h20

Envoyé par OButterlin

Dans la mesure où la réponse de l'IPX800 V3 à la requête getInputs est GetInputs=00000000000000000000000000000000, ce n'est pas vraiment nécessaire de passer par du Json ou xml, on a les valeurs directement par leur position... enfin, c'est ce que je pense... rien n'empêche d'utiliser autre chose bien sûr.

Pour ce qui est de la mise en œuvre, si je comprends bien, tu fais toujours la même requête mais sur plusieurs automates.
Donc, il suffirait de passer en paramètre à ta classe utilitaire l'adresse de l'automate et en retour passer un tableau contenant les 32 valeurs retournées par l'automate (avec une Exception en cas de problème).

Oui c'est bien ça, les valeurs correspondent a leurs position. "commande envoyée : 11111000000000000000000000000000" Voici lorsque les 5 premières leds sont allumées.

Il y aura deux trois requêtes différentes mais ça sera toujours les mêmes pour tous les automates. Oui voila ce que j'aimerais.

**OButterlin** · 22/01/2020, 15h40

Tu peux faire une classe utilitaire comme ceci

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
public class TestIPX800V3
{
 
    public static String test(String adresse, int port) throws Exception
    {
        try
        (
            Socket socket = new Socket(adresse, port);
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
        )
        {
            pw.write("GetInputs");
 
            String result = br.readLine();
            return result;
        }
    }
}

et l'appeler au niveau de ta servlet n fois avec les paramètres qui vont bien

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
// args est un tableau de String représentant la liste des automates...
        for (String target : args)
        {
            String result = null;
            try
            {
                result = TestIPX800V3.test(target, 9870);
            }
            catch (Exception e)
            {
                result = e.toString();
            }
            System.out.println("Test de l'état de l'automate " + target + " : " + result);
        }

**OButterlin** · 22/01/2020, 15h41

Ou alors passer par des requêtes Ajax à partir de ta page html... à toi de voir...

**Gwendal2835** · 22/01/2020, 15h59

Merci je vais regarder les deux pour trouver le plus adéquat

Mais je pense que la première façon est plus simple que faire de l'ajax.

**OButterlin** · 22/01/2020, 16h03

A voir... l'avantage de l'ajax est que tu envoies n requêtes en parallèle alors qu'avec la méthode simple, il faudra attendre le retour des n requêtes... (ce qui n'est pas forcément gênant d'ailleurs).

Dans la classe utilitaire, je te suggère de rajouter un timeout sur le socket, ça permet d'éviter d'attendre trop longtemps

Code Java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
        try
        (
            Socket socket = new Socket(adresse, port);
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
        )
        {
            socket.setSoTimeout(10 * 1000); // timeout 10 secondes
            pw.write("GetInputs");
 
            String result = br.readLine();
            return result;
        }

**OButterlin** · 23/01/2020, 09h31

Suite à ta demande d'explication et histoire que toutes les personnes intéressées puissent en profiter, voilà ce que je ferais.

1) Une simple page html pour l'IHM pour :
- ajouter les différentes adresses des automates à traiter
- visualiser l'état des automates enregistrés
- faire des extractions cycliques pour extraire les états

2) Une classe utilitaire qui prend en paramètre l'adresse de l'automate et envoie la commande "GetInputs" et renvoie le résultat

3) Une servlet pour récupérer les paramètres des requêtes ajax et appeler la classe utilitaire d'extraction de l'état automate

Comme les servlet sont multi-thread, 2 requêtes ajax seront traitées par 2 thread côté serveur

Le code de la page html

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
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8"/>
 
<script>
var automates = new Map();
 
function ajouterAutomate()
{
    var inputField = document.getElementById("automate");
    var adresse = inputField.value;
 
    if (automates.get(adresse) == null)
    {
        automates.set(adresse, "Initialisation en cours... ");
    }
 
    inputField.value = "";
    displayData();
    setTimeout(getAutomateData, 500, adresse);
}
 
function getAutomateData(adresse)
{
    var http = new XMLHttpRequest();
    http.open("GET", "http://localhost:8080/Automate/getState?addr=" + adresse, true);
    http.send();
    http.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 200)
        {
            var response = this.responseText;
            console.log(response);
            eval(response);                
            displayData();
        }
    }    
}
 
function displayData()
{
    var result = "";
    automates.forEach(function(valeur, cle) {
        result += cle + " = " + valeur + "<br/>";
    });
    document.getElementById("data").innerHTML = result;
}
 
function reloadData()
{
    automates.forEach(function(valeur, cle) {
        getAutomateData(cle);
    });
}
 
var intervalId = null;
function setTimer()
{
    if (intervalId != null)
    {
        clearInterval(intervalId);
        intervalId = null;
        document.getElementById("cyclique").innerHTML = "Démarrer l'extraction cyclique";
        return;
    }
    intervalId = setInterval("reloadData()", 5000);
    document.getElementById("cyclique").innerHTML = "Stopper l'extraction cyclique";
}
 
</script>
 
<style>
</style>
 
</head>
 
<body>
 
<form onsubmit="return false">
    <label for="automate">Adresse automate</label> <input type="text" id="automate"/>
    <button onclick="ajouterAutomate()">Ajouter automate</button>
    <button onclick="setTimer()" id="cyclique">Démarrer l'extraction cyclique</button>
    <div id="data">
    </div>
</form>
 
</body>
 
</html>

Comme tu peux le voir, il y a très peu de code html mais beaucoup de code javascript...

La méthode ajouterAutomate()

Elle est appelée par le bouton "Ajouter automate"
Elle se charge d'enrichir (si besoin) la map contenant les différents automates à traiter.
Elle demande le rafraichissement de la zone d'affichage des résultats (la <div> d'id "data") pour faire apparaître le nouveau venu directement (ne pas oublier que l'extraction peut prendre du temps).
Elle demande de lancer l'extraction de l'état de l'automate (getAutomateData) de manière diffférée (ici de 500ms)

La méthode getAutomateData(adresse)

C'est la méthode AJAX.
Elle prépare l'URL faisant référence à la servlet GetState (qui répond à /getState, voir l'annotation @WebServlet(urlPatterns = "/getState"))
Elle récupère l'objet XMLHttpRequest pour traiter la requête par javascript
Elle lance la requête et définie une méthode qui sera invoquée en retour (callback)
Pour faire simple, l'état qui nous intéresse est le readyState = 4 (requête terminée) et le statut de requête status = 200 (requête http ok)
Le résultat de la servlet est une commande javascript, il se récupère sous forme de texte via la propriété responseText. Pour exécuter le code renvoyé, il suffit de passer par la méthode eval(...)
Une fois le résultat évalué, on demande le raffraichissement de la zone d'affichage via la méthode displayData()

La méthode displayData()

C'est la méthode qui affiche le contenu de la map dans la <div> d'id "data".
La map a comme clé l'adresse de l'automate et comme valeur le résultat (ou la valeur initiale) liée à l'automate

La méthode setTimer()

Elle est appelée par le bouton "Démarrer l'extraction cyclique" ou "Stopper l'extraction cyclique" (même bouton mais on change le label)
Elle permet d'activer / désactiver l'extraction cyclique des états (ici toutes les 5 secondes, ce qui est court)

Le code de la classe utilitaire

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
public class IPX800V3
{
    public static String test(String adresse, int port) throws Exception
    {
        try
        (
            Socket socket = new Socket(adresse, port);
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
        )
        {
            socket.setSoTimeout(10000);
            pw.write("GetInputs");
 
            String result = br.readLine();
            return result;
        }
    }
}

Le code de la servlet

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
@WebServlet(urlPatterns = "/getState")
public class GetState extends HttpServlet
{
    private static final long serialVersionUID = 1;
 
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    {
        try
        ( PrintWriter out = response.getWriter();)
        {
            String adresse = request.getParameter("addr");
            System.out.println("Extraction de l'état de l'automate " + adresse + " en cours...");
            if (adresse != null)
            {
                String result = null;
                try
                {
                    result = IPX800V3.test(adresse, 9870);
                }
                catch (Exception e)
                {
                    result = e.toString();
                }
                StringBuilder sb = new StringBuilder();
                sb.append("automates.set(\"").append(adresse).append("\", ");
                sb.append("\"").append(result).append("\");");
                out.write(sb.toString());
            }
            System.out.println("Extraction de l'état de l'automate " + adresse + " terminée.");
        }
    }
}

Cette servlet répond donc aux requêtes ajax dans des thread séparés.
Elle récupère le paramètre "addr" qui contient l'adresse de l'automate à traiter
Elle appelle la classe utilitaire qui fait le job et renvoie le résultat ou le texte de l'exception sous forme d'une instruction javascript. Cette instruction sera évaluée côté client.

Pour rappel (au cas où) :

les pages html sont traitées côté client (le navigateur sur le poste de travail de l'utilisateur)
Les servlets sont traitées côté serveur (dans le conteneur de servlet du serveur d'application)

En action, voici le rendu de la page dans le navigateur
Nom : Screenshot_2020-01-23 Screenshot.png
Affichages : 356
Taille : 5,9 Ko

Nom : Screenshot_2020-01-23 Screenshot.png
Affichages : 356
Taille : 5,9 Ko

Comme tu peux le voir dans la log du serveur, les 2 requêtes s'éxécutent en parallèle
Nom : Capture.PNG
Affichages : 356
Taille : 20,9 Ko

Voilà, si tu as des questions, n'hésite pas

**Gwendal2835** · 23/01/2020, 11h04

Salut,

Merci pour ta réponse construite

J'ai donc essayé ton code, j'arrive a accéder a la page pour ajouter un automate.

Lorsque je rentre l'adresse IP j'ai une erreur : Nom : Capture.PNG
Affichages : 356
Taille : 9,4 Ko

Nom : Capture.PNG
Affichages : 356
Taille : 9,4 Ko

**OButterlin** · 23/01/2020, 12h31

Tu as créé un projet web pour ton application ?

Normalement, les étapes sont (avec Eclpse) :

- créer un projet de type "Dynamic Web Project" -> tu auras 2 répertoires : src pour les sources java, WebContent pour les pages
- créer un package "com.automate.state
- créer une classe GetState et copier le contenu (il faudra gérer les imports, le plus simple est de faire Ctrl+Shift+O)
- créer une classe IPX800V3 et copier le contenu (idem pour les imports)
- créer une page index.html dans le répertoire WebContent et copier le contenu

Ensuite, il faudra déployer sur ton serveur et démarrer ce dernier.

Pour tester, il faut (en local) taper l'url http://localhost:8080/Automate et ça devrait fonctionner...

**Gwendal2835** · 23/01/2020, 12h57

Oui j'ai bien créé un projet dynamic web.

Je met les deux classe dans le même package ?

C'est ce que j'ai fais pourtant.

J'ai aussi modifier le fichier xml.

Actuellement c'est une erreur lors de l'allocation pour la servlet [GetState].

Je me doute que le soucis provient du fichier xml..

Nom : Capture.PNG
Affichages : 354
Taille : 13,5 Ko

Nom : Capture.PNG
Affichages : 354
Taille : 13,5 Ko

Nom : Capture2.PNG
Affichages : 370
Taille : 45,3 Ko

**OButterlin** · 23/01/2020, 13h18

C'est quoi comme serveur d'application ?
Quelle version également ?

Problème de thread et socket : Affichage variables

Servlets/JSP Java

Discussions similaires

Partager

Partager