从0开始学习JavaScript--JavaScript 工厂模式

news2024/11/17 13:51:30

JavaScript 工厂模式是一种强大的设计模式，它提供了一种灵活的方式来创建对象。本文将深入讨论工厂模式的基本概念、多种实现方式以及在实际应用中的各种场景。

工厂模式的基本概念

工厂模式旨在通过一个函数或方法来创建对象，而不是通过类直接实例化。这种方式有助于封装创建对象的过程，提高代码的灵活性和可维护性。

1. 简单工厂模式

简单工厂模式是工厂模式的基础形式，通过一个函数来创建对象实例。

function createCar(make, model) {
  return {
    make: make,
    model: model,
    start: function() {
      console.log(`${make} ${model} is starting.`);
    },
    stop: function() {
      console.log(`${make} ${model} is stopping.`);
    }
  };
}

const car1 = createCar('Toyota', 'Camry');
const car2 = createCar('Honda', 'Accord');

car1.start(); // 输出: Toyota Camry is starting.
car2.stop(); // 输出: Honda Accord is stopping.

在这个例子中，createCar 函数充当了一个简单的工厂，负责创建具有相同结构的汽车对象。

2. 工厂方法模式

工厂方法模式引入了一个抽象工厂，通过继承或实现接口来创建对象。

class CarFactory {
  createCar(make, model) {
    throw new Error('createCar method must be implemented.');
  }
}

class ToyotaFactory extends CarFactory {
  createCar(model) {
    return new ToyotaCar(model);
  }
}

class HondaFactory extends CarFactory {
  createCar(model) {
    return new HondaCar(model);
  }
}

class ToyotaCar {
  constructor(model) {
    this.make = 'Toyota';
    this.model = model;
  }

  start() {
    console.log(`${this.make} ${this.model} is starting.`);
  }

  stop() {
    console.log(`${this.make} ${this.model} is stopping.`);
  }
}

class HondaCar {
  constructor(model) {
    this.make = 'Honda';
    this.model = model;
  }

  start() {
    console.log(`${this.make} ${this.model} is starting.`);
  }

  stop() {
    console.log(`${this.make} ${this.model} is stopping.`);
  }
}

const toyotaFactory = new ToyotaFactory();
const hondaFactory = new HondaFactory();

const car1 = toyotaFactory.createCar('Camry');
const car2 = hondaFactory.createCar('Accord');

car1.start(); // 输出: Toyota Camry is starting.
car2.stop(); // 输出: Honda Accord is stopping.

在这个例子中，CarFactory 是一个抽象工厂，ToyotaFactory 和 HondaFactory 是具体工厂，分别创建 ToyotaCar 和 HondaCar 对象。

工厂模式的实际应用场景

1. UI组件库

在开发大型的 UI 组件库时，工厂模式可以用于创建各种类型的 UI 组件，通过工厂来统一管理组件的创建和初始化。

class Button {
  constructor(text) {
    this.text = text;
  }

  render() {
    console.log(`<button>${this.text}</button>`);
  }
}

class Input {
  constructor(type) {
    this.type = type;
  }

  render() {
    console.log(`<input type="${this.type}"/>`);
  }
}

class UIComponentFactory {
  createComponent(type, options) {
    switch (type) {
      case 'button':
        return new Button(options.text);
      case 'input':
        return new Input(options.type);
      default:
        throw new Error('Invalid component type.');
    }
  }
}

const uiFactory = new UIComponentFactory();

const button = uiFactory.createComponent('button', { text: 'Click me' });
const input = uiFactory.createComponent('input', { type: 'text' });

button.render(); // 输出: <button>Click me</button>
input.render(); // 输出: <input type="text"/>

在这个例子中，UIComponentFactory 充当了组件的工厂，通过 createComponent 方法创建不同类型的 UI 组件。

2. 数据处理模块

在处理不同数据源的数据时，工厂模式可以用于创建数据处理模块，根据不同的数据源类型返回相应的数据处理对象。

class JSONProcessor {
  process(data) {
    return JSON.parse(data);
  }
}

class CSVProcessor {
  process(data) {
    // 实际的 CSV 处理逻辑
    console.log('Processing CSV data:', data);
  }
}

class DataProcessorFactory {
  createProcessor(type) {
    switch (type) {
      case 'json':
        return new JSONProcessor();
      case 'csv':
        return new CSVProcessor();
      default:
        throw new Error('Invalid data processor type.');
    }
  }
}

const processorFactory = new DataProcessorFactory();

const jsonProcessor = processorFactory.createProcessor('json');
const csvProcessor = processorFactory.createProcessor('csv');

jsonProcessor.process('{"name": "John", "age": 30}');
csvProcessor.process('Name,Age\nAlice,25\nBob,32');

在这个例子中，DataProcessorFactory 充当了数据处理模块的工厂，通过 createProcessor 方法创建不同类型的数据处理对象。

工厂模式的进阶应用

1. 插件系统

在构建插件化的应用程序时，工厂模式可以用于动态创建和加载插件。

class Plugin {
  constructor(name) {
    this.name = name;
  }

  execute() {
    console.log(`${this.name} plugin is executing.`);
  }
}

class PluginFactory {
  createPlugin(name) {
    return new Plugin(name);
  }
}

class App {
  constructor() {
    this.plugins = [];
    this.pluginFactory = new PluginFactory();
  }

  loadPlugin(name) {
    const plugin = this.pluginFactory.createPlugin(name);
    this.plugins.push(plugin);
  }

  runPlugins() {
    this.plugins.forEach(plugin => plugin.execute());
  }
}

const app = new App();
app.loadPlugin('Analytics');
app.loadPlugin('Logger');
app.runPlugins();

在这个例子中，PluginFactory 充当插件的工厂，通过 createPlugin 方法动态创建不同类型的插件。App 类通过工厂加载和运行插件。

2. 模块化加载

在模块化加载的应用中，工厂模式可以用于创建和管理模块实例。

class Module {
  constructor(name) {
    this.name = name;
  }

  execute() {
    console.log(`${this.name} module is executing.`);
  }
}

class ModuleFactory {
  createModule(name) {
    return new Module(name);
  }
}

class ModuleManager {
  constructor() {
    this.modules = [];
    this.moduleFactory = new ModuleFactory();
  }

  loadModule(name) {
    const module = this.moduleFactory.createModule(name);
    this.modules.push(module);
  }

  runModules() {
    this.modules.forEach(module => module.execute());
  }
}

const moduleManager = new ModuleManager();
moduleManager.loadModule('Authentication');
moduleManager.loadModule('Storage');
moduleManager.runModules();