Design pattern : Visiteur

Le pattern visiteur est, a mon sens, l'un des patterns les plus importants. Il est classé parmi les patterns comportementaux mais de par son utilisation, il est aussi un pattern structurel.

Le premier intérêt du pattern visiteur est de permettre de découpler les comportements des structures des objets surtout si les comportements ne sont pas tous définis et doivent être extensible. La logique métier est définie a coté de la structure objet stockant les données. A noter qu'en règle générale, cette démarche est a proscrire en POO... sauf, sauf, sauf dans ce cas. Oui le pattern visiteur est fait pour ça, il sépare les préoccupations.



Deuxième intérêt, s'il ne s'agissait que de découpler les aspects comportements et structures, certains avanceront que l'on peut s'en passer....  Sauf .. qu'en fait le visiteur ne vient pas qu'avec cette capacité. En effet, le visiteur a aussi pour but (du fait de son besoin de visiter son objet visitable) de permettre l'appel a d'autres visiteur en faisant le parcours de ses dépendances. Avec cette capacité, le pattern visiteur acquiert le status d'iterateur (Actif) sur un parcourt de graphe, a choisir, le visiteur offrira bien plus de souplesse que l'iterateur.

Ainsi, dans son fonctionnement, le visiteur vient avec une interface Visitable qu’implémentera son client. Cette interface définit la méthode accept prenant en paramètre nos visiteurs. Cette méthode une fois implémentée appellera la méthode visit du visiteur en se passant en paramètre afin de donner a celui-ci toutes ses capacités publiques accessibles ou privées via un peu de reflexivité.

A noter que le pattern visiteur implique cependant une contrainte que la structure a visiter soit suffisamment stable de façon a ne pas avoir une double ration de maintenance a faire dans le cas de modification sur le modèle objet.

Design pattern : Iterator

Le pattern est un pattern compagnon. Il permet d'abstraire et de découpler le comportement de parcourt sur les listes.

L'iterateur permet l’accès multiple aux éléments de la liste ou même d’implémenter des parcours spécifiques (comme le reverse, ou les filtres):

Aujourd'hui, surtout en Java, ou en Groovy, l'iterateur est masqué derrière des sucres syntaxiques

Ainsi sur une liste standard en java on écrira ceci:

List<String> l=new ArrayList<>();
for(String s:l)
{
  // TODO
}

alors que classiquement on l'utilisation de l'iterateur se manipule ainsi:

Iterator<String> it=l.iterator();
for(it.hasNext())
{
  String s=it.next();
  //TODO
}

Ceci est la façon standard d'utiliser les iterateurs impliquant que l'on implémente de moins en moins nos propres iterateurs alors qu'il permettent

• de fournir des parcour spécifique
• de modéliser des générateurs

La description que nous donnons la de l'iterateur est celui que tout le monde connait, il s'agit en fait de l'iterateur que l'on appelle Passif. Il existe cependant un autre type d'iterateur, l'iterateur Actif.

L'iterateur Actif est justement ce que l'on pourrait considérer comme l'apanage de l'iteration. Autant si l'iterateur passif peut fournir sous differentes formes des manières de parcourir les éléments de la liste, l'iterateur actif va proposer d'ajouter des traitements sur les éléments choisi ou non.

Ainsi, le prototype d'un iterateur passif sera souvent simplement hasNext pour savoir s'il existe un suivant et next pour obtenir l’élément, l'iterateur actif proposera des prédicats d’existences de certains type d’éléments, une iteration spécifique sur ceux ci, voir un traitement en ligne de ces données, voir même des procédures de recherche d’éléments particuliers.

Les iterateurs actif sont assez peu présent dans les patterns que l'on peut croiser, pourtant ils fournissent souvent des moyens élégants de réaliser des opérations arithmétiques, des concaténations, etc