Discussion :

[Tanebisse]

Bonjour,
J'ai une classe java Toto qui étends la classe Thread, dans mon appli (Web JEE),
je créé un objet Toto, après avoir fait un Toto.start(), je créé une boucle while qui test si mon thread est tjrs actif et dans laquelle j'appelle une méthode de Toto qui me renvoie une valeur. Ex :

Code :

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

1
2
3
4
5
 
while(toto.isAlive()){
  maValeur = toto.calculValeur();
  return maValeur;
}

Mon soucis, c'est qu'une fois que j'ai fait le return, je suis sorti de ma boucle while, hors je voudrais continuer à appeler calculValeur car la valeur change régulièrement (c'est un écouteur de port). Comment puis-je faire ?

[dinobogan]

utilise la technique du listener.
Tu donnes un objet à ton Thread. Un peu de code sera plus facile à comprendre :

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
public interface Ecouteur
{
  public void newValue( int value );
}
 
public class EcouteurImpl implements Ecouteur
{
  public void newValue( int value )
  {
    ...je fais ce que je veux de "value"...
  }
}
 
public class MonThread implements Runnable
{
  private Ecouteur ecouteur;
 
  public MonThread( Ecouteur e )
  {
    ...
    ecouteur = e;
    ...
  }
 
  public void run()
  {
    ...
    while( bidule )
    {
      ...
      ecouteur.newValue( calculNewValue );
      ...
    }
  }
}

[Tanebisse]

Ok, je vais essayer, ça va me permettre de voir si j'ai bien compris. Par contre quel est l'intérêt de passer par une interface pour ecouteur ?

Le problème c'est que la méthode que tu appelles "calculNewValue()", c'est pas une méthode qu'on appelle c'est une méthode qui réagit à des évènements c'est l'implémentation serialEvent de l'interface SerialPortEventListener.

[dinobogan]

Par contre quel est l'intérêt de passer par une interface pour ecouteur ?

Le Thread n'a pas à connaitre la classe qui implémente l'interface. Il n'a pas à savoir que c'est une classe à toi, ou à Tartampion. Ca permet de faire du code réutilisable, évite d'utiliser des méthodes non permises dans le thread. On s'assure ainsi que le thread ne pourra utiliser que les méthodes de l'interface.

Le problème c'est que la méthode que tu appelles "calculNewValue()", c'est pas une méthode qu'on appelle c'est une méthode qui réagit à des évènements c'est l'implémentation serialEvent de l'interface SerialPortEventListener.

Peu importe. L'appel à "newValue" peut se faire n'importe ou dans ton thread. J'ai fait un "calculNewValue" juste pour l'exemple.
Si tu n'y arrives pas, donne le code qui te pose problème.

[Tanebisse]

Code de la classe Ecouteur

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
 
public class EcouteurCom implements SerialPortEventListener {
 
	private CommPortIdentifier portId;
 
	private SerialPort serialPort;
 
	private BufferedReader fluxLecture;
 
	private ActionForward action;
 
 
 
	/**
         *
         */
	public EcouteurCom() {
		// TODO Auto-generated constructor stub
	}
 
 
	/**
         * @param name
         */
	public EcouteurCom(String port) {
 
		// initialisation du driver
		Win32Driver w32Driver = new Win32Driver();
		w32Driver.initialize();
		// récupération de l'identifiant du port
		try {
			portId = CommPortIdentifier.getPortIdentifier(port);
		} catch (NoSuchPortException e) {
		}
		// ouverture du port
		try {
			serialPort = (SerialPort) portId.open("EcouteurCom", 2000);
		} catch (PortInUseException e) {
		}
		// récupération du flux
		try {
			fluxLecture = new BufferedReader(new InputStreamReader(serialPort
					.getInputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
		// ajout du listener
		try {
			serialPort.addEventListener(this);
		} catch (TooManyListenersException e) {
		}
		// paramétrage du port
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setSerialPortParams(9600, SerialPort.DATABITS_7,
					SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN);
		} catch (UnsupportedCommOperationException e) {
		}
		System.out.println("port ouvert, attente de lecture");
	}
 
 
 
	/*
	 * (non-Javadoc)
	 *
	 * @see javax.comm.SerialPortEventListener#serialEvent(javax.comm.SerialPortEvent)
	 */
	public void serialEvent(SerialPortEvent event) {
		// gestion des événements sur le port :
		// on ne fait rien sauf quand les données sont disponibles
		switch (event.getEventType()) {
			case SerialPortEvent.BI:
			case SerialPortEvent.OE:
			case SerialPortEvent.FE:
			case SerialPortEvent.PE:
			case SerialPortEvent.CD:
			case SerialPortEvent.CTS:
			case SerialPortEvent.DSR:
			case SerialPortEvent.RI:
			case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
				break;
			case SerialPortEvent.DATA_AVAILABLE:
				String codeBarre = new String();
				try {
					// lecture du buffer et affichage
					codeBarre = (String) fluxLecture.readLine();
					System.out.println(codeBarre);
					String[] tabCodes = codeBarre.split(";");
 
					if(tabCodes.length >= 2){
						String numProg = tabCodes[0];
						String numSeq = tabCodes[1];
						//TODO tester si le programme et la séquence existe
						this.action = new ActionForward("/accueil.do");
						this.action.setProperty("numProg", numProg);
						this.action.setProperty("numSeq", numSeq);
 
					}
				} catch (IOException e) {
				}
				break;
		}
	}
 
 
 
	/**
         * @return the action
         */
	public ActionForward getAction() {
		return action;
	}
 
 
	/**
         * @param action the action to set
         */
	public void setAction(ActionForward action) {
		this.action = action;
	}
 
}

Code du Thread

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
 
public class EcouteurThread extends Thread {
 
	private boolean running;
	private EcouteurCom ecouteur;
 
	public EcouteurThread(EcouteurCom ec) {
		this.ecouteur = ec;
	}
 
	// Méthode appelé quand on fait thread.start
	public void run() {
		running = true;
		while (running) {
			try {
				Thread.sleep(2000);
 
			} catch (InterruptedException e) {
			}
		}
	}
 
	/**
         * Permet l'arrêt du thread
         */
	public void stopThread() {
		running = false;
	}
 
}

Ce que je voudrais récupérer c'est la propriété action de la classe EcouteurCom. En fait je dév avec Struts 1.3.8 et je suis dans une classe action quand je fais le "new EcouteurThread(ecouteurCom)". Ce que je veux au final c'est pouvoir modifier ma JSP en fonction des évènement d'ecouteurCom.

Je dois ajouter quoi à la méthode run ?

[dinobogan]

La classe qui génère l'événement appelle une méthode de l'interface.
Qui génère l'événement ? EcouteurCom.
Il faut donc transmettre un Ecouteur au constructeur de EcouteurCom.
La confusion vient du fait que dans mon exemple, celui qui génère l'événement est le thread, contrairement à ton appli.