Angular 同步在时间上发生变化的服务变量的变化

我正在尝试使用

Angular 10

中的以下服务，这是一个查找正在进行的http请求的服务，如果有http请求，此服务将从true更改为false，这样做很好，我使用控制台日志检查它

导出类SpinnerService实现HttpInterceptor{
公共加载：boolean=false；
构造函数（）{}
截取（req:HttpRequest，next:HttpHandler）：可观察{
这是。加载=真；
//log（'estado微调器：>>'，this.loading）；
返回next.handle（req.pipe）(
完成（（）=>{
这一点：加载=错误；
//log（'todas请求ok'）；
log（'estado espinner:>>'，this.loading）；
})
);
}
}

当我试图在另一个组件中使用该服务时，我遇到了问题，因为该服务与该组件的局部变量不同步。 例如，服务的加载变量开始为false，然后变为true，然后变为false。所有这一切都发生在5秒钟的时间段内，这需要API的其余部分来获取数据

加载变量最初与加载变量同步为false，但随后它不遵循加载变量的状态，加载变量保持false

如何同步这些变量？请帮忙，我不知道怎么搜索

这是我从加载变量调用服务的构造函数

public carga=this.\u spinnerService.loading；
构造函数（专用喷丝器服务：喷丝器服务）
{
this.crearFormulario（）；//inicializar formulario
//this._spinnerService.load=this.spinners；
//console.log（'estado inicial spinner:>>'，this.\u spinnerService.loading）；
console.log（'estado initial spinner:>>'，this.carga）；
} 

我认为您要展示的是应用程序中每个http网络调用的微调器。如果是这种情况，除了SpinnerService类中提到的公共变量“loading”之外，您几乎是正确的

import { NgxSpinnerService } from 'ngx-spinner';
export class SpinnerService implements HttpInterceptor{
            
    constructor(private spinner: NgxSpinnerService) { }

    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> 
    {
        this.spinner.show();
        return next.handle(req).pipe(
            finalize(() => {
                        this.spinner.hide();
                    }
            )
    );
    }
}

在您的app.component.ts中

<ngx-spinner></ngx-spinner>

请参阅：

---

我能够解决这个问题，我在同一个ts文件中创建了类，这样它更有序，一个类负责拦截逻辑，另一个类负责侦听http请求，我检查了许多解决方案，但这是我最喜欢的解决方案，因为它在html中返回true或false，而不需要使用依赖项

这是您使用的服务的ts文件，您只需将该服务导入到要使用微调器的组件中即可

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpResponse, HttpErrorResponse } from '@angular/common/http';//para interceptor de http
import { BehaviorSubject, Observable } from 'rxjs';//para interceptor de http
import { tap } from 'rxjs/operators';//para interceptor de http


@Injectable({
  providedIn: 'root'
})

//servicio interceptor que escucha si hay solicitudes http en progreso
export class interceptHttpService implements HttpInterceptor{

  constructor(private _pruebaspinerss3 : spinnerService ) { }
  
  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> 
  {    
    this._pruebaspinerss3.requestStarted();    
    return this.handler(next,request);
  }

  handler(next ,request)
  {
    return next.handle(request)
      .pipe(
          tap(
            (event) =>{
              if (event instanceof HttpResponse){
                this._pruebaspinerss3.requestEnded();  
              }
            },
            (error: HttpErrorResponse) =>{
              this._pruebaspinerss3.resetSpinner();
              throw error;
            }
          ),
      )
  };
}

export class spinnerService{
  
  private count = 0;
  private spinner$ = new BehaviorSubject<string>('');
  
  getSpinnerObserver(): Observable<string>{
    return this.spinner$.asObservable();
  }  

  requestStarted() {
    console.log('spinner activado');   
    if (++this.count === 1) {
      this.spinner$.next('start');
    }
  }

  requestEnded() {
    console.log('spinner desactivado');   
    if (this.count === 0 || --this.count === 0) {
      this.spinner$.next('stop');
    }
  }

  resetSpinner() {
    console.log('error en solicitud, reset spinner');
    this.count = 0;
    this.spinner$.next('stop');
  }
}

---

好的，该值在截取函数内部设置为true。一旦任何http请求返回，它就会被设置为false。问题是它处理了多少个请求，时差是多少？很有可能它发生得如此之快，除了50毫秒或更短的时间外，它的真实值从未见过。Yo creo Que这可能是由于您确定服务范围的方式。您的服务将拦截所有网络请求并应用您输入的逻辑。例如，如果您有两个api调用，当您进行第一个调用时，拦截器会将该值设置为true，然后在finalize中将其设置为false，第二个请求也会发生同样的情况。因此，您不能保证this.loading将按照您期望的方式运行。此SpinnerService的范围是什么，可能是将其提供给组件级别而不是模块。因此，它为每个组件创建自身的实例，从而为每个组件附加加载变量。这与依赖注入有关，因为它是竞争对手，而不是ngx依赖者

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpResponse, HttpErrorResponse } from '@angular/common/http';//para interceptor de http
import { BehaviorSubject, Observable } from 'rxjs';//para interceptor de http
import { tap } from 'rxjs/operators';//para interceptor de http


@Injectable({
  providedIn: 'root'
})

//servicio interceptor que escucha si hay solicitudes http en progreso
export class interceptHttpService implements HttpInterceptor{

  constructor(private _pruebaspinerss3 : spinnerService ) { }
  
  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> 
  {    
    this._pruebaspinerss3.requestStarted();    
    return this.handler(next,request);
  }

  handler(next ,request)
  {
    return next.handle(request)
      .pipe(
          tap(
            (event) =>{
              if (event instanceof HttpResponse){
                this._pruebaspinerss3.requestEnded();  
              }
            },
            (error: HttpErrorResponse) =>{
              this._pruebaspinerss3.resetSpinner();
              throw error;
            }
          ),
      )
  };
}

export class spinnerService{
  
  private count = 0;
  private spinner$ = new BehaviorSubject<string>('');
  
  getSpinnerObserver(): Observable<string>{
    return this.spinner$.asObservable();
  }  

  requestStarted() {
    console.log('spinner activado');   
    if (++this.count === 1) {
      this.spinner$.next('start');
    }
  }

  requestEnded() {
    console.log('spinner desactivado');   
    if (this.count === 0 || --this.count === 0) {
      this.spinner$.next('stop');
    }
  }

  resetSpinner() {
    console.log('error en solicitud, reset spinner');
    this.count = 0;
    this.spinner$.next('stop');
  }
}

import { interceptHttpService, spinnerService } from './services/spinner.service';