如何维护具有多个依赖项的 SRP（单一职责原则）？

Question

我对一个类必须依赖于其他因素的情况感到困惑。

例如

class Storage:
    def __init__(self):
        self.logger = Logger()
        self.client = Elasticsearch()

    def index(document):
        try:
            self.client.index(document)
         except ElasticsearchException as e:
             self.logger.error(str(e))

我的班级必须有记录器和Elasticsearch 对象才能执行其操作。在这种情况下，我如何维护 SRP，可能有两种情况需要更改我的类，例如：

1. 我切换到不同的数据库
2. 我切换到不同的日志库

有人可能会争辩说，我应该让客户端类处理异常，而不是在这里记录。但是在客户端只是yielding要插入的文档并且可以接受索引操作失败的情况下，客户端类不会担心错误。此外，即使我将异常重新抛出到客户端类，那里也会出现同样的 SRP 问题。

我希望能在我的上下文中给出解释性答案。

Answer 1

我认为部分问题出在标题中：“.. 具有多个依赖项”。您的依赖项是高度耦合的，因为在您的 Storage 类中实例化。 这就是为什么我会使用依赖注入（我有 0 的 python 知识，可能是一些错字）：

interface StorageClientInterface:
    def index(document)    

interface LoggerInterface:
    def error(Exception e) 

class ElasticSearchStorage implements storageClientInterface:
    def index(document):
        // implements ElasticSearch specific storage logic

class MyDefaultLogger implements LoggerInterface:
    def error(Exception e):
        // implements MyDefaultLogger specific logging logic, totally agnostic from ElascticSearch

class Storage:
    def __init__(self, StorageClientInterface storageClient, LoggerInterface logger):        
        self.client = storageClient
        self.logger = logger

    def index(document):
        try:
            self.client.index(document)
         except Exception as e:
             self.logger.error(e)


// usage
elasticSearch = ElasticSearch()
logger = MyDefaultLogger()
document = Document();
storage = Storage(elasticSearch, logger)    
storage.index(document)

这样，您的 Storage 类不会与您的存储策略或日志记录策略耦合。它只知道它可以使用这两个接口。如果您更改数据库，则不必更改 Storage 类中的任何内容，只要此新存储策略实现您的 StorageClientInterface。如果您更改记录错误的方式，也是如此。只需实例化一个新的具体 Logger，然后注入它。

Answer 2

您可以通过引入额外的层来为此功能定义抽象 API 来做到这一点：一个用于数据库，另一个用于记录日志。完成此操作后，您的 Storage 类必须仅限于使用它们，而不是直接调用或由特定库或模块公开的任何“真实”方法。

这样他们（以及他们的客户，比如重写的Storage 类）就不需要更改，除非由于某种原因必须更改其中一个抽象接口（如果设计得好，这将不是必需的）。这两个抽象接口中的任何一个的任何具体实现都只有一个职责（即通过某些特定日志记录或数据库库中可用的东西来模拟抽象 API）。

Answer 3

实现此目的的一种方法是使用decorator 模式。装饰器模式将允许您将所有错误处理逻辑封装在一个单独的类中，然后可以使用该类从本质上包装装饰类的行为，在这种情况下，它就是您的 Storage 类。我不是很了解 Python，所以请原谅任何语法错误，但它看起来像这样：

class Storage:
    def __init__(self, storageClient):        
        self.client = storageClient

    def index(document):
        self.client.index(document)


class ElasticSearchExceptionPolicy:
    def __init__(self, decorated, logger):
        self.logger = logger
        self.decorated = decorated

    def index(document):
        try:
            decorated.index(document)
        except ElasticsearchException as e:
            self.logger.error(str(e))

然后可以像这样使用这些对象：

elasticSearch = ElasticSearch()
logger = Logger()
storage = Storage(elasticSearch)    
loggedStorage = ElasticSearchExceptionPolicy(storage, logger)
loggedStorage.index(document)

如果您想遵循 Open/Closed 原则，您可能还希望将 ElasticSearch 对象和 Logger 对象传递到它们各自的类中。