Python中多方式连接Service服务并委托方法执行的优化方案咨询

Great question! Your current code works, but we can absolutely make it cleaner, more maintainable, and elegant. Let’s walk through a few solid approaches to refactor this:

1. Replace Conditional Logic with a Dictionary Mapping #

You mentioned considering a dictionary mapping but thought it wasn’t "pretty"—but with a little structure, it becomes a clean, readable alternative to the if-elif chain. This is essentially a lightweight factory pattern:

import configparser
from MyApp.Exceptions import WrongModeException

class Service(object):
    cfg_file = 'path/to/cfg.ini'
    
    # Lazy-load config to avoid side effects at import time
    @classmethod
    def get_config(cls):
        if not hasattr(cls, '_config'):
            cls._config = configparser.ConfigParser()
            cls._config.read(cls.cfg_file)
        return cls._config

    @staticmethod
    def generate_password():
        return 'ToPsEcReTp4ssw0rD'

class ServiceAPI(Service):
    def __init__(self):
        self.connection = APIConnect(self.get_config().some_param)

    def do_stuff(self, a):
        self.connection.do_stuff(a=a)

class ServiceMessageBroker(Service):
    def __init__(self):
        self.connection = MessageBrokerConnect(self.get_config().some_param)

    def do_stuff(self, a):
        self.connection.do_stuff(a=a)

class ServiceWrapper(Service):
    # Map mode strings directly to their corresponding service classes
    _SERVICE_CLASSES = {
        'Message Broker': ServiceMessageBroker,
        'API': ServiceAPI
    }

    def __init__(self):
        mode = self.get_config().get(option='mode')
        try:
            self.service = self._SERVICE_CLASSES[mode]()
        except KeyError:
            raise WrongModeException(f"Unsupported mode: {mode}") from None

    def do_stuff(self, **kwargs):
        self.service.do_stuff(**kwargs)

Why this works:

• No more messy if-elif checks—adding a new service type only requires adding one line to the _SERVICE_CLASSES dictionary.
• Exception handling is cleaner: we explicitly catch invalid modes and raise a meaningful error (no need for os.sys.exit(1) here—let the caller handle the exception instead of forcing an exit from within the class).
• We also refactored the config loading to be lazy, which avoids reading the config file at import time (a common source of unexpected side effects).

2. Extract Factory Logic to a Separate Component #

For even better separation of concerns, you can pull the service creation logic out of the ServiceWrapper into a dedicated factory function. This keeps the wrapper focused on proxying calls, while the factory handles instantiation:

def create_service(mode):
    service_map = {
        'Message Broker': ServiceMessageBroker,
        'API': ServiceAPI
    }
    try:
        return service_map[mode]()
    except KeyError:
        raise WrongModeException(f"Unsupported mode: {mode}") from None

class ServiceWrapper(Service):
    def __init__(self):
        mode = self.get_config().get(option='mode')
        self.service = create_service(mode)

    def do_stuff(self, **kwargs):
        self.service.do_stuff(**kwargs)

Why this works:

• Follows the single responsibility principle: the wrapper doesn’t need to know how to create service instances, just how to use them.
• The factory function is reusable—you can call it elsewhere in your code if you need to create a service directly without the wrapper.

3. Enforce Interface Consistency with Abstract Base Classes #

To make sure all your service classes implement the required methods (like do_stuff), use Python’s abc module to define an abstract base class. This prevents accidental bugs if you add a new service type and forget to implement the required methods:

from abc import ABC, abstractmethod

class BaseService(ABC):
    @abstractmethod
    def do_stuff(self, a):
        """Abstract method that all services must implement."""
        pass

class ServiceAPI(BaseService, Service):
    def __init__(self):
        self.connection = APIConnect(self.get_config().some_param)

    def do_stuff(self, a):
        self.connection.do_stuff(a=a)

class ServiceMessageBroker(BaseService, Service):
    def __init__(self):
        self.connection = MessageBrokerConnect(self.get_config().some_param)

    def do_stuff(self, a):
        self.connection.do_stuff(a=a)

Why this works:

• If you try to create a service class that inherits from BaseService but doesn’t implement do_stuff, Python will throw an error when you try to instantiate it—catching mistakes early.
• Makes your code’s intent clearer: anyone reading the code knows exactly what methods a service class must have.

Final Notes #

All these approaches are better than the original conditional logic, but the dictionary mapping is my favorite for simple cases like this—it’s concise, easy to extend, and keeps the code readable.

内容的提问来源于stack exchange，提问作者Mateusz Korycinski