Angular2 – Come catena async chiamate di servizio (le richieste http) in un componente?

Ho un componente necessario prima di chiamare un servizio di POSTARE qualcosa. Poi nella stessa componente voglio aspettare fino a quando il POST è fatto, per chiamare un altro servizio che Riceve i dati.

Come posso fare la chiamata di attendere la chiamata POST alla fine?

Nella nuova versione.componente.ts:

private createNewVersion(value) {
    ...

    //create new version, then call on all available versions

    //POST call
    this._newVersionService.createNewVersion(vnr);

    //GET call
    this._versionService.getAvailableVersions(); 

    ...
}

Nella nuova versione.servizio.ts:

export class NewVersionService {

response$: Subject<any>;

constructor(private _http: Http) {
    this.response$ = new BehaviorSubject<any>(null);
 }

public createNewVersion(versionNr) {    
    this._http.post('http://localhost:8080/services/' + versionNr, null, {
        method: 'POST',
    })
    .subscribe(response => {
        this.response$.next(response.status);
    },
    error => console.error(error));
}

Grazie!

InformationsquelleAutor Sojye | 2016-02-03



5 Replies
  1. 5

    Quando una chiamata restituisce un Promise catena di chiamate con

    someFunction() {
      return returnsPromise()
        .then(result => doSomethingNext())
        .then(result => doSomethingAfterThat());
    }

    Garantire un return che restituisce il Promise della catena in modo che il chiamante di someFunc() ha anche la possibilità di tempo di lavoro aggiuntivo per l’esecuzione dopo il doSomethingAfterThat() è completato.

    Quando una chiamata restituisce un Observable quindi utilizzare il complete richiamata

    someFunction() {
      return returnsObservable()
        .subscribe(
          event => doForEachEvent(),
          error => handleError(),
          () => doSomethingNext()
              .then(result => doSomethingAfterThat());
    }

    doSomethingNext() viene eseguito dopo l’ultimo event e doSomethingAfterThat() è di nuovo incatenato con then() per mostrare come mix osservabili e promessa. doSomething().

  2. 1

    Si dovrebbe essere in grado di concat per ottenere la sequenza, e reduce per raccogliere i valori emessi:

    var a = this._newVersionService.createNewVersion(vnr);
    var b = this._versionService.getAvailableVersions(); 
    
    Rx.Observable.concat(a, b).reduce((acc:Array<any>, x:any) => {
        acc.push(x); return acc;
    }, []).subscribe(t=> { 
          var firstEmitted = t[0];
          var secondEmitted = t[1];
    });
    
  3. 0

    Si può fare come questo:
    Cambiare createNewVersion a:

    public createNewVersion(versionNr) {
     return this._http.post('http://localhost:8080/nod_inspection_plugin/services/' + versionNr, null, {
        method: 'POST',
     });
    }
    

    Poi, nel bando:

    this._newVersionService.createNewVersion(vnr).subscribe(response=> {
     this._versionService.getAvailableVersions(); 
    }, error => console.error(error));
    
  4. 0

    Un altro modo per fare la stessa cosa è per subscribe in new-version.component.ts e invito GET richiesta entro il POST richiesta.e verificare se il POST richiesta è stato fatto Correttamente o non
    se sì POST è svolto Correttamente, quindi si chiama GET richiesta. Come di seguito:

    Nella nuova versione.componente.ts:

     private createNewVersion(value) {
        ...
        //create new version, then call on all available versions
    
        //POST call
        this._newVersionService.createNewVersion(vnr)
            .subscribe((res) => {
                if(res){
                    console.log(res);
                    if (---Post request done properly check via status or something else here----{
                        CALL YOUR GET REQUEST HERE.....
                        //GET call 
                        this._versionService.getAvailableVersions(); 
                    }
                    else {
                        DO something else whatever you want....
                    }
                }
            });
        ...
    }
    

    Nella nuova versione.servizio.ts:

    export class NewVersionService {
    
    response$: Subject<any>;
    
    constructor(private _http: Http) {
        this.response$ = new BehaviorSubject<any>(null);
     }
    
    public createNewVersion(versionNr) {    
        this._http.post('http://localhost:8080/nod_inspection_plugin/services/' + versionNr, null, {
            method: 'POST',
        })
        .map(response => {
            return [{status: response.status, json: response.json()}];
        },
        error => console.error(error));
    }
    

    per ulteriori informazioni relative al http richiesta è possibile leggi qui.

    • perché downvote ??
    • Hai mai letto il tuo codice? Il codice è illeggibile. Probabilmente questo è il motivo
  5. 0

    Meglio utilizzare switchMap() qui.

    const versions$ = this._newVersionService.createNewVersion(vnr)
                     .switchMap(response => this._versionService.getAvailableVersions());
    
    versions$.subscribe(response2 => this.versions = response2)
    

    Ma il problema sarà se fai un’altra richiesta POST di prima è stato risolto, la precedente richiesta di ottenere cancellato.

Lascia un commento