工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但让子类决定实例化哪个类。这种模式将对象的实例化推迟到子类，从而实现了创建逻辑与使用逻辑的分离。
核心概念解析
image
工厂方法模式包含以下几个关键角色：
产品接口（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)
// ...
}
}
}
基于数据库类型返回不同的 Driver 子类
统一入口 create()
使用者不关心具体 driver，只依赖 Driver 接口
工厂方法模式的优势与局限
优势
避免紧耦合：客户端代码只依赖于抽象接口，不依赖于具体类
单一职责原则：将创建逻辑集中在一个地方，便于维护
开闭原则：添加新产品类型时无需修改现有代码
代码可测试性：可以轻松创建模拟对象进行单元测试
局限
代码复杂度增加：需要引入多个额外的类和接口
可能过度设计：对于简单场景，直接实例化可能更合适
实践建议
适时使用：当预计会有多种类似产品，或创建逻辑比较复杂时使用
结合依赖注入：在大型应用中，结合依赖注入容器使用效果更佳
文档化工厂意图：明确每个工厂的职责和适用场景
考虑简单工厂：如果产品类型不多，可以考虑使用简单工厂模式
