sio:bloc2:poo:designpattern

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
sio:bloc2:poo:designpattern [2024/09/03 11:06] – supprimée - modification externe (Date inconnue) 127.0.0.1sio:bloc2:poo:designpattern [2024/09/03 11:06] (Version actuelle) – ↷ Page déplacée de slam4:poo:designpattern à sio:bloc2:poo:designpattern jcheron
Ligne 1: Ligne 1:
 +====== Patrons de conception ======
  
 +Les patrons de conception (design patterns) apportent des solutions algorithmiques et d'implémentation aux problèmes courants rencontrés dans le cadre de la conception orientée objet. 
 +
 +
 +
 +===== Le Singleton (Singleton) =====
 +
 +<html><div class='idea'>
 +Problématique : Créer et avoir toujours à disposition une unique instance d'une classe 
 +</div></html>
 +
 +
 +Le pattern Singleton apporte une solution aux cas où une unique instance d'une classe doit exister dans un programme (pour une gestion d'un pool de connexions, une gestion du cache, une instance d'application...)
 +==== Diagramme de classes ====
 +
 +{{:slam4:poo:singleton.png?|}}
 +
 +==== Implémentation en java ====
 +
 +<sxh java ;title:Singleton en java>
 +public final class Singleton {
 +
 +  private static Singleton instance;
 +
 +  private Singleton() {
 +    // constructeur
 +  }
 +
 +  public static Singleton getInstance() {
 +    if (instance == null) {
 +      synchronized (Singleton.class) {
 +        instance = new Singleton();
 +      }
 +    }
 +    return instance;
 +  }
 +
 +  @Override
 +  public Object clone() throws CloneNotSupportedException {
 +    throw new CloneNotSupportedException();
 +  }
 +}
 +</sxh>
 +
 +==== Utilisation ====
 +
 +Il est ensuite possible de faire appel à la méthode getInstance qui retournera toujours l'instance unique de singleton.
 +
 +<sxh java ;title:Utilisation>
 +Singleton.getInstance();
 +</sxh>
 +
 +===== La Fabrique (Factory) =====
 +
 +<html><div class='idea'>
 +Problématique : Créer différents objets dont le type peut varier à l'exécution, en fonction du déroulement du programme 
 +</div></html>
 +
 +==== Objectifs ====
 +
 +La fabrique est une classe de création d'objets, de différents types, héritant d'une classe de base, ou implémentant une interface. Elle permet la création d'objets dynamiquement en fonction de paramètres passés.
 +
 +
 +==== Caractéristiques ====
 +  * La fabrique étant souvent unique dans le programme, elle peut utiliser le pattern Singleton
 +  * Les paramètres passés à la fabrique déterminent le type d'instance à créer
 +
 +==== Diagramme de classes ====
 +
 +{{:slam4:poo:factory.png?|}}
 +
 +==== Implémentation en java ====
 +
 +Les différents types à créer (héritant d'un type générique)
 +
 +<sxh java ;title:Types d'objets>
 +public abstract class Animal{
 +   public abstract void myName();
 +}
 +
 +public class Chat extends Animal{
 +   public void myName(){
 +     System.out.println("Je suis un Chat");
 +   }
 +}
 +
 +public class Chien extends Animal{
 +   public void myName(){
 +     System.out.println("Je suis un Chien");
 +   }
 +}
 +</sxh>
 +
 +La fabrique :
 +
 +<sxh java ;title:Fabrique en java>
 +public class FabriqueAnimal{
 +
 +    private static FabriqueAnimal instance = new FabriqueAnimal();
 +    
 +    private FabriqueAnimal(){}
 +
 +    public static FabriqueAnimal getFabriqueAnimalInstance(){
 +        return instance ;
 +    }
 +
 +    public Animal getAnimal(String typeAnimal) throws ExceptionCreation{
 +        Animal result=null;
 +        switch(typeAnimal){
 +            case "chat":
 +                result= new Chat();
 +                break;
 +            case "chien":
 +                result=new Chien();
 +                break;
 +            default:
 +                throw new ExceptionCreation("Impossible de créer un " + typeAnimal);
 +                break;
 +        }
 +        return result;
 +    }
 +}
 +</sxh>
 +
 +
 +Utilisation :
 +
 +<sxh java;title:Programme java>
 +public class DemoFabrique{
 +   public static void main(String [] args){
 +     FabriqueAnimal fabrique =  FabriqueAnimal.getFabriqueAnimalInstance();
 +     Animal animal = FabriqueAnimal.getAnimal("chat");
 +     animal.myName(); 
 +   }
 +}
 +</sxh>
 +
 +===== La Fabrique abstraite (Abstract Factory) =====
 +
 +<html><div class='idea'>
 +Problématique : Créer différents objets dont le type peut varier à l'exécution, en fonction du déroulement du programme, dissocier création et utilisation pour permettre l'ajout de nouveaux objets, sans modifier le code du programme utilisateur.
 +</div></html>
 +
 +==== Objectifs ====
 +
 +La fabrique est un créateur d'objets, de différents types, héritant d'une classe de base, ou implémentant une interface. Elle permet d'isoler la création des objets de leur utilisation.\\
 +On peut ainsi ajouter de nouveaux objets dérivés sans modifier le code qui utilise l'objet de base.
 +
 +
 +==== Implémentation en java ====
 +
 +Les différents types d'objet à créer et leur classe de base :
 +
 +<sxh java>
 +public abstract class Button{
 +    private String caption;
 +    public abstract void paint();
 +     
 +    public String getCaption(){
 +        return caption;
 +    }
 +
 +    public void setCaption(String caption){
 +        this.caption = caption;
 +    }
 +}
 + 
 +class WinButton extends Button{
 +    public void paint(){
 +        System.out.println("I'm a WinButton: "+ getCaption());
 +    }
 +}
 +
 +class OSXButton extends Button{
 +    public void paint(){
 +        System.out.println("I'm a OSXButton: "+ getCaption());
 +    }
 +}
 +
 +</sxh>
 +
 +
 +Les factories concrètes et leur classe abstraite :
 +
 +<sxh java>
 +/*
 + * GUIFactory example
 + */
 +public abstract class GUIFactory{
 +    public static GUIFactory getFactory(){
 +        int sys = readFromConfigFile("OS_TYPE");
 +        if (sys == 0)
 +            return(new WinFactory());
 +        else
 +            return(new OSXFactory());
 +    }
 +    public abstract Button createButton();
 +}
 +
 +class WinFactory extends GUIFactory{
 +    public Button createButton(){
 +        return(new WinButton());
 +    }
 +}
 +
 +class OSXFactory extends GUIFactory{
 +    public Button createButton(){
 +        return(new OSXButton());
 +    }
 +}
 +</sxh>
 +
 +
 +=== Utilisation : ===
 +
 +<sxh java>
 +public class DemoAbstractFactory{
 +    public static void main(String[] args){
 +        GUIFactory aFactory = GUIFactory.getFactory();
 +        Button aButton = aFactory.createButton();
 +        aButton.setCaption("Jouer");
 +        aButton.paint();
 +    }
 +}
 +</sxh>
 +
 +==== Limites ====
 +  * Introduit une certaine complexité dans le développement, parfois à éviter
 +
 +
 +===== Le poids mouche (Flyweight) =====
 +<html><div class='idea'>
 +Problématique : Eviter de créer un trop grand nombre d'instances d'une classe ayant des propriétés intrinsèques 
 +</div></html>
 +
 +
 +Le poids mouche permet de factoriser le nombre d'instances à créer d'une classe, en permettant la réutilisation d'instance existantes.
 +
 +==== Diagramme de classes ====
 +{{:slam4:poo:flyweight.png?|}}
 +
 +==== Implémentation en java ====
 +Source : http://www.journaldev.com/1562/flyweight-pattern-in-java-example-tutorial
 +
 +Création de formes (Shape), de types concrets (Line, oval...)
 +
 +=== Models ===
 +
 +<sxh java;title:Shape>
 +package models;
 +
 +import java.awt.Color;
 +import java.awt.Graphics;
 +
 +public interface Shape {
 + public void draw(Graphics g, int x, int y, int width, int height, Color color);
 +}
 +</sxh>
 +
 +<sxh java;title:Line>
 +package models;
 +
 +import java.awt.Color;
 +import java.awt.Graphics;
 +
 +public class Line implements Shape {
 + @Override
 + public void draw(Graphics g, int x, int y, int width, int height, Color color) {
 + g.setColor(color);
 + g.drawLine(x, y, width, height);
 + }
 +}
 +</sxh>
 +
 +<sxh java;title:Oval>
 +package models;
 +
 +import java.awt.Color;
 +import java.awt.Graphics;
 +
 +public class Oval implements Shape {
 +
 + private boolean fill;
 +
 + public Oval(boolean fill) {
 + this.fill = fill;
 + }
 +
 + @Override
 + public void draw(Graphics g, int x, int y, int width, int height, Color color) {
 + g.setColor(color);
 + g.drawOval(x, y, width, height);
 + if (fill) {
 + g.fillOval(x, y, width, height);
 + }
 + }
 +}
 +</sxh>
 +
 +=== Factory ===
 +
 +<sxh java;title:ShapeFactory>
 +package models;
 +
 +import java.util.HashMap;
 +
 +public class ShapeFactory {
 +
 + private static final HashMap<ShapeType, Shape> shapes = new HashMap<ShapeType, Shape>();
 +
 + public static Shape getShape(ShapeType type) {
 + Shape shapeImpl = shapes.get(type);
 +
 + if (shapeImpl == null) {
 + switch (type) {
 + case OVAL_FILL:
 + shapeImpl = new Oval(true);
 + break;
 + case OVAL:
 + shapeImpl = new Oval(false);
 + break;
 + case LINE:
 + shapeImpl = new Line();
 + break;
 + }
 + shapes.put(type, shapeImpl);
 + }
 + return shapeImpl;
 + }
 +
 + public static enum ShapeType {
 + OVAL_FILL, OVAL, LINE;
 + }
 +}
 +</sxh>
 +
 +=== Utilisation ===
 +
 +<sxh java;title:DemoFlyweight>
 +public class DemoFlyweight extends JFrame {
 +
 + private static final long serialVersionUID = -1350200437285282550L;
 + private final int WIDTH;
 + private final int HEIGHT;
 +
 + private static final ShapeType shapes[] = { ShapeType.LINE, ShapeType.OVAL_FILL, ShapeType.OVAL };
 + private static final Color colors[] = { Color.RED, Color.GREEN, Color.YELLOW };
 +
 + public DemoFlyweight(int width, int height) {
 + this.WIDTH = width;
 + this.HEIGHT = height;
 + Container contentPane = getContentPane();
 +
 + JButton startButton = new JButton("Draw");
 + final JPanel panel = new JPanel();
 +
 + contentPane.add(panel, BorderLayout.CENTER);
 + contentPane.add(startButton, BorderLayout.SOUTH);
 + setSize(WIDTH, HEIGHT);
 + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 + setVisible(true);
 +
 + startButton.addActionListener(new ActionListener() {
 + public void actionPerformed(ActionEvent event) {
 + Graphics g = panel.getGraphics();
 + for (int i = 0; i < 40; ++i) {
 + Shape shape = ShapeFactory.getShape(getRandomShape());
 + shape.draw(g, getRandomX(), getRandomY(), getRandomWidth(), getRandomHeight(), getRandomColor());
 + }
 + }
 + });
 + }
 +
 + private ShapeType getRandomShape() {
 + return shapes[(int) (Math.random() * shapes.length)];
 + }
 +
 + private int getRandomX() {
 + return (int) (Math.random() * WIDTH);
 + }
 +
 + private int getRandomY() {
 + return (int) (Math.random() * HEIGHT);
 + }
 +
 + private int getRandomWidth() {
 + return (int) (Math.random() * (WIDTH / 10));
 + }
 +
 + private int getRandomHeight() {
 + return (int) (Math.random() * (HEIGHT / 10));
 + }
 +
 + private Color getRandomColor() {
 + return colors[(int) (Math.random() * colors.length)];
 + }
 +
 + public static void main(String[] args) {
 + new DemoFlyweight(500, 600);
 + }
 +}
 +</sxh>
 +
 +
 +
 +
 +===== MVC 2 =====
 +
 +MVC2 est un patron de conception dont la volonté est de séparer les données, les traitements et la présentation.
 +MVC2 permet de segmenter une application en trois composants essentiels :\\
 +  * Le modèle
 +  * Le contrôleur
 +  * Les vues
 +
 +MVC2 est une variante de MVC, dans laquelle le contrôleur est unique (contrairement à MVC où le rôle du contrôleur est assuré par plusieurs éléments).
 +
 +Nombre de frameworks permettent une implémentation de MVC ou MVC2 facilitée.
 +
 +==== Le Modèle ====
 +Le modèle correspond aux classes et objets métiers. Le modèle est responsable de la gestion de ces données, et en assure l'intégrité.
 +Il ne doit faire aucune référence aux vues, pas plus qu'au contrôleur.
 +==== Le contrôleur ====
 +
 +Le contrôleur synchronise (via évènements) les vues et le modèle. Il est responsable de la logique applicative. Le contrôleur n'effectue aucun traitement, mais se contente de solliciter le modèle adéquat, ou d'afficher la vue correspondante.
 +==== Les vues ====
 +
 +Les vues correspondent à l'IHM, elles affichent les résultats fournis par le modèle, en réponse aux actions de l'utilisateur.
 +
 +Voir [[http://www.do-as-i-say.com/notes/2009/08/framework-symfony-explique-a-ma-maman-1/|MVC expliqué à mam]]
 +
 +===== Injection de dépendance (dependency injection)=====
 +
 +<html><div class="idea">
 +Problématique : Eviter une dépendance directe entre deux classes, en définissant dynamiquement la dépendance plutôt que statiquement.
 +</div></html>
 +
 +Une classe A dépend d'une autre classe B quand la classe A possède un attribut de type B, ou possède une méthode utilisant la classe B (type de paramètre, valeur de retour, variable locale, appel de méthode de la classe B).
 +
 +Pour mettre en œuvre l'injection de dépendance :
 +
 +Créer une interface I déclarant les méthodes de la classe B utilisées par la classe A ;
 +<sxh java>
 +public interface I{
 +    public void doSomething();
 +}
 +</sxh>
 +
 +Déclarer la classe B comme implémentation de cette interface I ;
 +
 +<sxh java>
 +public class B implements I{
 +    public void doSomething(){
 +        system.out.println("something done !");
 +}
 +</sxh>
 +
 +Remplacer toute référence à la classe B par des références à l'interface I ;
 +Si la classe A instancie des instances de B à son initialisation, alors remplacer l'instanciation par un passage d'une instance de l'interface I au(x) constructeur(s) de A ;
 +Si besoin, ajouter une méthode pour spécifier l'instance de l'interface I à utiliser.
 +
 +<sxh java>
 +public class A{
 +    private I injected;
 +    
 +    public A(I injected){
 +        this.injected=injected;
 +    }
 +}
 +</sxh>
 +
 +
 +===== Observer/observable=====
 +
 +[[slam4:poo:designpattern:observer|Le design pattern Obserser en java]]
 +
 +
 +===== Delayed Queue =====
 +
 +Permet de gérer une liste d'éléments en sortie FIFO avec délai.
 +  * [[https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/DelayQueue.html|java DelayQueue API]]
 +  * [[https://examples.javacodegeeks.com/core-java/util/concurrent/delayqueue/java-util-concurrent-delayqueue-example/|Code geeks example]]
 +
 +{{:slam4:poo:delayedqueue.png?800|}}
 +
 +===== Références =====
 +  * [[http://www.tutorialspoint.com/design_pattern/flyweight_pattern.htm|Design patterns (TutorialsPoint)]]
 +  * [[https://fr.wikibooks.org/wiki/Patrons_de_conception|Patrons de conception (wikiBooks)]]