Node.js中常用的设计模式有哪些？

来源：cnblogs　　作者：葡萄城技术团队　　时间：2023/10/19 10:04:03　　对本文有异议

本文由葡萄城技术团队首发。转载请注明出处：葡萄城官网，葡萄城为开发者提供专业的开发工具、解决方案和服务，赋能开发者。

设计模式简介

设计模式是由经验丰富的程序员在日积月累中抽象出的用以解决通用问题的可复用解决方案，它提供了标准化的代码设计方案提升开发体验。Node.js 作为一款用来构建可扩展高性能应用的流行平台，自然也遵循设计模式解决通用问题。本文中，我们将讨论 Node.js 中设计模式的重要性并提供一些代码示例。

构建 Node.js 应用为何需要设计模式

设计模式为软件开发提供了一套标准化的解决方案。构建 Node.js 应用时，善用设计模式能够帮助开发者提升代码质量，节约开发时间，减少出错几率。同时也方便开发人员之间的沟通交流。

示例代码

单例模式

该模式用来保证特定的类在整个应用中只能创建唯一实例。Node.js 中，单例模式可以保证在同一个应用中，每个模块只有唯一实例。

class Singleton {
  constructor() {
    if (Singleton.instance) {
      return Singleton.instance;
    }
    Singleton.instance = this;
  }
  // Your code here
}
module.exports = Singleton;

工厂模式

工厂模式用来在不暴露实现逻辑的情况下创建对象。在 Node.js 中，使用工厂模式可以根据用户输入创建不同类型的实例。

class Car {
  constructor(name) {
    this.name = name;
  }
  drive() {
    console.log(`Driving ${this.name}`);
  }
}
class CarFactory {
  static create(name) {
    return new Car(name);
  }
}
const car1 = CarFactory.create("BMW");
const car2 = CarFactory.create("Audi");
car1.drive(); // Driving BMW
car2.drive(); // Driving Audi

观察者模式

观察者模式通过维护一个被观察对象列表，实现当对象发生改变时发出通知。在 Node.js中，该设计模式用来管理事件和回调。

class EventObserver {
  constructor() {
    this.observers = [];
  }
  subscribe(fn) {
    this.observers.push(fn);
  }
  unsubscribe(fn) {
    this.observers = this.observers.filter(subscriber => subscriber !== fn);
  }
  notify(data) {
    this.observers.forEach(observer => observer(data));
  }
}
const eventObserver = new EventObserver();
eventObserver.subscribe(data => console.log(`Subscribed to ${data}`));
eventObserver.notify("some data");

依赖注入模式

在本案例中，定义了一个依赖database 对象的UserService 类。通过将 database 传给 UserService 的构造函数，实现在不修改 UserService 的前提下操作不同数据库对象。

class UserService {
  constructor(database) {
    this.database = database;
  }
  getUser(id) {
    return this.database.query(`SELECT * FROM users WHERE id = ${id}`);
  }
}
module.exports = UserService;

Promise 模式

在本案例中，通过 fs.promises 模块异步读取文件。readFile 函数返回一个 promise 对象，该 promise对象成功时可以通过 then 方法获取文件内容，失败时可以通过 catch 方法获取错误信息。

const fs = require('fs').promises;
function readFile(filePath) {
  return fs.readFile(filePath, 'utf8');
}
readFile('example.txt')
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });

Node.js 内建模块中的设计模式

默认情况下，Node.js 本身在其功能中不依赖任何特定的设计模式，但它提供了遵循常见设计模式的内置模块。Node.js 中一些常用的设计模式包括：

模块模式

Node.js 默认使用模块模式将代码组织成可复用、可维护的模块。在 Node.js 中，每个文件都被视为一个模块，开发人员可以使用 require 和 module.exports 语句在文件之间导出或导入代码。

const fs = require('fs');
// 异步读取文件
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});
// 同步读取文件
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data);
// 写入文件
fs.writeFile('file.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('文件已写入');
});

事件驱动模式

