Question

如果实现效果必须依赖于调用代码中的某些参数，那么如何将接口实现与调用代码分离？

这可能听起来很复杂，所以这是一个现实生活中的例子：

一些网上商店销售不同品牌的产品;
处理用户购买时，我们需要根据所购产品的品牌向不同的存储区提交数据;
所有这些存储都可以通过相同接口的相同实现访问，但可以通过不同的底层连接访问。

遵循IoC原则，我们应该有一个存储接口实现的实例，以便在不知道其内部结构的情况下处理代码。但是，必须根据产品将数据发送到不同的服务器。品牌，这意味着我们必须以某种方式影响该实施。

如果我们将任何数据（品牌数据或存储库连接配置）传递到存储库，我们要么将存储库接口与品牌实体耦合，要么将处理代码订购到存储库实现细节。

那么如何按照IoC原则实现这种情况呢？其他脱钩模式的建议也很受欢迎。

Answer 1

我得出结论，在这种情况下代码不能完全解耦。通过定义手头的任务，业务逻辑和存储库实现之间存在耦合。

但是，为了简化进一步的代码维护，我最终使用了以下架构（伪代码）：

核心接口：

// Main repository interface
interface OrdersRepositoryInterface {
    store(order: Order): bool;

    // …other methods
}

// An interface of a factory that will be used to create repository instances with different configurations (different underlying storages, for example)
interface OrdersRepositoryFactoryInterface {
    createRepository(configuration: OrdersRepositoryConfigurationInterface): OrdersRepositoryInterface;
}

// An interface of a container that will create different instances of repositories based on specified brand
// An implementation of this interface is the coupling point between business logic and data persistence logic
interface OrdersRepositoryContainerInterface {
    get(brand: Brand): OrdersRepositoryInterface;
}

存储库工厂实现（紧密耦合到存储库本身，如果在接口本身中指定了存储库构造函数，则可以避免，但我个人认为这是不好的做法）：

class OrdersRepositoryImplementation implements OrdersRepositoryInterface {
    constructor(configuration: OrdersRepositoryConfigurationInterface) {
        // …
    }

    store(order: Order): bool {
        // …
    }
}

class OrdersRepositoryFactory implements OrdersRepositoryFactoryInterface {
    createRepository(configuration: OrdersRepositoryConfigurationInterface): OrdersRepositoryInterface {
        return new OrdersRepositoryImplementation(configuration);
    }
}

存储库容器实现：

class OrdersRepositoryContainer implements OrdersRepositoryContainerInterface {
    get(brand: Brand): OrdersRepositoryInterface {
        var factory = IoC.resolve(OrdersRepositoryFactoryInterface);

        var configuration1 = …;
        var configuration2 = …;

        if (brand.slug === "brand1") {
            return factory.createRepository(configuration1);
        } else {
            return factory.createRepository(configuration2);
        }
    }
}

IoC-container绑定（如果容器支持它，它可能更好地绑定类而不是实例，因为自动依赖注入可以在这些实现的构造函数中使用）：

IoC.bindInstance(OrdersRepositoryFactoryInterface, new OrdersRepositoryFactory());
IoC.bindInstance(OrdersRepositoryContainerInterface, new OrdersRepositoryContainer());

最后，但并非最不重要的，订单处理代码：

var order = …;

var repositoryContainer = IoC.resolve(OrdersRepositoryContainerInterface);

var repository = repositoryContainer.get(order.brand);

repository.store(order);

此体系结构将允许轻松替换存储库解析逻辑。例如，将来可以统一所有品牌的存储库，在这种情况下，只需要替换OrderRepositoryContainerInterface实现。但是，OrdersRepositoryContainer仍然与存储库的实现相结合，因为它必须知道如何以及在何处获得它们的配置。

我会将此答案标记为已接受，但如果有人提出更好的建议，我会乐意改变这一点。

如何在实施细节依赖于调用代码

1 个答案: