Question

我有两项服务：一项依赖于另一项。服务A进行http调用以获取数据。服务B实际上使用了这些数据。

服务A：

@Injectable({
  providedIn: 'root'
})
export class ServiceA {
  data: MyData;

  getData(): Observable<MyData> {
    return this.http.get<Mydata>('http://some.url')
      .pipe(
        tap((data: MyData) => {console.log(`got data');})
      )
    );
  };
}

服务B：

@Injectable({
  providedIn: 'root'
})
export class ServiceB {

  obs = Observable<MyData> = new Observable<MyData>();
  processedData: string[];

  constructor(private serviceA: ServiceA) {
    this.obs = this.serviceA.getData();
    this.obs.subscribe( 
      data => {this.processedData = process(data)},
      error => { /*process error*/ },
      function() { /* maybe mark flag here? */}
      );
  }

  process(endpointData) {
     // Do some business logic to endpointData
     this.processedData = endpointData;
  }

  processedData() {
    // The first time this is called, the observable hasn't completed
  }
}

服务B的客户端将调用processingData（）。只是好奇如何优雅地等待processData（）中的可观察对象。我的非异步方面想检查是否已调用了可观察对象的最后一部分。如果是这样，只需使用this.processedData。如果没有...那又如何？我想我只能在处理数据内仅进行一次订阅，并且只能在第一次调用时进行。这似乎仍然不太正确。有想法吗？

Answer 1

等待Observable 的正确方法是不 wait ，而是 listen 。

constructor(private readonly serviceA: ServiceA) {
  this.data$ = this.serviceA.getData().pipe(
     map(data => process(data)),
     shareReplay(1)
  );

  // Immediately subscribe to execute the HTTP call
  this.data$.subscribe({
    error: error => { /* Process error */ },
  });
}

...

processedData(): Observable<MyData> {
  // Return the data "holder".
  // The result will already be there, or in the process of being retrieved
  return this.data$;
}

使用 pipable 运算符shareReplay表示Observable充当缓存，返回最新的计算值在随后的每个订阅中。

serviceB.processedData().subscribe({
  next: data => ...
})

数据可以立即可用，或者需要一些时间来计算。

等待可观察的适当模式是什么？

1 个答案: