fu-orm-code-generator/src/infrastructure/di/Container.js

A Model Context Protocol (MCP) server for MyBatis code generation with enterprise-grade layered architecture

/**
 * 依赖注入容器
 * 管理应用中所有依赖的创建和生命周期
 */

import { config, initConfig } from '../../config/index.js';

/**
 * 简单的依赖注入容器
 */
export class Container {
  constructor() {
    this.services = new Map();
    this.singletons = new Map();
  }

  /**
   * 注册服务
   * @param {string} name - 服务名称
   * @param {Function|Object} factory - 工厂函数或实例
   * @param {Object} [options] - 选项
   * @param {boolean} [options.singleton=false] - 是否单例
   * @param {string[]} [options.dependencies=[]] - 依赖列表
   */
  register(name, factory, options = {}) {
    const { singleton = false, dependencies = [] } = options;
    
    this.services.set(name, {
      factory,
      singleton,
      dependencies,
      instance: null
    });
  }

  /**
   * 注册单例服务
   * @param {string} name - 服务名称
   * @param {Function|Object} factory - 工厂函数或实例
   * @param {string[]} [dependencies=[]] - 依赖列表
   */
  registerSingleton(name, factory, dependencies = []) {
    this.register(name, factory, { singleton: true, dependencies });
  }

  /**
   * 获取服务实例
   * @param {string} name - 服务名称
   * @returns {any} 服务实例
   */
  resolve(name) {
    const service = this.services.get(name);
    if (!service) {
      throw new Error(`Service "${name}" not found`);
    }

    // 如果是单例且已创建实例，直接返回
    if (service.singleton && service.instance) {
      return service.instance;
    }

    // 解析依赖
    const dependencies = service.dependencies.map(dep => this.resolve(dep));

    // 创建实例
    let instance;
    if (typeof service.factory === 'function') {
      instance = new service.factory(...dependencies);
    } else {
      instance = service.factory;
    }

    // 如果是单例，缓存实例
    if (service.singleton) {
      service.instance = instance;
    }

    return instance;
  }

  /**
   * 检查服务是否已注册
   * @param {string} name - 服务名称
   * @returns {boolean} 是否已注册
   */
  has(name) {
    return this.services.has(name);
  }

  /**
   * 获取所有已注册的服务名称
   * @returns {string[]} 服务名称列表
   */
  getServiceNames() {
    return Array.from(this.services.keys());
  }

  /**
   * 清除所有服务
   */
  clear() {
    this.services.clear();
    this.singletons.clear();
  }

  /**
   * 移除指定服务
   * @param {string} name - 服务名称
   * @returns {boolean} 是否成功移除
   */
  remove(name) {
    this.singletons.delete(name);
    return this.services.delete(name);
  }
}

/**
 * 配置和初始化容器
 * @returns {Promise<Container>} 配置好的容器实例
 */
export async function createContainer() {
  // 初始化配置
  initConfig();
  
  const container = new Container();

  // 注册配置
  container.registerSingleton('config', config);

  // 注册基础设施层
  const { HttpClient } = await import('../http/HttpClient.js');
  const { FileSystem } = await import('../filesystem/FileSystem.js');
  const { FileSystemService } = await import('../services/FileSystemService.js');
  const { Validator } = await import('../validation/Validator.js');
  
  container.registerSingleton('httpClient', HttpClient);
  container.registerSingleton('fileSystem', FileSystem);
  container.registerSingleton('fileSystemService', FileSystemService, ['config']);
  container.registerSingleton('validator', Validator);

  // 注册仓储实现
  const { TemplateRepositoryImpl } = await import('../repositories/TemplateRepositoryImpl.js');
  const { ConfigRepositoryImpl } = await import('../repositories/ConfigRepositoryImpl.js');
  
  container.registerSingleton('templateRepository', TemplateRepositoryImpl, ['httpClient', 'fileSystem']);
  container.registerSingleton('configRepository', ConfigRepositoryImpl, ['fileSystem']);

  // 注册应用服务
  const { TemplateApplicationService } = await import('../../application/services/TemplateApplicationService.js');
  const { ConfigApplicationService } = await import('../../application/services/ConfigApplicationService.js');
  const { CodeGenerationService } = await import('../../application/services/CodeGenerationService.js');
  
  container.registerSingleton('templateApplicationService', TemplateApplicationService, [
    'templateRepository', 
    'configRepository', 
    'validator'
  ]);

  container.registerSingleton('configApplicationService', ConfigApplicationService, [
    'configRepository',
    'validator'
  ]);

  container.registerSingleton('codeGenerationService', CodeGenerationService, [
    'templateRepository',
    'configApplicationService',
    'fileSystemService'
  ]);

  // 注册工具处理器
  const { VisitOnlineTemplatesHandler } = await import('../../presentation/tools/VisitOnlineTemplatesHandler.js');
  const { DownloadOnlineTemplateHandler } = await import('../../presentation/tools/DownloadOnlineTemplateHandler.js');
  const { ChooseLocalTemplateHandler } = await import('../../presentation/tools/ChooseLocalTemplateHandler.js');
  const { VisitLocalTemplatesHandler } = await import('../../presentation/tools/VisitLocalTemplatesHandler.js');
  const { EditLocalTemplatesHandler } = await import('../../presentation/tools/EditLocalTemplatesHandler.js');
  
  // 新增：用户信息管理工具处理器
  const { SetUserInfoHandler } = await import('../../presentation/tools/SetUserInfoHandler.js');
  const { GetUserInfoHandler } = await import('../../presentation/tools/GetUserInfoHandler.js');
  
  // 新增：表前缀管理工具处理器
  const { SetTablePrefixHandler } = await import('../../presentation/tools/SetTablePrefixHandler.js');
  const { GetTablePrefixHandler } = await import('../../presentation/tools/GetTablePrefixHandler.js');
  
  // 新增：代码生成工具处理器
  const { GenerateOrmCodeHandler } = await import('../../presentation/tools/GenerateOrmCodeHandler.js');

  // 模板管理工具处理器
  container.register('visitOnlineTemplatesHandler', VisitOnlineTemplatesHandler, {
    dependencies: ['templateApplicationService']
  });
  container.register('downloadOnlineTemplateHandler', DownloadOnlineTemplateHandler, {
    dependencies: ['templateApplicationService']
  });
  container.register('chooseLocalTemplateHandler', ChooseLocalTemplateHandler, {
    dependencies: ['templateApplicationService']
  });
  container.register('visitLocalTemplatesHandler', VisitLocalTemplatesHandler, {
    dependencies: ['templateApplicationService']
  });
  container.register('editLocalTemplatesHandler', EditLocalTemplatesHandler, {
    dependencies: ['templateApplicationService']
  });

  // 用户信息管理工具处理器
  container.register('setUserInfoHandler', SetUserInfoHandler, {
    dependencies: ['configApplicationService']
  });
  container.register('getUserInfoHandler', GetUserInfoHandler, {
    dependencies: ['configApplicationService']
  });

  // 表前缀管理工具处理器
  container.register('setTablePrefixHandler', SetTablePrefixHandler, {
    dependencies: ['configApplicationService']
  });
  container.register('getTablePrefixHandler', GetTablePrefixHandler, {
    dependencies: ['configApplicationService']
  });

  // 代码生成工具处理器
  container.register('generateOrmCodeHandler', GenerateOrmCodeHandler, {
    dependencies: ['codeGenerationService']
  });

  return container;
}