常用设计模式：工厂方法模式

技术分享 4个月前 (11-12) 0 999+

关注

在软件开发中，对象创建是最基础也是最关键的操作之一。随着项目规模的增长，直接使用 new 关键字创建对象会导致代码高度耦合，难以维护和扩展。工厂方法模式正是为了解决这一问题而生的经典设计模式。

什么是工厂方法模式？

工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但让子类决定实例化哪个类。这种模式将对象的实例化推迟到子类，从而实现了创建逻辑与使用逻辑的分离。

核心概念解析

工厂方法模式包含以下几个关键角色：

产品接口（Product Interface）：定义了产品对象的通用接口
具体产品（Concrete Products）：实现产品接口的具体类
创建者（Creator）：声明工厂方法，返回产品对象
具体创建者（Concrete Creators）：重写工厂方法，返回具体产品实例

为什么使用工厂方法模式？

解决紧耦合问题

考虑以下紧耦合的代码：

class Car {   drive() {     console.log('Driving a car');   } }  class Truck {   drive() {     console.log('Driving a truck');   } }  // 客户端代码直接依赖具体类 const vehicle1 = new Car(); const vehicle1 = new Truck();

这种写法的问题在于，客户端代码直接依赖于具体类，一旦需要添加新的车辆类型或修改创建逻辑，就需要在所有使用的地方进行修改。

实现开闭原则

工厂方法模式帮助你的代码遵循开闭原则：对扩展开放，对修改关闭。你可以添加新的产品类型而无需修改现有代码。

工厂方法模式实现

让我们通过一个完整的示例来理解工厂方法模式。

第一步：定义产品接口

interface Vehicle {   drive(): void;   getInfo(): string; }

第二步：实现具体产品类

class Car implements Vehicle {   drive() {     console.log('Driving a car');   }      getInfo(): string {     return 'This is a car with 4 seats';   } }  class Truck implements Vehicle {   drive() {     console.log('Driving a truck');   }      getInfo(): string {     return 'This is a truck for heavy loads';   } }  class Motorcycle implements Vehicle {   drive() {     console.log('Riding a motorcycle');   }      getInfo(): string {     return 'This is a motorcycle with 2 wheels';   } }

第三步：创建抽象创建者类

abstract class VehicleFactory {   // 工厂方法   public abstract createVehicle(): Vehicle;      // 业务逻辑方法   public deliverVehicle(): string {     const vehicle = this.createVehicle();     vehicle.drive();     return vehicle.getInfo();   } }

第四步：实现具体创建者类

class CarFactory extends VehicleFactory {   public createVehicle(): Vehicle {     return new Car();   } }  class TruckFactory extends VehicleFactory {   public createVehicle(): Vehicle {     return new Truck();   } }  class MotorcycleFactory extends VehicleFactory {   public createVehicle(): Vehicle {     return new Motorcycle();   } }

第五步：客户端使用

function clientCode(factory: VehicleFactory) {   console.log('Client: Delivery process started...');   const result = factory.deliverVehicle();   console.log(result); }  // 使用不同的工厂创建不同的产品 console.log('App: Launched with CarFactory.'); clientCode(new CarFactory());  console.log('nApp: Launched with TruckFactory.'); clientCode(new TruckFactory());  console.log('nApp: Launched with MotorcycleFactory.'); clientCode(new MotorcycleFactory());

高级应用：参数化工厂方法

在某些场景下，你可能希望通过参数来决定创建哪种产品：

class UniversalVehicleFactory extends VehicleFactory {   constructor(private vehicleType: 'car' | 'truck' | 'motorcycle') {     super();   }      public createVehicle(): Vehicle {     switch (this.vehicleType) {       case 'car':         return new Car();       case 'truck':         return new Truck();       case 'motorcycle':         return new Motorcycle();       default:         throw new Error('Unknown vehicle type');     }   } }  // 使用参数化工厂 const carFactory = new UniversalVehicleFactory('car'); clientCode(carFactory);

结合 TypeScript 的高级特性

使用泛型增强类型安全

abstract class GenericVehicleFactory<T extends Vehicle> {   public abstract createVehicle(): T;      public deliverVehicle(): string {     const vehicle = this.createVehicle();     vehicle.drive();     return vehicle.getInfo();   } }  class GenericCarFactory extends GenericVehicleFactory<Car> {   public createVehicle(): Car {     return new Car();   } }

利用枚举提高代码可读性

enum VehicleType {   CAR = 'car',   TRUCK = 'truck',   MOTORCYCLE = 'motorcycle' }  class EnumVehicleFactory extends VehicleFactory {   constructor(private type: VehicleType) {     super();   }      public createVehicle(): Vehicle {     switch (this.type) {       case VehicleType.CAR:         return new Car();       case VehicleType.TRUCK:         return new Truck();       case VehicleType.MOTORCYCLE:         return new Motorcycle();     }   } }

实际应用场景

场景一：UI 组件库

在不同平台（Web、Mobile、Desktop）上创建相同功能的 UI 组件：

interface Button {   render(): void;   onClick(callback: () => void): void; }  class WebButton implements Button {   render() { console.log('Rendering web button'); }   onClick(callback: () => void) { /* web 实现 */ } }  class MobileButton implements Button {   render() { console.log('Rendering mobile button'); }   onClick(callback: () => void) { /* mobile 实现 */ } }  abstract class UIFactory {   abstract createButton(): Button;   abstract createModal(): Modal; // 假设有 Modal 接口 }  class WebUIFactory extends UIFactory {   createButton(): Button { return new WebButton(); }   createModal(): Modal { return new WebModal(); } }

场景二：数据库连接工厂

interface DatabaseConnection {   connect(): void;   query(sql: string): any[]; }  class MySQLConnection implements DatabaseConnection {   connect() { console.log('Connecting to MySQL'); }   query(sql: string) { return []; } }  class PostgreSQLConnection implements DatabaseConnection {   connect() { console.log('Connecting to PostgreSQL'); }   query(sql: string) { return []; } }  abstract class DatabaseFactory {   abstract createConnection(): DatabaseConnection; }  class MySQLFactory extends DatabaseFactory {   createConnection(): DatabaseConnection {     return new MySQLConnection();   } }

真实案例

TypeORM 的 Driver 工厂使用工厂方法来根据数据库类型创建不同驱动实例。

export class DriverFactory {   create(connection: Connection): Driver {     switch (connection.options.type) {       case "mysql":         return new MysqlDriver(connection)       case "postgres":         return new PostgresDriver(connection)       case "sqlite":         return new SqliteDriver(connection)       // ...     }   } }