Node.js 使用事件驱动模式来处理 I/O 操作，如向文件或网络套接字读取和写入数据。事件驱动模式基于观察者模式，允许开发人员创建事件发射器，以便在某些事件发生时通知侦听器。

// 模块定义
const myModule = (function () {
  // 私有成员
  const privateVar = 'Hello, World!';
  function privateMethod() {
    console.log(privateVar);
  }
  // 公有成员
  return {
    publicMethod: function () {
      privateMethod();
    },
    publicVar: 'I am public'
  };
})();
// 使用模块
myModule.publicMethod();  // 输出 'Hello, World!'
console.log(myModule.publicVar); // 输出 'I am public'

回调模式

Node.js 使用回调模式来处理异步操作，如读写文件或网络请求。回调模式基于观察者模式，允许开发人员将函数作为参数传递，以便在操作完成时执行。

function fetchData(callback) {
  // 模拟异步数据获取
  setTimeout(() => {
    const data = 'Hello, World!';
    callback(null, data); // 第一个参数为错误对象，第二个参数为返回的数据
  }, 2000);
}
function processData(err, data) {
  if (err) {
    console.error('出错了：', err);
    return;
  }
  console.log('处理数据：', data);
}
fetchData(processData);

中间件模式

中间件是 Express.js 等 Node.js 框架中常用的设计模式。中间件函数是在管道中执行的函数，其中每个函数都可以在将请求或响应对象传递到下一个函数之前修改它们。中间件可用于身份验证、日志记录、错误处理等任务。

// 中间件函数1
function middleware1(req, res, next) {
  console.log('执行中间件1');
  // 在这里可以对 req 和 res 进行处理
  next(); // 调用 next() 将控制权传递给下一个中间件
}
// 中间件函数2
function middleware2(req, res, next) {
  console.log('执行中间件2');
  // 在这里可以对 req 和 res 进行处理
  next(); // 调用 next() 将控制权传递给下一个中间件
}
// 最终处理函数
function finalHandler(req, res) {
  console.log('执行最终处理函数');
  // 在这里进行最终的请求处理和响应
  res.end('Hello, World!');
}
// 使用中间件
function handleRequest(req, res) {
  middleware1(req, res, () => {
    middleware2(req, res, () => {
      finalHandler(req, res);
    });
  });
}
// 创建服务器并处理请求
const http = require('http');
const server = http.createServer(handleRequest);
server.listen(3000, 'localhost', () => {
  console.log('服务器已启动');
});

依赖注入模式

依赖注入（DI）模式是一种用于管理对象之间依赖关系的设计模式。在 Node.js 中，DI 可用于将依赖项注入到模块中，使它们更加模块化和可重用。DI 可以使用构造函数注入、属性注入或方法注入等技术来实现。

// 用户服务模块
class UserService {
  constructor() {
    this.users = [];
  }
  addUser(user) {
    this.users.push(user);
  }
  getUsers() {
    return this.users;
  }
}
// 用户控制器模块（依赖于用户服务模块）
class UserController {
  constructor(userService) {
    this.userService = userService;
  }
  addUser(user) {
    this.userService.addUser(user);
  }
  getUsers() {
    return this.userService.getUsers();
  }
}
// 使用依赖注入创建用户控制器实例
const userService = new UserService();
const userController = new UserController(userService);
// 在用户控制器中添加用户并获取用户列表
userController.addUser('John');
userController.addUser('Mary');
console.log(userController.getUsers()); // 输出：['John', 'Mary']

Promise模式

Promise模式是一种设计模式，用于以更结构化和类似同步的方式处理异步操作。Promise 是表示异步操作最终完成或失败的对象，允许开发人员通过将异步操作连接在一起来编写更具可读性和可维护性的代码。

// 使用 Promise 封装异步函数
function getUserById(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const user = { id, name: 'John' };
      resolve(user);
    }, 1000);
  });
}
// 调用异步函数并使用 Promise 链式调用处理结果
getUserById(1)
  .then(user => {
    console.log(user);
    return getUserById(2);
  })
  .then(user => {
    console.log(user);
  })
  .catch(err => {
    console.error(err);
  });