Programmation évènementielle [Résolu]

LocalStone 515 Messages postés mercredi 19 mars 2003Date d'inscription 1 mars 2009 Dernière intervention - 22 févr. 2008 à 01:56 - Dernière réponse : LocalStone 515 Messages postés mercredi 19 mars 2003Date d'inscription 1 mars 2009 Dernière intervention
- 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
Afficher la suite 

Votre réponse

6 réponses

cs_DARKSIDIOUS 15838 Messages postés jeudi 8 août 2002Date d'inscription 4 mars 2013 Dernière intervention - 23 févr. 2008 à 06:15
+3
Utile
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
Cette réponse vous a-t-elle aidé ?  
Commenter la réponse de cs_DARKSIDIOUS
cs_DARKSIDIOUS 15838 Messages postés jeudi 8 août 2002Date d'inscription 4 mars 2013 Dernière intervention - 22 févr. 2008 à 06:03
0
Utile
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
Commenter la réponse de cs_DARKSIDIOUS
LocalStone 515 Messages postés mercredi 19 mars 2003Date d'inscription 1 mars 2009 Dernière intervention - 22 févr. 2008 à 13:29
0
Utile
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 ...

LocalStone
Commenter la réponse de LocalStone
cs_DARKSIDIOUS 15838 Messages postés jeudi 8 août 2002Date d'inscription 4 mars 2013 Dernière intervention - 22 févr. 2008 à 18:56
0
Utile
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
Commenter la réponse de cs_DARKSIDIOUS
LocalStone 515 Messages postés mercredi 19 mars 2003Date d'inscription 1 mars 2009 Dernière intervention - 22 févr. 2008 à 21:58
0
Utile
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 ?

LocalStone
Commenter la réponse de LocalStone
LocalStone 515 Messages postés mercredi 19 mars 2003Date d'inscription 1 mars 2009 Dernière intervention - 23 févr. 2008 à 12:15
0
Utile
D'accord, je comprend mieux. Merci beaucoup pour ta réponse !

LocalStone
Commenter la réponse de LocalStone

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.