TypeScript 中的工厂模式
1. 什么是工厂模式？
工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种封装对象创建逻辑的方法，而不是直接使用 new 关键字实例化对象。工厂模式可以提高代码的可维护性和可扩展性，特别适用于需要创建多个相似对象的场景。
2. 工厂模式的优点
- 封装对象创建逻辑，避免代码中到处使用
new关键字。 - 提高代码的可维护性，如果对象的创建逻辑发生变化，只需要修改工厂类即可。
- 符合开闭原则，可以方便地扩展新的产品类型，而不影响现有代码。
- 适用于复杂对象的创建，减少代码重复。
3. TypeScript 实现工厂模式
3.1 简单工厂模式
简单工厂模式通过一个工厂类来创建不同类型的对象。
// 定义产品接口
interface Product {
use(): void;
}
// 具体产品类A
class ConcreteProductA implements Product {
use(): void {
console.log("使用产品A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
use(): void {
console.log("使用产品B");
}
}
// 工厂类
class ProductFactory {
static createProduct(type: string): Product {
switch (type) {
case "A":
return new ConcreteProductA();
case "B":
return new ConcreteProductB();
default:
throw new Error("未知的产品类型");
}
}
}
// 使用工厂创建对象
const productA = ProductFactory.createProduct("A");
productA.use(); // 输出: 使用产品A
const productB = ProductFactory.createProduct("B");
productB.use(); // 输出: 使用产品B
3.2 工厂方法模式
工厂方法模式通过定义一个抽象工厂接口，让子类决定实例化哪种具体产品。
// 抽象产品接口
interface Product {
use(): void;
}
// 具体产品类A
class ConcreteProductA implements Product {
use(): void {
console.log("使用产品A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
use(): void {
console.log("使用产品B");
}
}
// 抽象工厂接口
interface ProductFactory {
createProduct(): Product;
}
// 具体工厂A
class ConcreteFactoryA implements ProductFactory {
createProduct(): Product {
return new ConcreteProductA();
}
}
// 具体工厂B
class ConcreteFactoryB implements ProductFactory {
createProduct(): Product {
return new ConcreteProductB();
}
}
// 使用工厂方法创建对象
const factoryA: ProductFactory = new ConcreteFactoryA();
const productA2 = factoryA.createProduct();
productA2.use(); // 输出: 使用产品A
const factoryB: ProductFactory = new ConcreteFactoryB();
const productB2 = factoryB.createProduct();
productB2.use(); // 输出: 使用产品B
3.3 抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）用于创建一系列相关或相互依赖的对象，而无需指定其具体类。
// 抽象产品接口
interface Button {
render(): void;
}
interface Checkbox {
check(): void;
}
// 具体产品A
class WindowsButton implements Button {
render(): void {
console.log("渲染 Windows 按钮");
}
}
class WindowsCheckbox implements Checkbox {
check(): void {
console.log("选中 Windows 复选框");
}
}
// 具体产品B
class MacButton implements Button {
render(): void {
console.log("渲染 Mac 按钮");
}
}
class MacCheckbox implements Checkbox {
check(): void {
console.log("选中 Mac 复选框");
}
}
// 抽象工厂接口
interface GUIFactory {
createButton(): Button;
createCheckbox(): Checkbox;
}
// 具体工厂A
class WindowsFactory implements GUIFactory {
createButton(): Button {
return new WindowsButton();
}
createCheckbox(): Checkbox {
return new WindowsCheckbox();
}
}
// 具体工厂B
class MacFactory implements GUIFactory {
createButton(): Button {
return new MacButton();
}
createCheckbox(): Checkbox {
return new MacCheckbox();
}
}
// 使用抽象工厂模式
function renderUI(factory: GUIFactory) {
const button = factory.createButton();
const checkbox = factory.createCheckbox();
button.render();
checkbox.check();
}
const windowsFactory = new WindowsFactory();
renderUI(windowsFactory);
// 输出: 渲染 Windows 按钮
// 选中 Windows 复选框
const macFactory = new MacFactory();
renderUI(macFactory);
// 输出: 渲染 Mac 按钮
// 选中 Mac 复选框
4. 总结
工厂模式是一种常见的创建型设计模式，适用于对象创建逻辑复杂、对象种类较多的情况。在 TypeScript 中，我们可以使用简单工厂模式、工厂方法模式或抽象工厂模式来封装对象创建逻辑，从而提高代码的可维护性和扩展性。
- 简单工厂模式：适用于对象类型较少、创建逻辑较简单的情况。
- 工厂方法模式：适用于对象类型较多，且需要扩展性较强的情况。
- 抽象工厂模式：适用于创建多个相关的对象族，以保证对象的一致性。
根据实际需求选择合适的工厂模式，可以有效提高代码的可读性、可维护性和可扩展性。
