mm_os/core/handler/index.js

MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。

const {
  Drive
} = require('mm_machine');

/**
 * 应用处理器基类（应用服务层）
 * 负责处理请求，调用服务层，返回响应
 */
class Handler extends Drive {
  static config = {
    name: 'default',
    title: '处理器',
    // 依赖的服务
    services: [],
    // 依赖的仓储
    stores: [],
    // 依赖的富血模型
    models: [],
    timeout: 30000,
    perf_log: false, // 是否记录性能日志
  };
  /**
   * 构造函数
   * @param {object} config 配置参数
   * @param {object} parent 父对象
   */
  constructor(config, parent) {
    super({ ...Handler.config, ...config || {} }, parent);

    // 仓储管理集合
    this._store = {};
    // 服务管理集合
    this._service = {};
    // 富血模型管理集合
    this._model = {};
  }
}

/**
 * 预设
 */
Handler.prototype._preset = function () {
  /** === 基础设施 === */
  // 文件管理器
  this._filer = null;

  // 消息推送器
  this._sender = null;
  // 广播器
  this._pusher = null;
  // 通知器
  this._notifier = null;
};

/**
 * 获取模板目录
 * @returns {string} 模板目录
 */
Handler.prototype.getTplDir = function () {
  return __dirname;
};

/**
 * 初始化依赖检查
 */
Handler.prototype._checkDeps = function () {
  let {
    services,
    stores,
    models
  } = this.config;

  for (var i = 0; i < services.length; i++) {
    var name = services[i];
    if (!this._service[name]) {
      this.log('error', `${name}服务(service)未找到`);
    }
  }

  for (var i = 0; i < stores.length; i++) {
    var name = stores[i];
    if (!this._store[name]) {
      this.log('error', `${name}仓储(store)未找到`);
    }
  }

  for (var i = 0; i < models.length; i++) {
    var name = models[i];
    if (!this._model[name]) {
      this.log('error', `${name}模型(model)未找到`);
    }
  }
};

/**
 * 初始化核心
 * @param {object} app 当前应用
 * @param {object} eventer 事件总线
 * @param {object} logger 日志管理器
 */
Handler.prototype._initCore = async function (app, eventer, logger) {
  // 初始化依赖项
  if (logger) {
    this.setLogger(logger);
  }
  if (eventer) {
    this.getEventer = function () {
      return eventer;
    };
  }

  let {
    store,
    service,
    model
  } = app;
  this._store = store;
  this._service = service;
  this._model = model;

  // 检查依赖项
  this._checkDeps();
};

/**
 * 销毁处理器
 */
Handler.prototype._destroy = async function () {
  try {
    // 清理资源
    this._store = null;
    this._service = null;
    this._model = null;
    this._db = null;
    this._cache = null;
    this._filer = null;

    this._sender = null;
    this._pusher = null;
    this._notifier = null;

  } catch (error) {
    this.log('error', '销毁发生错误:', error);
  }
};

/**
 * 请求预处理方法
 * @param {object} req 请求对象
 * @param {object} res 响应对象
 * @returns {Promise<void>}
 */
Handler.prototype._before = async function (req, res) {
  this.log('debug', '请求预处理', { req, res });
};

/**
 * 请求主处理逻辑
 * 核心业务逻辑应该在此方法中实现
 * @param {object} req 请求对象
 * @param {object} res 响应对象
 * @returns {Promise<object>} 处理结果
 */
Handler.prototype.main = async function (req, res) {
  this.log('debug', '默认请求处理，子类应重写此方法', { req, res });
  // 默认实现，子类必须重写
  throw new Error('main 方法必须被重写');
};

/**
 * 请求后处理方法
 * @param {object} req 请求对象
 * @param {object} res 响应对象
 * @param {object} result 处理结果
 * @returns {Promise<void>}
 */
Handler.prototype._after = async function (req, res, result) {
  this.log('debug', '请求后处理', { req, res, result });
};

exports.Handler = Handler;