Angular 角度提供程序，循环依赖错误

我得到这个错误：
提供程序分析错误：无法实例化循环依赖项

我有一个组件可以对我的后端进行http调用：
后端.component.ts

import { HttpClient } from '@angular/common/http';
public basicQuery(): void {
  this.httpClient.get('http://...')
    .subscribe(
    (response) => {

    },
    error => {

    });
}

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  request = request.clone({
    setHeaders: {
      token: this.auth.getToken()
    }
  });

  return next
    .handle(request)
    .do(
    (response: HttpEvent<any>) => {
    },
    (error: any) => {
      return false;
  });
}

handleError(error): void {
  this.errorLogService.logServer(error);
  super.handleError(error);
}

import { HttpClient } from '@angular/common/http';
logServer(error: Error) {
  this.httpClient.post('http://...', JSON.stringify(error.message))
    .subscribe(
    (response) => { },
    (error) => { });
}

我每次通话都使用侦听器。
令牌.interceptor.ts

import { HttpClient } from '@angular/common/http';
public basicQuery(): void {
  this.httpClient.get('http://...')
    .subscribe(
    (response) => {

    },
    error => {

    });
}

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  request = request.clone({
    setHeaders: {
      token: this.auth.getToken()
    }
  });

  return next
    .handle(request)
    .do(
    (response: HttpEvent<any>) => {
    },
    (error: any) => {
      return false;
  });
}

handleError(error): void {
  this.errorLogService.logServer(error);
  super.handleError(error);
}

import { HttpClient } from '@angular/common/http';
logServer(error: Error) {
  this.httpClient.post('http://...', JSON.stringify(error.message))
    .subscribe(
    (response) => { },
    (error) => { });
}

因此，我使用服务。
errorLog.service.ts

import { HttpClient } from '@angular/common/http';
public basicQuery(): void {
  this.httpClient.get('http://...')
    .subscribe(
    (response) => {

    },
    error => {

    });
}

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  request = request.clone({
    setHeaders: {
      token: this.auth.getToken()
    }
  });

  return next
    .handle(request)
    .do(
    (response: HttpEvent<any>) => {
    },
    (error: any) => {
      return false;
  });
}

handleError(error): void {
  this.errorLogService.logServer(error);
  super.handleError(error);
}

import { HttpClient } from '@angular/common/http';
logServer(error: Error) {
  this.httpClient.post('http://...', JSON.stringify(error.message))
    .subscribe(
    (response) => { },
    (error) => { });
}

这就是问题所在，因为我也使用httpClient。 但我如何避免这种失败，如何正确处理？ 现在我使用“Http”而不是“HttpClient”

更新1

private auth: AuthService;

constructor(
  private utils: Utils,
  private router: Router,
  private injector: Injector
) {
  this.auth = this.injector.get(AuthService);
}

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  request = request.clone({
    setHeaders: {
      token: this.auth.getToken()
    }
  });

  return next
    .handle(request)
    .do(
      (response: HttpEvent<any>) => { },
      (error: any) => { return false }
    );
}

private-auth:AuthService；
建造师(
私有utils:utils，
专用路由器：路由器，
专用注射器：注射器
) {
this.auth=this.injector.get（AuthService）；
}
公共截获（请求：HttpRequest，下一步：HttpHandler）：可观察{
request=request.clone({
集合标题：{
令牌：this.auth.getToken（）
}
});
下一个返回
.处理（请求）
.做(
（响应：HttpEvent）=>{}，
（错误：any）=>{return false}
);
}

更新2

将AuthService和路由器注入到主体中修复了该问题：

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  const started = Date.now();

  this.auth = this.injector.get(AuthService);
  this.router = this.injector.get(Router);

  (...)
}

public intercept（请求：HttpRequest，下一步：HttpHandler）：可观察{
const start=Date.now（）；
this.auth=this.injector.get（AuthService）；
this.router=this.injector.get（路由器）；
(...)
}

以下是如何做到这一点的，不要在构造函数中注入服务，而是在函数体中注入服务。在这里，您也不会遇到诸如达到最大呼叫数之类的问题

@Injectable()
export class YourInterceptor implements HttpInterceptor {
  yourService: YourService;
  constructor(private inject: Injector) {
    //this.yourService = inject.get(YourService);
  }

  intercept(
    request: HttpRequest<any>,
    next: HttpHandler
  ): Observable<HttpEvent<any>> {

    this.yourService = this.inject.get(YourService);

    request = request.clone({
       setHeaders: {
          token: this.YourService.getToken()
       }
    });

    return next.handle(request);    
  }
}

@Injectable（）
导出类YourInterceptor实现HttpInterceptor{
你的服务：你的服务；
构造函数（私有注入：注入器）{
//this.yourService=inject.get（yourService）；
}
拦截(
请求：HttpRequest，
下一步：HttpHandler
)：可见{
this.yourService=this.inject.get（yourService）；
request=request.clone({
集合标题：{
令牌：this.YourService.getToken（）
}
});
下一步返回。处理（请求）；
}
}

根据你的构造器，试试这个

private auth: AuthService;
private router: Router;

constructor(
  private utils: Utils,
  private injector: Injector
) {

}

public intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
  this.router = this.injector.get(Router);
  this.auth = this.injector.get(AuthService);
  request = request.clone({
    setHeaders: {
      token: this.auth.getToken()
    }
  });

  return next
    .handle(request)
    .do(
      (response: HttpEvent<any>) => { },
      (error: any) => { return false }
    );
}

private-auth:AuthService；
专用路由器：路由器；
建造师(
私有utils:utils，
专用注射器：注射器
) {
}
公共截获（请求：HttpRequest，下一步：HttpHandler）：可观察{
this.router=this.injector.get（路由器）；
this.auth=this.injector.get（AuthService）；
request=request.clone({
集合标题：{
令牌：this.auth.getToken（）
}
});
下一个返回
.处理（请求）
.做(
（响应：HttpEvent）=>{}，
（错误：any）=>{return false}
);
}

那么你是不是在你的拦截器中得到了这个？我在拦截器构造函数中遇到了相同的错误，如果是，我可能会给您一个答案。这也不起作用->RangeError:超过最大调用堆栈大小能否显示构造函数代码？您已经为InterceptorUpdate编写了，但我认为这是出于error.service，因为在那里我也导入了httpClient，而不是从interceptor导入的。那么，在更改之后，为什么会超过最大调用数？我正在更新我的答案，尝试一下，让我知道这是否有效，我相信它会，因为在构造函数中，您提供了服务注入，我认为这是错误的或不正确的。我相信我在构造函数中注释的代码让您有点困惑，这些代码被注释了，因为如果我取消注释，我会遇到相同的最大堆栈大小问题。：）对不起，不行。我现在在intercept（）中注入auth.service。提供程序分析错误：无法实例化循环依赖项！路由器（“[错误->]”）