[PYTHON] Modèle de conception #Builder

J'ai pratiqué les modèles de conception afin de pouvoir écrire du code conscient du design. D'autres modèles de conception seront publiés fréquemment.

Préface

• Introduction aux modèles de conception appris en langage Java est passé de Java à Python. (Python est 3.4.2)
• Le code est sur github (certains ne fonctionnent toujours pas)

L'objectif principal est de comprendre quand, quoi et comment utiliser les modèles de conception. (Je suis nouveau en Java ou dans un langage à typage statique, et je n'ai pas une longue histoire de python, donc je pense qu'il y a des choses qui ne ressemblent pas à Pythonista. Si vous avez des suggestions, apprenez-moi s'il vous plaît.)

Cette fois, le générateur de modèles pour la génération.

Qu'est-ce que Builder

Lorsque la procédure de création d'objet est compliquée, le processus de création est encapsulé et une instance avec une structure est assemblée. De plus, en préparant divers constructeurs de motifs, il est possible de gérer la production de divers motifs, et même des combinaisons de méthodes compliquées peuvent être exécutées collectivement.

Aperçu

À titre d'exemple, créez un programme qui crée du «texte» à l'aide du modèle Builder. Le texte créé ici a la structure suivante.

• Comprend un titre
• Contient quelques chaînes
• Comprend certains éléments à puces

La classe Builder définit des méthodes de construction de documents. La classe Director utilise ensuite cette méthode pour créer un document concret,

La classe Builder est une classe abstraite et le traitement réel n'est pas écrit. Seules les méthodes abstraites sont déclarées. C'est la sous-classe de la classe Builder qui détermine le traitement spécifique pour l'écriture.

• Classe TextBuilder ・ ・ ・ Créer un document en texte brut (chaîne de caractères ordinaire)
• Classe HTMLBuilder ・ ・ ・ Créer un document en utilisant HTML

Director peut utiliser TextBuilder pour créer des documents en texte brut et HTMLBuilder peut être utilisé pour créer des documents HTML.

Diagramme de classe global

builder.py

from abc import ABCMeta, abstractmethod


class Builder(metaclass=ABCMeta):

    @abstractmethod
    def make_title(self, title):
        pass

    @abstractmethod
    def make_string(self, string):
        pass

    @abstractmethod
    def make_items(self, items):
        pass

    @abstractmethod
    def close(self):
        pass

La classe Builder est une classe abstraite qui déclare les méthodes qui créent des "documents". make_title, make_string et make_items sont des méthodes pour construire respectivement des titres, des chaînes et des puces dans des phrases. La méthode close est la méthode qui complète le document.

director.py

class Director():

    def __init__(self, builder):
        self.__builder = builder

    def construct(self):
        self.__builder.make_title('Greeting')
        self.__builder.make_string('Du matin à midi')
        string = ['Bonjour.', 'Bonjour.']
        self.__builder.make_items(string)
        self.__builder.make_string('La nuit')
        string = ['Bonsoir.', 'bonne nuit.', 'Au revoir.']
        self.__builder.make_items(string)
        self.__builder.close()

Dans la classe Director, le document est créé à l'aide des méthodes déclarées dans la classe Builder.

L'argument du constructeur de classe Director est un type de sous-classe (classe TextBuilder ou HTMLBuilder) de la classe Builder. La classe Builder est une classe abstraite, vous ne pouvez donc pas créer d'instance. Le type de sous-classe de la classe Builder donnée détermine le format de document spécifique créé par la classe Director.

La méthode construct est une méthode de création d'un document. L'appel de cette méthode génère le document. La méthode construct utilise la méthode déclarée dans Builder.

text_builder.py

from builder import Builder


class TextBuilder(Builder):
    __buffer = []

    def make_title(self, title):
        self.__buffer.append('=' * 20)
        self.__buffer.append('[' + title + ']\n')
        self.__buffer.append('\n')

    def make_string(self, string):
        self.__buffer.append('■' + string + '\n')
        self.__buffer.append('\n')

    def make_items(self, items):
        for i in range(0, len(items)):
            self.__buffer.append('●' + items[i] + '\n')
        self.__buffer.append('\n')

    def close(self):
        self.__buffer.append('=' * 20)

    def get_result(self):
        for buffer in self.__buffer:
            print(buffer)

La classe TextBuilder est une sous-classe de la classe Builder. Créez votre document en utilisant du texte brut. Le résultat est renvoyé sous forme de chaîne.

