Interdire l'appel de méthode jusqu'à ce que l'appel asynchrone aboutisse à la plate-forme GWT

Question

Dans mon application GWT-Platform, j'ai implémenté une méthode dans laquelle une étape consiste à extraire des données du serveur et la prochaine étape en dépend. Je veux empêcher ma méthode pour l'exécution ultérieure du code jusqu'à ce que l'appel asynchrone soit terminé.

Devrait être quelque chose de simple mais je ne trouve pas un moyen.

Answer 1

Je pense qu'il vous manque le point sur le Web asynchrone.

Il n'est pas considéré comme une bonne pratique (c'est plutôt un anti-pattern) de bloquer l'exécution de votre code côté client jusqu'à la fin de l'appel asynchrone.

Ainsi, au lieu de bloquer l'exécution jusqu'à ce que votre code async est terminé faire ce qui suit:

1. Créer un événement qui est tiré sur le EventBus global lorsque votre code async est terminé
2. Joindre un gestionnaire pour cet événement dans l'un de vos présentateurs
3. Démarrez le code async
4. afficher un indicateur de chargement
5. Lorsque l'appel est terminé async masquer l'indicateur de chargement et déclenche l'événement sur t e Eventbus
6. Gérez l'étape suivante dans le gestionnaire que vous avez créé auparavant.

Answer 2

Je ne suis pas gourou GWT, mais je sais comment le faire de manière simple. Je serais très reconnaissant si quelqu'un dit comment le faire de la bonne façon, parce que je m'y intéressais aussi. Vous pouvez juste faire la méthode qui contiendra le code requis et l'appelle onSuccess ou faire quelque chose comme ceci:

import com.google.gwt.core.client.EntryPoint; 
import com.google.gwt.core.client.GWT; 
import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.user.client.Timer; 
import com.google.gwt.user.client.Window; 
import com.google.gwt.user.client.rpc.AsyncCallback; 
import com.google.gwt.user.client.ui.Button; 
import com.google.gwt.user.client.ui.RootPanel; 

public class Aaa implements EntryPoint { 

    private final MyServiceAsync service = GWT 
      .create(MyService.class); 
    private Timer t; 

    public void onModuleLoad() { 
     t = new Timer() { 
      @Override 
      public void run() { 
       // Make something or call function 
       Window.alert("Next Step"); 
      } 
     }; 
     final Button sendButton = new Button("Send"); 
     sendButton.addClickHandler(new ClickHandler() { 

      @Override 
      public void onClick(ClickEvent event) { 
       service.sendInfo("Send First Step Info", 
         new AsyncCallback<String>() { 
          @Override 
          public void onSuccess(String result) { 
           Window.alert("Success Call"); 
           // Call Next step code or function 
           t.schedule(1); 

          } 

          @Override 
          public void onFailure(Throwable caught) { 
           Window.alert("Failure Call"); 
          } 
         }); 
      } 
     }); 
     RootPanel.get().add(sendButton); 
    } 
} 

Answer 3

Pourquoi utiliser un Timer?

final Button sendButton = new Button("Send"); 
sendButton.addClickHandler(new ClickHandler() { 

    @Override 
    public void onClick(ClickEvent event) { 
     service.sendInfo("Send First Step Info", 
       new AsyncCallback<String>() { 
        @Override 
        public void onSuccess(String result) { 
         Window.alert("Success Call"); 
          nextStep(result); 
        } 

        @Override 
        public void onFailure(Throwable caught) { 
         Window.alert("Failure Call"); 
        } 
       }); 
    } 
}); 

private void nextStep(String data) { 
} 

Answer 4

J'ai dû modifier le flux d'origine, le déplacer et le chaîner vers l'onSuccess() de l'appel asynchrone.

A l'origine, le flux est

1. utilisateur clique sur un bouton Ok de dialogue poopup
2. validate (everthing est la validation de la fin avant), si en cas d'erreur de validation, exception throw et erreur d'exposition. diaglog n'est pas fermé.
3. En cas de validation réussie, procédez au traitement des données et fermez la boîte de dialogue.

Maintenant Dans un nouveau scénario, le n ° 2 de validation est modifié pour exiger un appel asynchrone à l'arrière-plan. DonC# 3 doit être déplacé en chaîne vers le callback de la méthode validate.' extraits de code ci-dessous

public void onValidationDataReady(List<Long> existingTests) throws ValidationException { 

    if (!existingTests.isEmpty()) { 
     throw new ValidationException("The entered name has already been used."); 
    } 

    //only after the validation do we proceed with the original OK click 
    proceedOkClick(testNameField.getValue()); 
} 

public void proceedOkClick(String data) { 
    // proceed only after the async call 

    if (callback != null) { 
     callback.onDialogResult(true, data); 
    } 

    clearDialog(); 
} 


public boolean validateInputs() throws ValidationException { 
    //async call to get data from back end. 
      //pass in a Callback 
    testNameValidator.validate(testNameField.getValue(), new DataReadyCallback<List<Long>>() { 
     @Override 
     public void onDataReady(List<Long> existingTests) { 
      onValidationDataReady(existingTests); 
     } 
    }); 
    return true; 
} 

//The call back interface. 
public interface DataReadyCallback<T> { 
void onDataReady(T data); 
}