Python: Builder Pattern

 DuBuilder.py

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133

# 生成器模式 Builder Pattern from __future__ import annotations from abc import ABC, abstractmethod from typing import Any     class Builder(ABC):     """     The Builder interface specifies methods for creating the different parts of     the Product objects.     """       @property     @abstractmethod     def product(self) -> None:         pass       @abstractmethod     def produce_part_a(self) -> None:         pass       @abstractmethod     def produce_part_b(self) -> None:         pass       @abstractmethod     def produce_part_c(self) -> None:         pass     class ConcreteBuilder1(Builder):     """     The Concrete Builder classes follow the Builder interface and provide     specific implementations of the building steps. Your program may have     several variations of Builders, implemented differently.     """       def __init__(self) -> None:         """         A fresh builder instance should contain a blank product object, which is         used in further assembly.         """         self.reset()       def reset(self) -> None:         self._product = Product1()       @property     def product(self) -> Product1:         """         Concrete Builders are supposed to provide their own methods for         retrieving results. That's because various types of builders may create         entirely different products that don't follow the same interface.         Therefore, such methods cannot be declared in the base Builder interface         (at least in a statically typed programming language).           Usually, after returning the end result to the client, a builder         instance is expected to be ready to start producing another product.         That's why it's a usual practice to call the reset method at the end of         the `getProduct` method body. However, this behavior is not mandatory,         and you can make your builders wait for an explicit reset call from the         client code before disposing of the previous result.         """         product = self._product         self.reset()         return product       def produce_part_a(self) -> None:         self._product.add("发动机")       def produce_part_b(self) -> None:         self._product.add("车架")       def produce_part_c(self) -> None:         self._product.add("车身")     class Product1():     """     It makes sense to use the Builder pattern only when your products are quite     complex and require extensive configuration.       Unlike in other creational patterns, different concrete builders can produce     unrelated products. In other words, results of various builders may not     always follow the same interface.     """       def __init__(self) -> None:         self.parts = []       def add(self, part: Any) -> None:         self.parts.append(part)       def list_parts(self) -> None:         print(f"产品部分为: {', '.join(self.parts)}", end="")     class Director:     """     The Director is only responsible for executing the building steps in a     particular sequence. It is helpful when producing products according to a     specific order or configuration. Strictly speaking, the Director class is     optional, since the client can control builders directly.     """       def __init__(self) -> None:         self._builder = None       @property     def builder(self) -> Builder:         return self._builder       @builder.setter     def builder(self, builder: Builder) -> None:         """         The Director works with any builder instance that the client code passes         to it. This way, the client code may alter the final type of the newly         assembled product.         """         self._builder = builder       """     The Director can construct several product variations using the same     building steps.     """       def build_minimal_viable_product(self) -> None:         self.builder.produce_part_a()       def build_full_featured_product(self) -> None:         self.builder.produce_part_a()         self.builder.produce_part_b()         self.builder.produce_part_c()

　　

main.py

调用：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

## 生成器模式 Builder Pattern  director = DuBuilder.Director()  builder = DuBuilder.ConcreteBuilder1()  director.builder = builder  print("\n")  print("生成器模式 Builder Pattern")    print("产品最基本的部分: ")  director.build_minimal_viable_product()  builder.product.list_parts()    print("\n")    print("标准的全功能产品: ")  director.build_full_featured_product()  builder.product.list_parts()    print("\n")    # Remember, the Builder pattern can be used without a Director class.  print("客户需要的产品部分: ")  builder.produce_part_a()  builder.produce_part_b()  builder.product.list_parts()

　　

输出：

?

1 2 3 4 5 6 7 8 9 10

生成器模式 Builder Pattern 产品最基本的部分: 产品部分为: 发动机   标准的全功能产品: 产品部分为: 发动机, 车架, 车身   客户需要的产品部分: 产品部分为: 发动机, 车架 Process finished with exit code 0