Angular Ngrx和解析器，带角度6中的HttpClient

我在Angular 6中使用ngrx/（存储，效果）。 我有一个问题，通过解析器解析其中一个路由变量。 下面是代码和说明

解析器

@Injectable()
export class HkSpecialitiesResolver implements Resolve<Speciality[]> {

  constructor(
    private store: Store<AppState>) {
  }

  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Speciality[]> {
    return this.store
      .pipe(
        select(selectAllSpecialities),
        tap(specialities => {
          if (!specialities || specialities.length === 0) {
            this.store.dispatch(new AllSpecialitiesRequested());
          }
        }),
        filter((specialities: Speciality[]) => {
          return specialities !== [];
        }),
        take(select(selectAllSpecialities).length)
      );
  }
}

export interface SpecialitiesState extends EntityState<Speciality> {
  allSpecialitiesLoaded: boolean;
}

export const adapter: EntityAdapter<Speciality> =
  createEntityAdapter<Speciality>({
    selectId: (speciality: Speciality)  =>  {
      return (speciality !== undefined) ? speciality.uuid : undefined;
    }
  });


export const initialSpecialitiesState: SpecialitiesState = adapter.getInitialState({
  allSpecialitiesLoaded: false
});


export function specialityReducer(state = initialSpecialitiesState, action: SpecialityActions): SpecialitiesState {
  switch (action.type) {
    case SpecialityActionTypes.SpecialityLoaded:
      return adapter.addOne(action.payload.speciality, state);
    case SpecialityActionTypes.AllSpecialitiesLoaded:
      return adapter.addAll(action.payload.specialities, {...state, allSpecialitiesLoaded: true});
    case SpecialityActionTypes.SpecialitySaved:
      return adapter.updateOne(action.payload.speciality, state);
    default: {
      return state;
    }
  }
}

export const {
  selectAll,
  selectEntities,
  selectIds,
  selectTotal

} = adapter.getSelectors();

@Injectable（）
导出类HKSpecialistesResolver实现解析{
建造师(
私人店铺（零售店）{
}
解析（路由：ActivatedRouteSnapshot，状态：RouterStateSnashot）：可观察{
把这个还给我
.烟斗(
选择（选择所有专业），
点击（特色=>{
如果（！specialites | | specialites.length==0）{
this.store.dispatch（新的AllSpecialitiesRequested（））；
}
}),
过滤器（（专业：专业[]）=>{
退货特价！=[]；
}),
拍摄（选择（选择所有专业）。长度）
);
}
}

效果

@Injectable()
export class HkSpecialitiesEffects {

  @Effect()
  loadAllSpecilities$ = this.actions$
    .pipe(
      ofType<AllSpecialitiesRequested>(SpecialityActionTypes.AllSpecialitiesRequested),
      withLatestFrom(this.store.pipe(select(allSpecialitiesLoaded))),
      filter(([action, allSpecialitiesLoaded]) => {
        console.log('loadAllSpecilities$ - ', [action, allSpecialitiesLoaded]);
        return !allSpecialitiesLoaded;
      }),
      mergeMap((o) => {
        console.log('loadAllSpecilities$ - mergeMap', o);
        return this.specialityService.findAll();
      }),
      map((specialities: Speciality[]) => {
        console.log('loadAllCourses$ - map', specialities);
        return new AllSpecialitiesLoaded({specialities});
      })
    );

  constructor(private actions$: Actions, private specialityService: HkSpecialitiesService,
              private store: Store<AppState>) {

  }
}

@Injectable（）
出口类香港特产效果{
@效果（）
loadAllSpecilities$=this.actions$
.烟斗(
ofType（SpecialityActionTypes.AllSpecialitiesRequested），
withLatestFrom（this.store.pipe（select（allSpecialitiesLoaded））），
过滤器（（[action，allSpecialitiesLoaded]）=>{
log（'LoadAllSpecialities$-'，[action，allSpecialitiesLoaded]）；
返回！所有专业已加载；
}),
合并映射（（o）=>{
log（'loadAllSpecilities$-mergeMap'，o）；
返回此.specialityService.findAll（）；
}),
地图（（专业：专业[]）=>{
log（'loadAllCourses$-map'，specialities）；
返回新的AllSpecialitesLoaded（{Specialites}）；
})
);
构造函数（私有操作$：操作，私有specialityService:HKSpecialityService，
私人店铺（零售店）{
}
}

