Discussion :

[ploxien]

Hello,

Je voudrais propager une exception, comme cela:

Code :

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

throw new NagiosException("Unable to call Method "+functionName+":"+e.getMessage());

Seulement, je voudrais faire cela dans une méthode run() de Runnable, qui n'est pas prévue pour propager d'exception... Comment faire?

Ce que je voudrais:

Code :

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

1
2
3
4
5
6
7
8
        // Create runnable
        final Runnable r = new Runnable(){
 
            @Override
            public void run() throws NagiosException {
                // génération de l'exception
            }
        };

Y a-t-il un moyen détourné?

Merci d'avance,
A+

[adiGuba]

Salut,



Tu peux utiliser une RuntimeException... mais dans ce cas rien ne t'obligera à la traiter (et le thread sera interrompu).

Quel est le contexte d'utilisation ?

a++

[ploxien]

J'utilise un Timer:

Code :

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

1
2
3
4
5
6
7
8
        Timer tm = new Timer();
        tm.schedule(new TimerTask(){
            @Override
            public void run() {
            t = new Thread(r);
            t.start();
            }
        }, startTime, freq);

Et c'est dans le Runnable r que cette exception peut être levée.

P.S. J'ai mis seulement une partie de mon code, il est indispensable que je fasse comme cela, même si dans ce cas ça peut parraitre étrange...

Merci, si tu as une idée...

A+

[adiGuba]

Si tu utilises une RuntimeException cela arrêtera le thread "violemment"...


Sinon ce que tu peux faire c'est de gérer cela au niveau de ton Runtime :

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
abstract class AbstractRunnable implements Runnable {
 
	/**
         * On utilise une méthode abstraite qui remplacera run(),
         * et qui permet de remonter n'importe quelle exception :
         * @throws Throwable
         */
	public abstract void runOrThrow() throws Throwable;
 
	/** On utilise un attribut pour stocker les eventuelles exceptions : */
	private Throwable throwable = null;
 
	/**
         * On implémente run() afin qu'elle appelle runOrThrow() et conserve
         * les éventuelles exceptions...
         */
	public final void run() {
		try {
			runOrThrow();
		} catch (Throwable t) {
			this.throwable = t;
		}
	}
 
	// + des méthodes utilitaires pour déterminer s'il y a eu une exception ou pas :
 
	public boolean isValid() {
		return this.throwable==null;
	}
 
	public Throwable getThrowable() {
		return this.throwable;
	}
}

Tu implémentes runOrThorw() au lieu de run(), et à la fin tu peux récupérer les éventuelles exceptions via getThrowable()...

a++