python的策略模式+建造者模式结合

一、策略模式

from abc import ABC, abstractmethod

class abstract_base_strategy(ABC):
    @abstractmethod
    def do_execute(self):
        pass

class concrete_strategy_a(abstract_base_strategy):
    def __init__(self, param1, param2, param3):
        self.param1 = param1
        self.param2 = param2
        self.param3 = param3

    def do_execute(self):
        print(f"利用参数{self.param1} {self.param2} {self.param3}, 执行策略A")

class concrete_strategy_b(abstract_base_strategy):
    def __init__(self, param1, param2, param3):
        self.param1 = param1
        self.param2 = param2
        self.param3 = param3

    def do_execute(self):
        print(f"利用参数{self.param1} {self.param2} {self.param3}, 执行策略B")

class context:
    def __init__(self, strategy):
        self.strategy = strategy

    def set_strategy(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        self.strategy.do_execute()

if __name__ == "__main__":
    strategy_a = concrete_strategy_a("a1", "b1", "c1")
    context_a = context(strategy_a)
    context_a.execute_strategy()

    strategy_b = concrete_strategy_b("a2", "b2", "c2")
    context_b = context(strategy_b)
    context_b.execute_strategy()

二、建造者模式

'''
python实现建造者模式, 建造者模式通常包含这四个角色:
1、抽象建造者 (Builder)：定义构建产品的抽象接口，通常包含构建各部分的方法和返回产品的方法。
2、具体建造者 (ConcreteBuilder)：实现抽象建造者接口，负责实际创建产品的各个部件。
3、指挥者 (Director)：负责控制构建过程（决定如何调用建造者的方法来组装产品）。
4、产品 (Product)：被构建的复杂对象。
'''
from abc import ABC, abstractmethod

# 1. 产品：最终要构建的复杂对象
class Computer:
    def __init__(self):
        self.cpu = None
        self.memory = None
        self.storage = None

    def __str__(self):
        return f"Computer(cpu={self.cpu}, memory={self.memory}, storage={self.storage})"


# 2. 抽象建造者：定义构建步骤
class ComputerBuilder(ABC):
    @abstractmethod
    def build_cpu(self):
        pass

    @abstractmethod
    def build_memory(self):
        pass

    @abstractmethod
    def build_storage(self):
        pass

    @abstractmethod
    def get_computer(self) -> Computer:
        pass


# 3. 具体建造者：实现具体构建逻辑
class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer()

    def build_cpu(self):
        self.computer.cpu = "Intel i9"

    def build_memory(self):
        self.computer.memory = "32GB DDR5"

    def build_storage(self):
        self.computer.storage = "1TB NVMe SSD"

    def get_computer(self) -> Computer:
        return self.computer


class OfficeComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer()

    def build_cpu(self):
        self.computer.cpu = "Intel i5"

    def build_memory(self):
        self.computer.memory = "16GB DDR4"

    def build_storage(self):
        self.computer.storage = "512GB SSD"

    def get_computer(self) -> Computer:
        return self.computer


# 4. 指挥者：控制构建顺序
class Director:
    def __init__(self, builder: ComputerBuilder):
        self.builder = builder

    def construct_computer(self):
        self.builder.build_cpu()
        self.builder.build_memory()
        self.builder.build_storage()
        return self.builder.get_computer()


# 使用示例
if __name__ == "__main__":
    # 组装游戏电脑
    gaming_builder = GamingComputerBuilder()
    director = Director(gaming_builder)
    gaming_pc = director.construct_computer()
    print(gaming_pc)  # Computer(cpu=Intel i9, memory=32GB DDR5, storage=1TB NVMe SSD)

    # 组装办公电脑
    office_builder = OfficeComputerBuilder()
    director = Director(office_builder)
    office_pc = director.construct_computer()
    print(office_pc)  # Computer(cpu=Intel i5, memory=16GB DDR4, storage=512GB SSD)

三、策略模式+建造者模式

'''
运行结果是：
执行策略，使用建造者类型: type_a
接收到的参数: {'param1': 'high_performance', 'param2': 'large_memory', 'param3': 'fast_storage'}
构建完成的产品: Product(feature1=构建A的feature1 with high_performance, feature2=构建A的feature2 with large_memory, feature3=构建A的feature3 with fast_storage, special=None)    

执行策略，使用建造者类型: type_c
接收到的参数: {'param1': 'standard_spec', 'param2': '8GB', 'param3': '256GB', 'special': 'RGB_lights'}
构建完成的产品: Product(feature1=构建C的增强版feature1 with standard_spec, feature2=构建C的增强版feature2 with 8GB, feature3=构建C的增强版feature3 with 256GB, special=特殊功能 with RGB_lights)

==================================================
动态切换示例

执行策略，使用建造者类型: type_b
接收到的参数: {'param1': 'advanced_cpu', 'param2': 'advanced_memory', 'param3': 'advanced_storage'}
构建完成的产品: Product(feature1=构建B的feature1 with advanced_cpu, feature2=构建B的feature2 with advanced_memory, feature3=构建B的feature3 with advanced_storage, special=None)
'''
from abc import ABC, abstractmethod
from typing import Dict, Any

# ========== 建造者模式部分 ==========
# 1. 产品：最终要构建的复杂对象
class Product:
    def __init__(self):
        self.feature1 = None
        self.feature2 = None
        self.feature3 = None
        self.special_feature = None
    
    def __str__(self):
        return f"Product(feature1={self.feature1}, feature2={self.feature2}, feature3={self.feature3}, special={self.special_feature})"


# 2. 抽象建造者
class ProductBuilder(ABC):
    @abstractmethod
    def build_feature1(self, param):
        pass
    
    @abstractmethod
    def build_feature2(self, param):
        pass
    
    @abstractmethod
    def build_feature3(self, param):
        pass
    
    @abstractmethod
    def get_product(self) -> Product:
        pass


# 3. 具体建造者A：用于构建类型A的产品
class ConcreteBuilderA(ProductBuilder):
    def __init__(self):
        self.product = Product()
    
    def build_feature1(self, param):
        self.product.feature1 = f"构建A的feature1 with {param}"
    
    def build_feature2(self, param):
        self.product.feature2 = f"构建A的feature2 with {param}"
    
    def build_feature3(self, param):
        self.product.feature3 = f"构建A的feature3 with {param}"
    
    def get_product(self) -> Product:
        return self.product


# 具体建造者B：用于构建类型B的产品
class ConcreteBuilderB(ProductBuilder):
    def __init__(self):
        self.product = Product()
    
    def build_feature1(self, param):
        self.product.feature1 = f"构建B的feature1 with {param}"
    
    def build_feature2(self, param):
        self.product.feature2 = f"构建B的feature2 with {param}"
    
    def build_feature3(self, param):
        self.product.feature3 = f"构建B的feature3 with {param}"
    
    def get_product(self) -> Product:
        return self.product


# 具体建造者C：用于构建类型C的产品（有特殊功能）
class ConcreteBuilderC(ProductBuilder):
    def __init__(self):
        self.product = Product()
    
    def build_feature1(self, param):
        self.product.feature1 = f"构建C的增强版feature1 with {param}"
    
    def build_feature2(self, param):
        self.product.feature2 = f"构建C的增强版feature2 with {param}"
    
    def build_feature3(self, param):
        self.product.feature3 = f"构建C的增强版feature3 with {param}"
    
    def build_special_feature(self, param):
        self.product.special_feature = f"特殊功能 with {param}"
    
    def get_product(self) -> Product:
        return self.product


# 4. 指挥者：控制构建顺序
class Director:
    def __init__(self, builder: ProductBuilder):
        self.builder = builder
    
    def construct_product(self, params: Dict[str, Any]):
        """根据参数构建产品"""
        self.builder.build_feature1(params.get('param1', 'default1'))
        self.builder.build_feature2(params.get('param2', 'default2'))
        self.builder.build_feature3(params.get('param3', 'default3'))
        
        # 如果是特殊建造者，可以调用额外的方法
        if hasattr(self.builder, 'build_special_feature'):
            self.builder.build_special_feature(params.get('special', 'special_default'))
        
        return self.builder.get_product()


# ========== 策略模式部分 ==========
class AbstractBaseStrategy(ABC):
    @abstractmethod
    def do_execute(self, params: Dict[str, Any]):
        pass


class ConcreteStrategyWithBuilder(AbstractBaseStrategy):
    """这个策略内部使用建造者模式"""
    
    def __init__(self, builder_type: str):
        """
        builder_type: 决定使用哪种具体建造者
        """
        self.builder_type = builder_type
    
    def _create_builder(self) -> ProductBuilder:
        """根据参数创建对应的建造者"""
        if self.builder_type == "type_a":
            return ConcreteBuilderA()
        elif self.builder_type == "type_b":
            return ConcreteBuilderB()
        elif self.builder_type == "type_c":
            return ConcreteBuilderC()
        else:
            raise ValueError(f"Unknown builder type: {self.builder_type}")
    
    def do_execute(self, params: Dict[str, Any]):
        print(f"\n执行策略，使用建造者类型: {self.builder_type}")
        print(f"接收到的参数: {params}")
        
        # 创建建造者
        builder = self._create_builder()
        
        # 创建指挥者
        director = Director(builder)
        
        # 构建产品
        product = director.construct_product(params)
        
        print(f"构建完成的产品: {product}")
        return product


class AnotherSimpleStrategy(AbstractBaseStrategy):
    """另一个简单的策略，不使用建造者"""
    
    def do_execute(self, params: Dict[str, Any]):
        print(f"\n执行简单策略，参数: {params}")
        print("直接处理逻辑，不构建复杂产品")
        return {"result": "simple_operation"}


# ========== 上下文类 ==========
class Context:
    def __init__(self, strategy: AbstractBaseStrategy):
        self.strategy = strategy
    
    def set_strategy(self, strategy: AbstractBaseStrategy):
        self.strategy = strategy
    
    def execute_strategy(self, params: Dict[str, Any]):
        return self.strategy.do_execute(params)


# ========== 使用示例 ==========
if __name__ == "__main__":
    # 场景1：根据条件1选择策略A（内部使用建造者A）
    condition = "gaming"
    if condition == "gaming":
        # 选择策略，并指定内部使用哪种建造者
        strategy = ConcreteStrategyWithBuilder(builder_type="type_a")
    else:
        strategy = AnotherSimpleStrategy()
    
    context = Context(strategy)
    result1 = context.execute_strategy({
        'param1': 'high_performance',
        'param2': 'large_memory',
        'param3': 'fast_storage'
    })
    
    # 场景2：根据不同的条件，选择相同的策略类型但不同的建造者
    product_type = "premium"
    if product_type == "premium":
        strategy = ConcreteStrategyWithBuilder(builder_type="type_c")  # 使用高级建造者
    elif product_type == "standard":
        strategy = ConcreteStrategyWithBuilder(builder_type="type_b")
    else:
        strategy = ConcreteStrategyWithBuilder(builder_type="type_a")
    
    context.set_strategy(strategy)
    result2 = context.execute_strategy({
        'param1': 'standard_spec',
        'param2': '8GB',
        'param3': '256GB',
        'special': 'RGB_lights'  # 特殊参数会被C类型建造者使用
    })
    
    # 场景3：动态切换策略和建造者
    print("\n" + "="*50)
    print("动态切换示例")
    
    # 根据不同的用户选择，创建不同的策略（内部使用不同的建造者）
    strategies_map = {
        "basic": ConcreteStrategyWithBuilder("type_a"),
        "advanced": ConcreteStrategyWithBuilder("type_b"),
        "premium": ConcreteStrategyWithBuilder("type_c")
    }
    
    user_level = "advanced"
    context.set_strategy(strategies_map[user_level])
    result3 = context.execute_strategy({
        'param1': f'{user_level}_cpu',
        'param2': f'{user_level}_memory',
        'param3': f'{user_level}_storage'
    })