JavaScript 设计模式 : What is a Concrete Factory?

Question

在阅读 this article 中的工厂时，我遇到了这两个术语 AbstractFactory 和 ConcreteFactory。

在阅读 StackOverflow 时，我发现了一些很好的答案(如 this SO question)，它们讨论了工厂和抽象工厂，但仍然不清楚什么是具体工厂。

所以，我想问:

1. 什么是混凝土工厂？
2. 它与抽象工厂有何不同？

编辑:在单独的问题 (Abstract Factory vs Concrete factory) 中提出问题 #2，以将这两个讨论分开。

---

我目前的理解(关于工厂):

• 在高层次上，我理解工厂是指一种方法，它返回一个全新的东西(可以是任何东西，一个对象，一个方法，根据我们的要求需要的任何东西)，我们称之为工厂。在这里，如果我错了，请纠正我。
• 工厂将对象创建与其余代码封装并分离。下面是一个例子来说明这一点:

// This function is a factory. When called, creates and returns a new object every time
function ourFactoryFn (firstName, lastName) {
    var a = {
        prop1:  firstName,
        prop2: lastName,
        prop3: firstName + ' ' + lastName + ' says Hello world!'
    }
    return a;
};

// Now, let's use our factory to produce new objects
// let's actually have an example to treat it like real life factories :P
var inputArr = [
    {firstName: 'Barack', lastName: 'Obama'},
    {firstName: 'Narendra', lastName: 'Modi'},
    {firstName: 'Mike', lastName: 'Tyson'},
    {firstName: 'Mahatma', lastName: 'Gandhi'},
    {firstName: 'Donald', lastName: 'Trump'},
    {firstName: 'Priyanka', lastName: 'Chopra'}
];
var outputArr = [];
inputArr.forEach(function (x) {
    var newObj = ourFactoryFn(x.firstName, x.lastName); // we used our factory
    console.dir(newObj); // print the freshly created object
    outputArr.push(newObj);
});

Answer 1

具体工厂是实现抽象工厂的类，可以被实例化。抽象工厂是定义工厂接口(interface)的非实例化类。例如(使用 Java 进行说明)，抽象工厂 (FooFactory) 类似于:

public class Foo {}

public interface FooFactory {
    public Foo createFoo() { /* ... */ }
}

因为这个FooFactory 是一个接口(interface)(是抽象的)，它不能被实例化。例如，以下将是无效的(并且无法编译):

FooFactory factory = new FooFactory();

具体工厂(在本例中称为 ConcreteFooFactory)是一个可实例化的类，它实现了 FooFactory 接口(interface):

public class ConcreteFooFactory implements FooFactory {

    @Override
    public Foo createFoo() { /* ... */ }
}

FooFactory factory = new ConcreteFooFactory();

所有这些都引出了一个问题:为什么要先创建一个抽象工厂，然后再创建一个具体工厂？原因是抽象工厂定义了工厂的接口(interface)(可以调用的方法)，而没有定义工厂的任何具体行为。这允许我们创建多个 FooFactory 实现(具体类)，每个都有不同的特定行为。依赖工厂的客户端可以依赖抽象工厂，同时它的行为可以根据传递给它的具体工厂而改变:

public class BlueFooFactory implements FooFactory {

    @Override
    public Foo createFoo() { /* ...create blue Foo... */ }
}

public class RedFooFactory implements FooFactory {

    @Override
    public Foo createFoo() { /* ...create red Foo... */ }
}

public class FooClient {

    private FooFactory factory;

    public FooClient(FooFactory factory) {
        this.factory = factory;
    }

    public void doSomething() {
        Foo someFoo = factory.createFoo();
        // ...do something with someFoo...
    }
}

// Option 1
FooClient client = new FooClient(new BlueFooFactory());

// Option 2
FooClient client = new FooClient(new RedFooFactory());

虽然这些示例是用 Java 完成的，但它们也可以用 Javascript 完成。参见 Object-oriented JavaScript: A Deep Dive into ES6 Classes获取更多信息。