Method resolve

packages/core/src/Core/ServiceContainer.ts:257–317

* 解析服务 * * @param identifier - 服务标识符（构造函数或 Symbol） * @returns 服务实例 * @throws 如果服务未注册或存在循环依赖 * * @example * ```typescript * const timer = container.resolve(TimerManager); * * // 使用 Symbol * const fileSystem = container.resolve(IFileSystem);

(identifier: ServiceIdentifier<T>)

     * ```
     */
    public resolve<T extends IService>(identifier: ServiceIdentifier<T>): T {
        const registration = this._services.get(identifier);
        const name = typeof identifier === 'symbol' ? identifier.description : identifier.name;

        if (!registration) {
            throw new Error(`Service ${name} is not registered`);
        }

        // 检测循环依赖
        if (this._resolving.has(identifier)) {
            const chain = Array.from(this._resolving).map((t) =>
                typeof t === 'symbol' ? t.description : t.name
            ).join(' -> ');
            throw new Error(`Circular dependency detected: ${chain} -> ${name}`);
        }

        // 如果是单例且已经有实例，直接返回
        if (registration.lifetime === ServiceLifetime.Singleton && registration.instance) {
            return registration.instance as T;
        }

        // 添加到解析栈
        this._resolving.add(identifier);

        try {
            // 创建实例
            let instance: IService;

            if (registration.factory) {
                // 使用工厂函数
                instance = registration.factory(this);
            } else if (registration.type) {
                // 直接构造
                instance = new (registration.type)();
            } else {
                throw new Error(`Service ${name} has no factory or type to construct`);
            }

            // 如果是单例，缓存实例
            if (registration.lifetime === ServiceLifetime.Singleton) {
                registration.instance = instance;

                // 如果使用了@Updatable装饰器，添加到可更新列表
                if (registration.type && checkUpdatable(registration.type)) {
                    const metadata = getUpdatableMetadata(registration.type);
                    const priority = metadata?.priority ?? 0;
                    this._updatableServices.push({ instance, priority });

                    // 按优先级排序（数值越小越先执行）
                    this._updatableServices.sort((a, b) => a.priority - b.priority);

                    logger.debug(`Service ${name} is updatable (priority: ${priority}), added to update list`);
                }
            }

            return instance as T;
        } finally {
            // 从解析栈移除