等待 observable 的正确模式是什么？ [复制]

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 的客户端将调用 processesData()。只是好奇如何优雅地等待 processData() 中的 observable。我的非异步方面想检查 observable 的 finally 部分是否已被调用。如果是这样，只需使用 this.processedData。如果不是……那又怎样？我想我可以只订阅一次，在处理数据中，并且只在第一次调用时。这似乎仍然不太正确。想法？

Answer 1

等待Observable的正确方法不是等待，而是聆听。

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 => ...
})

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