Я хочу выполнять несколько HTTP-вызовов синхронно на разных уровнях в angular 2 с помощью rxJS. Например, у меня есть служба распознавателя, которая обрабатывает 5 вызовов API, таких как a, b, c, d и e.

Я хочу, чтобы они выполнялись в этом порядке, и я не использую ни одно из этих выходных значений в качестве входных, поэтому мне нужны все ответы только в конце.

Сначала должен быть вызван a, и как только api завершен, второй b, c, d третий после завершения b, c, d, тогда следует вызвать e

В активированном маршруте мне нужно получить эти значения и использовать их, которые я уже пробовал ниже, но я получаю только ответы A и E, и я не смог получить значения из внутреннего наблюдаемого

resolve(a,b){
 return A.flatMap(data=> {
      return forkJoin (
                 B,C,D)
                  }).flatMap(xres => {
                                 return E
                                 })
}
route.data.dataA
route.data.dataBCD
route.data.dataE
1
Arunsai B K 25 Сен 2018 в 06:08

2 ответа

Лучший ответ

Если у вас есть один преобразователь, который заботится обо всех 5 запросах, чтобы гарантировать их порядок выполнения, тогда имеет смысл возвращать результаты этих 5 запросов как один элемент. Попробуйте следующее:

import {Observable, forkJoin} from 'rxjs';
import {mergeMap, map} from 'rxjs/operators';

interface AFoo { }
interface BFoo { }
interface CFoo { }
interface DFoo { }
interface EFoo { }

class FooService {
  doA(): Observable<AFoo> { throw new Error("Not implemented"); }
  doB(): Observable<BFoo> { throw new Error("Not implemented"); }
  doC(): Observable<CFoo> { throw new Error("Not implemented"); }
  doD(): Observable<DFoo> { throw new Error("Not implemented"); }
  doE(): Observable<EFoo> { throw new Error("Not implemented"); }
}

interface CompositeFoo {
  aFoo: AFoo;
  bFoo: BFoo;
  cFoo: CFoo;
  dFoo: DFoo;
  eFoo: EFoo;
}

export class FooResolver implements Resolve<CompositeFoo>{
  constructor(private fooService: FooService) { }
  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<CompositeFoo> {
    const forked$ = forkJoin(this.fooService.doB(), this.fooService.doC(), this.fooService.doD())
                    .pipe(map(([bFoo, cFoo, dFoo]) => ({ bFoo, cFoo, dFoo })));
    return this.fooService.doA()
      .pipe(
      mergeMap(aFoo => forked$.pipe(map(forked => ({ ...forked, aFoo })))),
      mergeMap(result => this.fooService.doE().pipe(map(eFoo => ({ eFoo, ...result })))),
      map(result => ({ ...result }))
      );
  }
}
0
Jota.Toledo 25 Сен 2018 в 09:53

Предполагая, что у вас есть готовые угловые http-сервисы A, B C, D и E, вы можете попробовать это

A.subscribe((responseFromA) => {
     Observable.zip(B, C, D).subscribe(([responsefromB, responseFromC, responseFromD])=> {
          E.subscribe( (responseFromE)=> {
               // Here you can get all above resposne
        });
    });
})
-2
Ritesh 25 Сен 2018 в 06:50