Question

我有A级必须接收工厂的BFactory。 BFactory创建了B的实现。每个实现类都需要注入不同的服务。

class B
{
};

class C : public B
{
public:
    C(shared_ptr<ServiceL> serviceL);
};

class D : public B
{
public:
    C(shared_ptr<ServiceM> serviceM);
};

我应该向BFactory注入其所有实现所需的所有服务，还是应该使用不同的设计？如果我将所有服务注入到BFactory，那么BFactory将看起来如下：

class BFactory
{
public:
    BFactory(shared_ptr<ServiceL> serviceL, shared_ptr<ServiceM> serviceM);

    shared_ptr<B> createInstance(Btype type);

private:
    shared_ptr<ServiceL> _serviceL; 
    shared_ptr<ServiceM> _serviceM
};

BFactory::BFactory(shared_ptr<ServiceL> serviceL, shared_ptr<ServiceM> serviceM) : _serviceL(serviceL), _serviceM(serviceM)
{
}

void BFactory::createInstance(Btype type)
{
    if (type == ...)
    {
        return shared_ptr<B>(new C(_serviceL));
    }
    else if (type == ...)
    {
        return shared_ptr<B>(new D(_serviceM));
    }
}

Answer 1

您演示的方法，即您将产品的依赖关系传递给工厂，是我使用的方法。事实上，这些通常是我注入工厂的唯一类型的依赖项。

工厂对象的唯一目的是按需创建产品。为了实现这一目的，工厂有责任确保产品在发布之前具有所需的依赖性。

工厂与其产品类型紧密相关。他们有，因为他们正在调用产品的构造函数。

这种紧密耦合的后果之一是工厂还加上其产品的依赖性。因此，产品的每个依赖关系也是工厂的依赖关系，应该像任何其他依赖关系一样注入工厂。

事实上，这就是我们在系统中的其他地方设计松散耦合的原因。通过紧密耦合，对象了解其依赖性的依赖性及其依赖性，令人作呕。通过使用工厂，我们能够控制这种复杂性，并防止其泄漏到系统的其他部分。

Answer 2

我会创建一个ServiceFactory并将其提供给BFactory。然后根据类型，BFactory可以请求ServiceFactory在BFactory::createInstance方法中创建适当的服务，该方法将用于创建B实例。

使用依赖注入设计工厂类

2 个答案: