JavaScript 设计模式：啥是具体工厂？

Posted 2023-02-17

【中文标题】JavaScript 设计模式：啥是具体工厂？

【英文标题】：JavaScript Design Patterns: What is a Concrete Factory?JavaScript 设计模式：什么是具体工厂？

【发布时间】：2019-05-15 11:16:50

【问题描述】：

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

在阅读 *** 时，我发现了一些关于工厂和抽象工厂的好答案（例如 this SO question），但仍然不清楚具体工厂是什么。

所以，我想问一下：

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

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

---

我目前的理解（关于工厂）：

在高层次上，我理解，工厂指的是返回全新

something

的方法（可以是任何东西、对象、方法、任何我们需要的东西），我们称之为工厂。在这里，如果我错了，请纠正我。 工厂封装对象创建并将其与其余代码分开。下面是一个例子来说明这一点：

// 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);
);

【问题讨论】：

我不明白为什么这被否决了......这个问题足够可靠并且格式很好......

【参考方案1】：

具体工厂是实现抽象工厂的类，可以实例化。抽象工厂是一个不可实例化的类，它定义了工厂的接口。例如（使用 Java 进行说明），抽象工厂 (FooFactory) 将类似于：

public class Foo 

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

因为这个FooFactory 是一个接口（是抽象的），所以它不能被实例化。例如，以下内容将无效（并且无法编译）：

FooFactory factory = new FooFactory();

具体工厂（在本例中称为ConcreteFooFactory）是实现FooFactory 接口的可实例化类：

public class ConcreteFooFactory implements FooFactory 

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


FooFactory factory = new ConcreteFooFactory();

所有这些都引出了一个问题：为什么要创建一个抽象工厂，然后再创建一个具体工厂？原因是抽象工厂定义了工厂的接口（可以调用的方法），而没有定义工厂的任何具体行为。这允许我们创建多个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 了解更多信息。