Angular 2、4中如何在服务内检查调用其方法的组件/服务（无额外参数）

其实在Angular的依赖注入体系里，直接获取调用方的信息确实有点棘手，但还是有几个可行的方案，我给你梳理一下：

1. 使用Error栈追踪 #

这是最直接的办法，不需要修改调用逻辑。你可以在服务方法内部生成一个Error对象，然后解析它的栈信息来定位调用者。

举个例子：

@Injectable()
export class MyService {
  doSomething() {
    const error = new Error();
    // 解析栈信息，不同浏览器格式可能略有差异
    const stackLines = error.stack?.split('\n') || [];
    // 通常第3行左右是实际的调用者（跳过Error构造和当前方法的行）
    const callerLine = stackLines[2];
    if (callerLine) {
      // 提取调用者的类名/方法名，比如从类似"at AppComponent.ngOnInit (app.component.ts:15:20)"的字符串里解析
      const callerMatch = callerLine.match(/at\s+(.+?)\s+\(/);
      if (callerMatch) {
        const callerInfo = callerMatch[1];
        console.log('调用者:', callerInfo);
        // 这里可以根据callerInfo做后续逻辑处理
      }
    }
  }
}

注意：这种方法依赖浏览器的栈格式，不同环境（比如Chrome、Firefox、Node.js）的栈输出可能不一样，所以需要做兼容处理；而且生产环境如果开启了代码压缩（比如Terser），类名和方法名可能会被混淆，这时候就不太好用了。

2. 利用Angular的DI和InjectionToken（进阶可靠方案） #

如果你希望在生产环境也能稳定获取调用者信息，可以结合Angular的依赖注入特性，让调用方在注入服务时附带自己的标识，全程不需要手动传参数。

步骤大概是这样：

• 定义一个CallerToken的InjectionToken，用于注入调用者的标识
• 服务在构造函数中注入这个token的可选值
• 调用组件/服务在providers数组中提供这个token的值

示例代码：

首先定义token：

import { InjectionToken } from '@angular/core';

export const CALLER_ID = new InjectionToken<string>('CallerId');

然后服务里注入这个token：

import { Injectable, Inject, Optional } from '@angular/core';
import { CALLER_ID } from './caller-token';

@Injectable()
export class MyService {
  constructor(@Optional() @Inject(CALLER_ID) private callerId?: string) {}

  doSomething() {
    if (this.callerId) {
      console.log('调用者标识:', this.callerId);
      // 这里可以根据标识做针对性逻辑处理
    } else {
      console.log('未指定调用者标识');
    }
  }
}

调用组件里配置providers：

import { Component } from '@angular/core';
import { MyService } from './my.service';
import { CALLER_ID } from './caller-token';

@Component({
  selector: 'app-root',
  template: `<button (click)="callService()">调用服务</button>`,
  providers: [
    MyService,
    { provide: CALLER_ID, useValue: 'AppComponent' }
  ]
})
export class AppComponent {
  constructor(private myService: MyService) {}

  callService() {
    this.myService.doSomething();
  }
}

这种方法的好处是完全不受代码压缩影响，可靠性高，只是需要调用方在providers里配置一次标识，后续调用方法都不用额外传参，符合你的需求。

3. 使用装饰器包装服务方法 #

你可以写一个装饰器，把调用者追踪的逻辑封装起来，自动给服务方法添加上追踪能力，本质上还是基于栈追踪，但代码会更整洁。

比如一个简单的装饰器：

function TrackCaller(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function(...args: any[]) {
    const error = new Error();
    const stackLines = error.stack?.split('\n') || [];
    const callerLine = stackLines[2];
    let callerInfo = '未知调用者';
    if (callerLine) {
      const match = callerLine.match(/at\s+(.+?)\s+\(/);
      callerInfo = match ? match[1] : callerLine;
    }
    console.log(`方法${propertyKey}被${callerInfo}调用`);
    return originalMethod.apply(this, args);
  };
  return descriptor;
}

然后在服务方法上使用：

@Injectable()
export class MyService {
  @TrackCaller
  doSomething() {
    // 方法原有逻辑
  }
}

这个方案和栈追踪的优缺点类似，但把追踪逻辑抽离到了装饰器里，代码复用性更好。

总结一下：如果只是开发环境调试用，栈追踪的方法最快捷；如果是生产环境需要稳定的调用者信息，那推荐用DI注入标识的方案。

内容的提问来源于stack exchange，提问作者Pasan Sumanaratne