Spring et les design patterns

List<String> liste = new ArrayList<String>(); 
UtilisateurDao dao = (UtilisateurDao)  
factory.getBean("utilisateurDao"); 

Façade

Une façade est par exemple une classe qui concentre les API d’un ensemble de classes en un unique point dans une classe façade. Spring JDBC est un exemple de façade qui masque les différences entre les implémentations de diverses bases de données via une API unifiée. Spring JDBC permet également de simplifier la gestion des exceptions liées aux bases de données. Il offre une façade qui encapsule de façon uniforme des traitements très différents d’une base à une autre, mais qui sont vus comme identiques du côté de la façade.

Un service Spring (annoté avec @Service) peut être considéré comme une façade qui expose d’un côté des API métier et de l’autre côté s’interface avec les DAO pour effectuer les opérations métier et bases de données.

Cette façade permet alors de concevoir une API qui peut être simple, testable. Le programme qui utilise la façade n’a plus besoin des dépendances car celles-ci sont déplacées dans la façade.

Fabrique

Spring utilise un modèle de fabrique (factory) pour créer des beans à l’aide d’une référence au contexte applicatif. Ces beans sont décrits dans la configuration. Une partie de la configuration est fixée à l’avance alors qu’une autre partie est déduite à partir de règles relativement complexes. Spring trouve le meilleur candidat pour un contrat d’API donné.

BeanFactory factory = new XmlBeanFactory(new  
FileSystemResource("spring.xml")); 
Triangle triangle = (Triangle) factory.getBean("triangle"); 
triangle.draw(); 

Spring met à disposition une batterie complète de fabriques afin de couvrir un maximum de cas d’utilisation à travers l’interface BeanFactory. Cette interface a en effet neuf sous-interfaces et vingt-quatre implémentations dans sa dernière version.

La fabrique peut être visible dans le cas d’une application standalone. Nous utilisons alors une factory qui se base sur des fichiers comme celle citée dans l’exemple. Pour une application web, la fabrique se cache dans un filtre de servlet.

Décorateur

Un décorateur se base sur un composant concret qui implémente une interface. Le décorateur est lui-même dérivé de cette interface. Il inclut l’objet d’origine et lui ajoute des attributs ou des méthodes. Il permet l’interception de méthodes mais il utilise l’héritage.

interface Pojo3 {  
    public void foo();  
} 
 
class SimplePojo3 implements Pojo3 {  
    public void foo() {  
        System.out.println("foo");  
    }  
} 
 
class RetryAdvice implements AfterReturningAdvice {  
   public void afterReturning(Object returnValue, Method method,  
         Object[] args, Object target) throws Throwable {  
      System.out.println("Après "+method.getName());  
   }  
} 
 
public class MainAvecAspect {  
    public static void main(String[] args) {  
        ProxyFactory factory = new ProxyFactory(new SimplePojo3()); 
        Class<?> intf=Pojo3.class;  ...

Modèle Vue Contrôleur (MVC)

Spring MVC permet de faire simplement des applications web en séparant les trois éléments principaux :

Spring délègue le choix de la vue à un ViewResolver qui est, lui-même, un design pattern.

Par exemple, le contrôleur suivant sur la sollicitation de l’URL /bonjourdemandera l’affichage de la page bonjour.jsp en lui fournissant la date pour que la page l’affiche :

@Controller 
public class BonjourController { 
  @RequestMapping("/bonjour") 
  public ModelAndView bonjour() { 
    ModelAndView mav = new ModelAndView(); 
    mav.setViewName("bonjour"); 
    mav.addObject("date", new Date()); 
    return mav; 
  } 

Les templates

On utilise des templates (modèles) pour tous les codes génériques.

Spring utilise massivement ces templates. Voici quelques exemples :

Ce livre présente des exemples pour l’utilisation de certains de ces templates.

Les templates sont une grande force pour Spring car ils simplifient le code. Ils masquent la complexité et il est même possible d’interfacer un système exotique en étendant un template Spring et d’offrir une interface standard aux développeurs.

Stratégie

L’injection de dépendances (DI) est un design pattern de stratégie. En effet, chaque fois que vous voulez mettre en place une logique d’interchangeabilité entre beans, vous trouverez une interface qui correspond à un constructeur ou une méthode setter appropriée sur la classe d’accueil pour câbler votre propre implémentation de cette interface.

Pour une même interface, nous pouvons demander à Spring d’injecter un objet implémentant l’interface et choisir ainsi un objet ou un autre ayant les mêmes API de traitement mais avec des API ayant des comportements différents. Par exemple, pour une liste qui a pour interface List on pourra choisir entre les implémentations suivantes : AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, Linked List, RoleList, RoleUnresolvedList, Stack, Vector... en fonction du comportement que l’on souhaitera avoir.

Points clés