LocalStone
Messages postés514Date d'inscriptionmercredi 19 mars 2003StatutMembreDernière intervention 1 mars 2009
-
22 févr. 2008 à 01:56
LocalStone
Messages postés514Date d'inscriptionmercredi 19 mars 2003StatutMembreDernière intervention 1 mars 2009
-
23 févr. 2008 à 12:15
Salut à tous !
Je pense que le titre de mon sujet résume bien le thème de ma question : comment faire de la programmation évènementielle en Java ? Attention, je ne parle pas de Swing ou de n'importe quelle autre IHM. Je parle plutôt dans le cas général.
Un exemple tout bête ... Imaginons une application qui scanne toutes les 5 minutes un répertoire pour voir s'il y a des modification dedans et qui effectue une action particulière en fonction de cette action. On aura alors une classe qui va envoyer des évènements (la classe qui scanne le répertoire), et une classe qui effectue l'action correspondante.
Je pense qu'il faut s'orienter vers le pattern Observer (ou observateur pour les plus français d'entre-nous), mais quelque chose m'echappe ...
En C#, par exemple, il y a un mot clé particulier pour gérer les evenements. Du coup, on peut avoir un évènement qui va correspondre à la suppression d'un fichier, un qui va correspondre au renommage, etc.).
Le truc, c'est qu'avec le pattern Observer, on va pouvoir s'abonner qu'à UN seul évènement. Alors comment faire pour pouvoir différencier l'évènement qui a été réalisé ? Je suppose que la solution se trouve dans un paramètre de type Event que l'on va faire passer à la méthode qui va être appellée. Mais cela implique une grosse suite de if else qui va permettre de différencier l'évènement ... Et ça, saymal.
En fait mon problème est là ... Existe-il une solution propre en Java qui pourrait résoudre le problème que je viens de poser ?
Merci beaucoup pour vos idées et pour les temoignages que vous allez apporter !
LocalStone
cs_DARKSIDIOUS
Messages postés15814Date d'inscriptionjeudi 8 août 2002StatutMembreDernière intervention 4 mars 2013131 23 févr. 2008 à 06:15
Salut,
Comme je t'avais dit plus haut : tu as plusieurs solutions : le listener est le plus utilisé, et le plus simple (et souple) à mettre en place.
Il permet de passer des objets d'événements dans la fonction appellée (pattern commande si on va par là).
L'Observable/observer permet plutôt (en théorie) d'être notifié lorsqu'une ou plusieurs valeur(s) de l'objet qu'on observe est modifié (tu me dira, dans 90 % des cas, c'est ce qui se passe avec les listeners). Il permet aussi d'accumuler plusieurs modifications de variables et ne déclencher la notification qu'une fois un traîtement terminé là où le listener est un appel direct à l'événement (si tu te limite au cas simple).
Le listener quant à lui peut être utilisé pour être notifié quand tu le juge bon : en entrée de fonction par exemple pour annuler le traîtement de celle-ci (grâce à l'objet que tu lui passe en paramètre), et à la fin de cette même fonction pour notifier que c'est fini (pour un traitement asynchrone par exemple) par exemple.
Disons pour résumer que le Listener s'apparente beaucoup à l'observer, mais est plus générique : là où l'observer se limite à la modification des valeurs, le listener permet plus de choses et de personnaliser les événements déclenchés.
______________________________________
DarK Sidious
cs_DARKSIDIOUS
Messages postés15814Date d'inscriptionjeudi 8 août 2002StatutMembreDernière intervention 4 mars 2013131 22 févr. 2008 à 06:03
Salut,
Tu as plusieurs solutions qui s'offre à toi, mais la plus utilisée en java est d'utiliser des Listener : une interface permettant de s'abonner aux événements que te procure une classe, et une autre qui te permet de recevoir les événements par des appels à des fonctions que tu dois redéfinir.
______________________________________
DarK Sidious
LocalStone
Messages postés514Date d'inscriptionmercredi 19 mars 2003StatutMembreDernière intervention 1 mars 2009 22 févr. 2008 à 13:29
Salut,
En fait je connaissais ça : c'est en gros l'application du pattern Observer. Mais ce que je ne comprends pas, c'est comment faire pour distinguer 2 évènements différents. En effet, l'utilisation de l'interface Listener permet de s'abonne qu'à un seul évènement ...
cs_DARKSIDIOUS
Messages postés15814Date d'inscriptionjeudi 8 août 2002StatutMembreDernière intervention 4 mars 2013131 22 févr. 2008 à 18:56
Salut,
C'est là où les le listener se distingue de l'observer (qui existe aussi directement en java : suffit d'implémenter l'interface observable) : il est possible de définir plusieurs fonctions (correspondant à plusieurs événements) dans la même interface de listener (comme pour les événements clavier par exemple avec l'interface KeyboardListener qui possède plusieurs événements qui se déclenche au moment opportun).
______________________________________
DarK Sidious
Vous n’avez pas trouvé la réponse que vous recherchez ?
LocalStone
Messages postés514Date d'inscriptionmercredi 19 mars 2003StatutMembreDernière intervention 1 mars 2009 22 févr. 2008 à 21:58
Merci pour ta réponse ... Qui entraîne alors une question : à quoi servent alors les interfaces Observable et Observer fournies par l'API Java ? Parce qu'à la limite, on peut faire tout avec des listeners, non ?