html_builder.py

import logging
from builder import Builder


class HTMLBuilder(Builder):

    def make_title(self, title):
        self.__filename = title + '.html'

        try:
            self.__writer = open(self.__filename, mode='w')
        except IOError as e:
            logging.exception(e)

        self.__writer.write('<!DOCTYPE html><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>' + title + '</title></head><body>')
        self.__writer.write('<h1>' + title + '<h1>')

    def make_string(self, string):
        self.__writer.write('<h1>' + string + '</p>')

    def make_items(self, items):
        self.__writer.write('<ul>')
        for i in range(0, len(items)):
            self.__writer.write('<li>' + items[i] + '</li>')
        self.__writer.write('</ul>')

    def close(self):
        self.__writer.write('</body></html>')
        self.__writer.close()

    def get_result(self):
        return self.__filename

La classe HTMLBuilder est également une sous-classe de la classe Builder. La classe HTMLBuilder crée le document sous forme de fichier HTML. Le résultat construit est renvoyé comme nom de fichier du fichier HTML.

main.py

import sys
from text_builder import TextBuilder
from html_builder import HTMLBuilder
from director import Director


def usage():
    print('Usage: Python main plain')
    print('Usage: Python main html')


def main():
    if len(sys.argv) != 2:
        usage()
        sys.exit()

    if sys.argv[1] == 'plain':
        text_builder = TextBuilder()
        director = Director(text_builder)
        director.construct()
        result = text_builder.get_result()
        print(result)
    elif sys.argv[1] == 'html':
        html_builder = HTMLBuilder()
        director = Director(html_builder)
        director.construct()
        filename = html_builder.get_result()
        print(filename + 'A été créé.')
    else:
        usage()
        sys.exit()


if __name__ == "__main__":
    main()

Le fichier principal est un programme de test pour le modèle Builder. Créez un document selon le format spécifié sur la ligne de commande comme indiqué ci-dessous.

python main.py plain ・ ・ ・ Créer un document avec du texte brut python main.py html ・ ・ ・ Création de documents avec fichier HTML

Si vous spécifiez ** plain ** sur la ligne de commande, vous transmettez une instance de la classe TextBuilder au constructeur de classe Director. De plus, si ** html ** est spécifié sur la ligne de commande, une instance de la classe HTMLBuilder est transmise au constructeur de la classe Director.

TextBuilder et HTMLBuilder sont des sous-classes de Builder et Director n'utilise que des méthodes Builder pour créer des documents. Utiliser uniquement les méthodes Builder signifie que ** Director ne sait pas si TextBuilder ou HTMLBuilder est réellement en cours d'exécution **.

Par conséquent, le constructeur doit déclarer un ensemble de méthodes nécessaires et suffisantes pour atteindre l'objectif de construction du document. Cependant, Builder ne doit pas fournir de méthodes spécifiques au texte brut ou aux fichiers HTML.

Résultat d'exécution (clair)

====================
[Greeting]

■ Du matin à midi


● Bonjour.

● Bonjour.


■ La nuit


● Bonsoir.

● Bonne nuit.

● Au revoir.
====================

Résultat d'exécution (html)

`Greeting.html a été créé. ''

Résumé

Un modèle Builder spécialisé pour réduire le travail de création d'instance lorsque la procédure de création d'instance et le contenu sont compliqués.

En ce qui concerne la procédure, la différence entre le modèle de méthode modèle et le modèle Builder est de savoir qui est responsable de l'instanciation. Le modèle de méthode modèle détermine la procédure d'instanciation dans une superclasse. D'autre part, la classe Director (autres classes) est responsable de la procédure de génération du modèle Builder.

La clé du modèle Builder est de savoir qui sait comment créer une instance, c'est-à-dire la classe Director. Il est également important que les utilisateurs des directeurs aient besoin de savoir ce qu'est une instance créée par Builder.

Il semble que le modèle Builder entre en jeu lorsqu'il y a une procédure de création d'une instance, lorsque vous devez créer une instance à l'aide d'une ressource externe ou lorsque vous avez beaucoup d'arguments différents dans le constructeur.

référence

• Motif de conception inversé que même les singes peuvent comprendre
• Modèle de conception TECHSCORE
• Wikipedia Software design pattern
• Modèle de conception Wikipedia
• En apprenant avec Ruby 2.0.0, j'ai créé 14 modèles de conception [GoF] [Modèle de conception]
• 5 principes des modèles de conception par Ruby