深度OOP组合结构中合理传递数据的设计模式探讨

针对深层组合类结构中重复传递参数的问题，以下是几个符合Python场景、能精准控制参数传递且避免全局变量的实用方案：

1. 配置对象模式（Config Object） #

将分散的参数封装为专门的配置类，按组件需求拆分或组合配置对象，让组件仅接收自己需要的配置，避免重复传递多个零散参数。

示例实现： #

from typing import Literal

# 按职责拆分配置类
class MediaConfig:
    def __init__(self, mediatype: Literal['video', 'image']):
        self.mediatype = mediatype

class ChannelConfig:
    def __init__(self, channel: Literal['online', 'offline']):
        self.channel = channel

# 上层组件可按需传递组合/单独配置
class UploaderExecutor:
    def __init__(self, media_config: MediaConfig, channel_config: ChannelConfig, ...):
        self.uploader = Uploader(media_config, channel_config, ...)
        self.validator = Validator(media_config, channel_config, ...)
        # Reporter仅需MediaConfig，精准传递
        self.reporter = Reporter(media_config, ...)

class Uploader:
    def __init__(self, media_config: MediaConfig, channel_config: ChannelConfig, ...):
        self.configurator = Configurator(media_config, channel_config)
        self.file_parser = FileParser(media_config, channel_config)

class NameValidator:
    # 仅接收需要的ChannelConfig，避免无关参数
    def __init__(self, channel_config: ChannelConfig):
        self.channel = channel_config.channel

优点：参数结构清晰，可精准控制每个组件的参数范围，修改参数时只需调整配置类，无需修改所有组件的初始化方法。

2. 手动依赖注入（Dependency Injection） #

将组件的子依赖提前初始化完成，再注入到父组件中，而非让父组件自行创建子组件。这种方式彻底解耦组件的创建逻辑，避免重复传递初始化参数。

示例实现： #

class UploaderExecutor:
    def __init__(self, mediatype, channel, ...):
        # 提前创建所有子依赖
        media_config = MediaConfig(mediatype)
        channel_config = ChannelConfig(channel)
        
        configurator = Configurator(media_config, channel_config)
        file_parser = FileParser(media_config, channel_config)
        uploader = Uploader(configurator, file_parser)
        
        file_validator = FileValidator(media_config, channel_config)
        name_validator = NameValidator(channel_config)
        validator = Validator(file_validator, name_validator)
        
        self.uploader = uploader
        self.validator = validator
        ...

class Uploader:
    # 直接接收已初始化的子依赖，无需关心参数来源
    def __init__(self, configurator: Configurator, file_parser: FileParser):
        self.configurator = configurator
        self.file_parser = file_parser

优点：组件职责单一（仅负责业务逻辑，不负责子组件创建），参数传递完全可控，便于单元测试（可替换模拟依赖）。若依赖关系复杂，还可封装简单DI容器集中管理依赖创建。

3. 上下文对象模式（Context Object） #

创建包含全局运行上下文的对象，通过受控接口让组件访问所需参数。与配置对象不同，上下文可包含运行时状态，且能通过接口限制参数访问范围。

示例实现： #

class UploadContext:
    def __init__(self, mediatype, channel, ...):
        self._mediatype = mediatype
        self._channel = channel
    
    # 仅暴露组件需要的访问接口
    @property
    def mediatype(self):
        return self._mediatype
    
    @property
    def channel(self):
        return self._channel

class Uploader:
    def __init__(self, context: UploadContext):
        self.configurator = Configurator(context)
        self.file_parser = FileParser(context)

class NameValidator:
    def __init__(self, context: UploadContext):
        # 仅使用需要的channel参数
        self.channel = context.channel

优点：适合需要共享运行时状态的场景，通过接口控制参数访问，避免组件获取无关数据。

4. 工厂模式（Factory Pattern） #

创建专门的工厂类，集中处理所有组件的初始化逻辑，上层类只需调用工厂方法获取实例，无需手动传递参数。

示例实现： #

class ComponentFactory:
    @staticmethod
    def create_uploader(mediatype, channel):
        configurator = Configurator(mediatype, channel)
        file_parser = FileParser(mediatype, channel)
        return Uploader(configurator, file_parser)
    
    @staticmethod
    def create_validator(mediatype, channel):
        file_validator = FileValidator(mediatype, channel)
        name_validator = NameValidator(channel)
        return Validator(file_validator, name_validator)

class UploaderExecutor:
    def __init__(self, mediatype, channel, ...):
        self.uploader = ComponentFactory.create_uploader(mediatype, channel)
        self.validator = ComponentFactory.create_validator(mediatype, channel)
        self.reporter = ComponentFactory.create_reporter(mediatype)

优点：将组件初始化的冗余逻辑集中到工厂，上层代码更简洁，修改组件依赖时只需调整工厂方法，无需修改所有调用处。

内容的提问来源于stack exchange，提问作者Fernando Jesus Garcia Hipola