减速器

@Injectable()
export class HkSpecialitiesResolver implements Resolve<Speciality[]> {

  constructor(
    private store: Store<AppState>) {
  }

  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Speciality[]> {
    return this.store
      .pipe(
        select(selectAllSpecialities),
        tap(specialities => {
          if (!specialities || specialities.length === 0) {
            this.store.dispatch(new AllSpecialitiesRequested());
          }
        }),
        filter((specialities: Speciality[]) => {
          return specialities !== [];
        }),
        take(select(selectAllSpecialities).length)
      );
  }
}

export interface SpecialitiesState extends EntityState<Speciality> {
  allSpecialitiesLoaded: boolean;
}

export const adapter: EntityAdapter<Speciality> =
  createEntityAdapter<Speciality>({
    selectId: (speciality: Speciality)  =>  {
      return (speciality !== undefined) ? speciality.uuid : undefined;
    }
  });


export const initialSpecialitiesState: SpecialitiesState = adapter.getInitialState({
  allSpecialitiesLoaded: false
});


export function specialityReducer(state = initialSpecialitiesState, action: SpecialityActions): SpecialitiesState {
  switch (action.type) {
    case SpecialityActionTypes.SpecialityLoaded:
      return adapter.addOne(action.payload.speciality, state);
    case SpecialityActionTypes.AllSpecialitiesLoaded:
      return adapter.addAll(action.payload.specialities, {...state, allSpecialitiesLoaded: true});
    case SpecialityActionTypes.SpecialitySaved:
      return adapter.updateOne(action.payload.speciality, state);
    default: {
      return state;
    }
  }
}

export const {
  selectAll,
  selectEntities,
  selectIds,
  selectTotal

} = adapter.getSelectors();

导出接口专用状态扩展EntityState{
加载的所有特殊性：布尔值；
}
导出常量适配器：EntityAdapter=
createEntityAdapter({
selectId：（专业：专业）=>{
返回（speciality！==未定义）？speciality.uuid：未定义；
}
});
导出常量InitialSpecialiteState:SpecialiteState=adapter.getInitialState({
加载的所有专业：false
});
导出函数specialityReducer（状态=InitialSpecialityState，操作：SpecialityActions）：SpecialityState{
开关（动作类型）{
案例SpecialityActionTypes.SpecialityLoaded：
返回adapter.addOne（action.payload.speciality，state）；
案例SpecialityActionTypes.AllSpecialities已加载：
返回adapter.addAll（action.payload.specialities，{…state，allspecialitiesload:true}）；
案例SpecialityActionTypes.SpecialitySaved：
返回adapter.updateOne（action.payload.speciality，state）；
默认值：{
返回状态；
}
}
}
出口常数{
选择全部，
选择实体，
SelectID，
选择总计
}=adapter.getSelectors（）；

服务

@Injectable()
export class HkSpecialitiesService {

  constructor(private http: HttpClient) {
  }

  findAll(): Observable<Speciality[]> {
    const vm = this;
    // it works with these lines
    /*return Observable.create((observer) => {
  observer.next([{id: 'a', uuid: 'a', name: 'Psychology', description: 'Psychology'}]);
});*/
    // Not works with this line
    return vm.http.get<Speciality[]>('/api/specialities').pipe(map((specialities) => specialities));
  }
}

@Injectable（）
出口类香港专业服务{
构造函数（专用http:HttpClient）{
}
findAll（）：可观察{
const vm=这个；
//它适用于这些行
/*返回可观察的。创建（（观察者）=>{
下一步（[{id:'a'，uuid:'a'，名称：'Psychology'，描述：'Psychology'）；
});*/
//这条线不行
返回vm.http.get（'/api/specialities'）.pipe（map（（specialities）=>specialities））；
}
}

问题在于，正如代码所示，resolves specialities变量被解析为空（[]），在组件中，我将其解析为空，一个空数组。 但是如果在服务中，我更改了http调用，对于注释的行，解析程序中变量的解析将采用我返回的唯一正确值

当在服务中调用http的get时，“解析器”在效果结束之前被解析

我不理解的是，注释行（所有操作都使用该行）返回的可观察内容与http调用的内容相同

有什么建议吗