Remonter une exception de la méthode Run() ?

Version imprimable

29/01/2007, 14h39
Jonef

Remonter une exception de la méthode Run() ?

Bonjour,
je développe une application bluetooth client/serveur qui me force à utiliser des threads pour l'exécution de certaines méthodes du package javax.bluetooth. En fait j'ai une classe serveur qui implémente l'interface Runnable.
Dans la méthode Run() j'exécute des méthodes qui me revoient des exceptions, or je ne trouve aucun moyen pour transmettre ces exceptions à mon interface graphique. En effet la méthode Run() ne supporte pas throws exception.
Avez-vous une solution?
Merci beaucoup.;)
29/01/2007, 14h43
CyberChouan
Et bien tu rattrapes ton exception, et tu invoque une méthode spécifique qui signale une exception sur ton interface graphique, et qui effectue l'action appropriée pour que ton programme reste stable (return null, return, levée d'une autre Exception...).

Tu peux d'ailleurs passer l'exception elle-même en paramètre de la méthode.
Code:

1 2 3 4 5 6 7 8 9 // [...] // ici tu es suceptible de lever une exception try { maMethode(); } catch (Exception e) { monInterfaceGraphique.attentionException(e); } // [...]
29/01/2007, 15h06
Jonef

Effectivement c'est une solution mais j'aurais bien voulu rendre ma classe "dépendante" de son parent car plusieurs GUI utiliseront l'objet. :(
Merci pour cette solution. :D
Si quelq'un à une autre idée? :roll:

Cree-toi une interface de gestionnaire d'erreurs (ex : ErrorHandler) que tu passes en parametre de ta methode ou de ta classes et que tu appelles en cas d'exception... apres le gestionnaire concret peut-etre une sortie console, un gestionnaire centralise qui fait du log ou qui gere les affichages centralies, ... ou juste la boite de dialogue parente qui a lance la thread (note : penser SwingUtilities.invokeAndWait() lorsqu'il s'agit de faire apparaitre des boites de dialogues pour les erreurs generees dans d'autres Threads)...

Un truc du genre (vite tape) :

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
public interface ErrorHandler {
  public void handleError(Throwable t);
  public void handleError(Throwable t, String message);
  ...
}
 
public class MySimpleDialog extends ... implements ErrorHandler {
  /** @inheritDoc
   */
  public void handleError(Throwable t) {
     if (t != null) {
       /** @todo Verify we're in EDT and popup a dialog box directly.  
        * If not in EDT, use SwingUtilities.invokeAndWait() instead.
        */
    }
  }
}
 
public class MyConfigurableDialog extends  ... implements ErrorHandler {
   /** Error handler has been changed. 
   */
   public static final String ERROR_HANDLER_PROPERTY = "errorhandler";
 
   /** The error handler.
    */
   private ErrorHandler errorHandler = DefaultGUIErrorHandler.getInstance();
 
   /** Sets the error handler.
    * @param newValue The new value.
    * @see #getErrorHandler
    */
   public void setErrorHandler(ErrorHandler newValue) {
      ErrorHandler oldValue = this.errorHandler 
      this.errorHandler  = newValue;
      firePropertyChange(ERROR_HANDLER_PROPERTY, oldValue, newValue);
   }
 
   /** Gets the error handler.
    * @return A <code>ErrorHandler</code> or <code>null</code>.
    * @see #setErrorHandler
    */
   public ErrorHandler getErrorHandler() {
     return errorHandler;
   }
 
  /** @inheritDoc
   */
   public void handleError(Throwable t) {
       ErrorHandler errorHandler = getErrorHandler();
       if ((errorHandler != null) && (errorHandler != this)) {
          errorHandler.handleError(t);
       }
       else { 
          DefaultGUIErrorHandler.getInstance().handleError(t);
       }
   }
}
 
public final class DefaultGUIErrorHandler implements ErrorHandler {
   private static final INSTANCE = new DefaultGUIErrorHandler 
 
   public static DefaultGUIErrorHandler getInstance() {
     return INSTANCE;
   }
 
  /** @inheritDoc
   */
  public void handleError(Throwable t) {
     if (t != null) {
       /** @todo Verify we're in EDT and popup a dialog box directly.  
        * If not in EDT, use SwingUtilities.invokeAndWait() instead.
        */
    }
  }
}
 
public class DefaultConsoleErrorHandler implements ErrorHandler {
  /** @inheritDoc
   */
  public void handleError(Throwable t) {
    if (t != null) {
      System.err.println(t);
      t.printStackTrace();
    }
  }
}

Citation:

Envoyé par Jonef

Effectivement c'est une solution mais j'aurais bien voulu rendre ma classe "dépendante" de son parent car plusieurs GUI utiliseront l'objet. :(
Merci pour cette solution. :D
Si quelq'un à une autre idée? :roll:

La methode de Bouye est certainement meilleure que la mienne ;)
Cependant, pour répondre à ta question et continuer sur mon idée, il suffit de passer l'interface graphique parente en parametre de la classe. Ainsi, elle devient dépendante de ce paramètre.
Code:

1 2 3 4 5 6 7 8 private JFrame monInterfaceGraphique; public void setMonInterfaceGraphique(JFrame interfaceGraphique) { this.monInterfaceGraphique = interfaceGraphique; } // Code de mon precedent post
Juste une petite précision... Pour programmer proprement, il est bien que les classes métier soient indépendantes de l'interface graphique. Donc le code ci-dessus n'est en général pas posé sur la classe métier mais sur un controlleur intermédiaire qui fait le lien entre ta classe métier et ton interface graphique.
Pour avoir plus de détails sur l'implémentation, je t'invite à te renseigner sur le modèle de programmation PAC.

30/01/2007, 22h06
Jonef

Ok!
Merci bien à vous deux! :king: