Angular 5 HTTP拦截器错误消息

我的Angular 5:HTTP拦截器有问题。我是新来的，所以请耐心等待我了解这一切是如何运作的。这是我的错误消息：

 compiler.js:19514 Uncaught Error: Provider parse errors:
 Cannot instantiate cyclic dependency! InjectionToken_HTTP_INTERCEPTORS 
 ("[ERROR ->]"): in NgModule AppModule in ./AppModule@-1:-1

这是我的拦截代码：

import {Injectable} from '@angular/core';
import {HttpEvent, HttpHandler, HttpInterceptor, HttpRequest} from'@angular/common/http';
import {Observable} from 'rxjs/Observable';
import {AuthenticationService} from '../_services/authentication.service';



 @Injectable()
 export class AuthInterceptor implements HttpInterceptor {

constructor(private authService: AuthenticationService) {}

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

    this.authService.id_token = localStorage.getItem('access_token');

    // Retrieving the JWT string from Local Storage directly

    if (this.authService.id_token) { // We are checking if the JWT is present

        const cloned = req.clone({
          headers: req.headers.set('Authorization', 'Bearer ' + this.authService.getToken(this.authService.username, this.authService.password))

        });
        return next.handle(cloned); // If the JWT is not present, then the request goes through to the server unmodified

    } else {

        return next.handle(req); // If the JWT is present, then we will clone the HTTP headers, and add an extra Authorization header, which will contain the JWT
    }
   }
}

从'@angular/core'导入{Injectable}；
从'@angular/common/http'导入{HttpEvent，HttpHandler，HttpInterceptor，HttpRequest}；
从“rxjs/Observable”导入{Observable}；
从“../\u services/authentication.service”导入{AuthenticationService}；
@可注射（）
导出类AuthInterceptor实现HttpInterceptor{
构造函数（私有authService:AuthenticationService）{}
截取（req:HttpRequest，next:HttpHandler）：可观察
HttpEvent>{
this.authService.id_token=localStorage.getItem（'access_token'）；
//直接从本地存储中检索JWT字符串
if（this.authService.id_令牌）{//我们正在检查JWT是否存在
const clone=req.clone({
headers:req.headers.set（'Authorization'，'Bearer'+this.authService.getToken（this.authService.username，this.authService.password））
});
return next.handle（cloned）；//如果JWT不存在，则请求将不经修改地传递到服务器
}否则{
return next.handle（req）；//如果存在JWT，那么我们将克隆HTTP头，并添加一个额外的授权头，其中将包含JWT
}
}
}

我正在导入身份验证服务，但不知道还能做什么，我尝试注入它，但它不起作用。请帮忙

          @NgModule({
         declarations: [
         AppComponent,
         NavbarComponent,
         hatitPageComponent,
         hatitLitePageComponent,
         hatitbodyComponent,
         hatitLitebodyComponent,
         MeterqueryComponent,
         MeterlinesideComponent,
         MeterloadsideComponent,
         MeterstatusComponent,
         CommstatusComponent,
         MeterlistComponent,
         MessagecenterComponent,
         FooterComponent,
         WhatsnewComponent,
         MeterresultsComponent,
         DefaultareaComponent,
         InstructionsComponent,
         AuthComponent,
         HomeComponent,
        ],
        imports: [
         BrowserModule,
         FormsModule,
         RoutingModule,
         HttpClientModule,
         BrowserAnimationsModule,
         MatProgressSpinnerModule,
             ],
       providers: [
          ClockService,
          MessageCenterService,
          MeterService,
          DaqService,
          AuthenticationService,
          AuthGuard,
          hatitGuard,
          hatitLiteGuard,
          VersionService,
          {provide: HTTP_INTERCEPTORS , useClass: AuthInterceptor, multi: true}
          ],
        bootstrap: [AppComponent]
                })
        export class AppModule {
     }


import { Injectable} from '@angular/core';
import { Observable} from 'rxjs/Observable';
import {HttpParams, HttpHeaders, HttpClient} from '@angular/common/http';
import { AdGroup } from '../_models/adgroup.model';
import { adGroupsEnum } from '../_enums/adgroups.enum';
import { Router } from '@angular/router';
import { BehaviorSubject } from 'rxjs/BehaviorSubject';

  @Injectable()
  export class AuthenticationService {

    username: any;
    password: any;
    loggedInUsername: string;
    loggedInUserADGroups: string[] = [];
    loggedInUserADGroupModels: AdGroup[] = [];
    // tokenExpirationTimer: any;

    isAuthenticated = false;
    isAuthenticatedSubject: BehaviorSubject < boolean > = new BehaviorSubject(false);

           authApiEndpoint = '';

           hatitCall = '';
           // userAuthURL = '';

           id_token = null;
           refresh_token = null;
           access_token = null;
           // tokenRefreshInterval: any;

           consumer_key_empim = '';
           consumer_secret_empim = '';

           constructor(private http: HttpClient,
          private router: Router) {
             this.isAuthenticatedSubject.next(false);
           }

           ADDGroupMapper(adGroup: string) {
             const adGroupEnumElem = adGroupsEnum[adGroup];
             return new AdGroup(
               adGroupEnumElem['adGroupName'],
               adGroupEnumElem['adGroupEnv'],
               adGroupEnumElem['adGroupApp']
             );
           }

           getUserADDGroups(userName) {
             this.loggedInUserADGroups = [];
             this.loggedInUserADGroupModels = [];
             const url = this.getAuthDSEndPoint();
             const params = new HttpParams()
               .set('lanId', userName)
               .set('domain', this.getUserDomain());
             console.log(url);
             return this.http.get(url, {
               params: params,
               responseType: 'text'
             });
           }


            getToken(username, password): Observable < any > {
                const headers = new HttpHeaders({
                'Content-Type': 'application/x-www-form-urlencoded',
                'Authorization': 'Basic ' + btoa(this.consumer_key_emp + ':' + this.consumer_secret_empim)
                });
                if (username && password) {

                let formData = 'username=' + encodeURIComponent(username) + '&password=' + encodeURIComponent(password)
                    + '&scope=openid msso&grant_type=password';

                return this.http.post(this.getAuthEndPoint(), formData, {
                    headers: headers,
                });
                }
                return null;
            }


                getBackEndRefreshToken() {
                    const headers = new HttpHeaders({
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Authorization': 'Basic ' + btoa(this.consumer_key_emp + ':' + this.consumer_secret_empim)
                    });
                    const formData = 'grant_type=refresh_token&refresh_token=';
                    return this.http.post(this.getAuthEndPoint(), formData)
                    .map(response => response)
                    .catch(error => {
                        this.clearSession();
                        this.router.navigate(['/login']);
                        return Promise.reject(error);
                    }).subscribe(response => {

                        this.setAccessToken(this.access_tokenim);
                        this.setRefreshToken(this.refresh_tokenim);

                        localStorage.setItem('access_token', this.access_tokenim);
                        localStorage.setItem('refresh_token', this.refresh_tokenim);
                    });
                }

                loginUser(username, password, id_token): Observable<any> {
                    this.id_token = id_token;
                    const headers = new Headers({
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Authorization': 'Basic ' + btoa(this.consumer_key_emp + ':' + this.consumer_secret_empim)
                    });
                    const header = new Headers({ headers: headers });
                    this.getBackEndRefreshToken();
                    if (username && password) {
                    const formData = 'username=' + encodeURIComponent(username) + '&password=' + encodeURIComponent(password)
                        + '&scope=openid msso&grant_type=password';

                    return this.http.post(this.hatitCall, formData).map(res => res);
                    }
                    return null;
                }

                // loginUser(token):  Observable<any> {
                //   this.id_token = token;
                //   const headers = new HttpHeaders({
                //     'Content-Type': 'application/x-www-form-urlencoded',
                //     'Authorization': 'Basic ' + btoa(this.consumer_key_emp + ':' + this.consumer_secret_empim)
                //     });
                //     const options  = new RequestOptions({headers: headers});
                //   const formData = 'username=' + encodeURIComponent(this.username) + '&password=' + encodeURIComponent(this.password)
                //     + '&scope=openid msso&grant_type=password';
                //       return this.http.post(this.hatitCall, formData, options).map(res => res);
                // }

                logOut(): void {
                    this.clearSession();
                }

                isUserAuthenticated(): boolean {
                    return this.isAuthenticated;
                }

                hashatitAppAccess() {
                    const appLookUp = 'hatit';
                    // console.log('Checking for hatit Access');
                    if (this.loggedInUserADGroupModels.length > 0) {
                    for (const adg of this.loggedInUserADGroupModels) {
                        if (adg.adGroupApp === appLookUp) {
                        return true;
                        }
                    }
                    }
                    return false;
                }

                hashatitLiteAppAccess() {
                    const appLookUp = 'hatitLite';
                    // console.log('Checking for hatitLite Access');
                    if (this.loggedInUserADGroupModels.length > 0) {
                    for (const adg of this.loggedInUserADGroupModels) {
                        if (adg.adGroupApp === appLookUp) {
                        return true;
                        }
                    }
                    }
                    return false;
                }
                clearSession() {
                    sessionStorage.clear();
                }

                getRefreshToken() {
                    return sessionStorage.getItem('refresh_token');
                }

                setAccessToken(token) {
                    sessionStorage.setItem('access_token', token);
                }
                setRefreshToken(token) {
                    sessionStorage.setItem('refresh_token', token);
                }
                getUserDomain() {
                    return 'NAM';
                }

                getAuthEndPoint() {
                    return this.authApiEndpoint + this.hatitCall;
                }

                getAuthDSEndPoint() {
                    return this.authApiEndpoint + this.hatitCall;
                }
                getAccessToken() {
                    return sessionStorage.getItem('access_token');
                }
                }

@NgModule({
声明：[
应用组件，
导航组件，
HattPageComponent，
hatitLitePageComponent，
HattBodyComponent，
HatitliteBody组件，
仪表查询组件，
梅特林分解成分，
MeterLoadSide组件，
仪表状态组件，
CommstatusComponent，
气象要素，
MessagecenterComponent，
页脚组件，
什么新成分，
MeterResults组件，
默认区域组件，
指令组件，
AuthComponent，
HomeComponent，
],
进口：[
浏览器模块，
FormsModule，
路由模块，
HttpClientModule，
BrowserAnimationsModule，
喷丝头模块，
],
供应商：[
时钟服务，
MessageCenterService，
气象服务，
DaqService，
认证服务，
AuthGuard，
帽卫士，
哈蒂利特卫士，
版本服务，
{提供：HTTP_拦截器，useClass:AuthInterceptor，multi:true}
],
引导：[AppComponent]
})
导出类AppModule{
}
从“@angular/core”导入{Injectable}；
从“rxjs/Observable”导入{Observable}；
从“@angular/common/http”导入{HttpParams，HttpHeaders，HttpClient}；
从“../\u models/AdGroup.model”导入{AdGroup}；
从“../\u enums/adgroups.enum”导入{adGroupsEnum}；
从'@angular/Router'导入{Router}；
从'rxjs/BehaviorSubject'导入{BehaviorSubject}；
@可注射（）
导出类身份验证服务{
用户名：任意；
密码：任意；
loggedInUsername:string；
loggedInUserADGroups:字符串[]=[]；
loggedInUserADGroupModels:AdGroup[]=[]；
//tokenExpirationTimer：任何；
isAuthenticated=false；
isAuthenticatedSubject:BehaviorSubject=新的BehaviorSubject（false）；
authApiEndpoint=''；
hatitCall=''；
//userAuthURL=''；
id_token=null；
刷新\u令牌=null；
access_token=null；
//时间间隔：任何；
消费者密钥empim=“”；
消费者机密信息=“”；
构造函数（私有http:HttpClient，
专用路由器（路由器）{
this.isAuthenticatedSubject.next（false）；
}
ADDGroupMapper（adGroup:string）{
const adGroupEnumElem=adGroupsEnum[adGroup]；
返回新的广告组(
adGroupEnumElem['adGroupName']，
adGroupEnumElem['adGroupEnv']，
adGroupEnumElem['adGroupApp']
);
}
getUserADDGroups（用户名）{
this.loggedInUserADGroups=[]；
this.loggedInUserADGroupModels=[]；
const url=this.getAuthDSEndPoint（）；
const params=新的HttpParams（）
.set（'lanId'，用户名）
.set（'domain'，this.getUserDomain（））；
console.log（url）；
返回此.http.get（url{
params:params，
响应类型：“文本”
});
}
getToken（用户名、密码）：可观察{
const headers=新的HttpHeaders({
“内容类型”：“应用程序/x-www-form-urlencoded”，
“授权”：“基本”+btoa（this.consumer\u key\u emp+：“+this.consumer\u secret\u empim）
});
如果（用户名和密码）{
让formData='username='+encodeURIComponent（username）+'&password='+encodeURIComponent（password）
+“&scope=openid-msso&grant_type=password”；
返回此.http.post（this.getAuthEndPoint（），formData{
标题：标题，
});
}
返回null；
}
getBackEndRefreshToken（）{
const headers=新的HttpHeaders({
“内容类型”：“应用程序/x-www-form-urlencoded”，
“授权”：“基本”+btoa（this.consumer\u key\u emp+：“+this.consumer\u secret\u empim）
});
const formData='grant_type=refresh_token&refresh_token='；
把这个还给我。
 constructor(injector: Injector) {
   this.authService= injector.get(AuthenticationService)
}

const auth = this.injector.get(AuthenticationService);

@Injectable()
export class AuthenticationService {
    constructor(private http: HttpClient, private router: Router) {
             this.isAuthenticatedSubject.next(false);
    }
}

import { Injectable, Injector } from '@angular/core';
import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest} from 
'@angular/common/http';
import {Observable} from 'rxjs/Observable';
import {AuthenticationService} from '../_services/authentication.service';

@Injectable()
export class AuthInterceptor implements HttpInterceptor {
private authService: AuthenticationService;

  constructor(private inj: Injector) {
   }

intercept(req: HttpRequest<any>, next: HttpHandler): 
Observable<HttpEvent<any>> {
 if (req.url.includes('token')) {
return next.handle(req);
}

this.authService = this.inj.get(AuthenticationService);

 const cloned = req.clone({
headers: req.headers.set('Authorization', 'Bearer ' + 
this.authService.getAccessToken())
});

 return next.handle(cloned); // If the JWT is not present, then the 
 request goes through to the server unmodified
}

}