Chaîne de retour à partir d'un rappel - Java

personne ne sait comment je peux résoudre le problème suivant. Je veux retourner une Chaîne de caractères à partir d'un rappel, mais je ne reçois que "La dernière variable locale s ne peut pas être affectée, car elle est définie dans un enfermant type", en raison de la finale.

 public String getConstraint(int indexFdg) {
    final String s;
    AsyncCallback<String> callback = new AsyncCallback<String>() {
        public void onFailure(Throwable caught) {
            caught.printStackTrace();
        }

        public void onSuccess(String result) {
            s = result;
        }
    };
    SpeicherService.Util.getInstance().getConstraint(indexFdg, callback);
    return s;
    }

AsyncCallback ne peut pas retourner de valeur. Mais Callable<T> peut. Habituellement, ce que je voudrais faire est de faire de cette un Callable, le passer à un exécuteur testamentaire service, et le retour de l' Future<T> pour obtenir la valeur renvoyée.

OriginalL'auteur ph09 | 2011-07-27

15

Le point de l'ensemble d'un rappel asynchrone est de vous informer de quelque chose qui se passe de manière asynchrone, à un certain moment dans l'avenir. Vous ne pouvez pas retourner s de getConstraint si elle va être mis en après la méthode a fini de s'exécuter.

Lorsque vous traitez avec des rappels asynchrones vous avez à repenser le déroulement de votre programme. Au lieu de getConstraint retourner une valeur, le code qui est utilisation cette valeur doit être appelé comme un résultat de la fonction de rappel.

Comme un simple (incomplet), par exemple, vous auriez besoin de les changer cela:
```
 String s = getConstraint();
 someGuiLabel.setText(s);
```
En quelque chose comme ceci:
```
 myCallback = new AsyncCallback<String>() {
     public void onSuccess(String result) {
         someGuiLabel.setText(result);
     }
 }
 fetchConstraintAsynchronously(myCallback);
```
Modifier

Une alternative populaire est le concept d'une avenir. Un future est un objet que vous pouvez revenir immédiatement, mais qui n'auront qu'une valeur à un certain moment dans l'avenir. C'est un récipient où vous avez seulement besoin d'attendre pour la valeur au point de la demander.

Vous pouvez penser à la tenue d'un avenir que la tenue d'un billet pour votre costume qui est au pressing. Vous obtenez le billet immédiatement, pouvez les garder dans votre porte-monnaie, le donner à un ami... mais dès que vous avez besoin de l'échanger pour le costume, vous devez attendre jusqu'à ce que le costume est prêt.

Java a une telle classe (Avenir<V>) qui est largement utilisé par les ExecutorService API.

Ok, merci...
Je suis confronté à un problème similaire, à partir du résultat de la fonction de rappel-je mettre à jour l'INTERFACE utilisateur. J'ai adopté la même technique que vous avez mentionné, mais le problème dans mon cas, c'est devenu cyclique comme Un - > B, et à nouveau B -> A, où A est la classe UI et B est la classe qui a la fonction de rappel. Est-ce une bonne pratique de garder de cette façon ou pouvez-vous suggérer d'autres solutions? Comme l'INTERFACE utilisateur de la classe appelle la fonction de rappel et rappel des appels de l'INTERFACE utilisateur de nouveau.
Nous aurions probablement besoin de plus de détails pour savoir si c'est un problème. Si elle est à l'origine d'un problème concret, il pourrait être approprié de poser une question avec un exemple minimal qui reproduit la question. Si vous vous demandez généralement au sujet de la conception, il pourrait être approprié pour codereview.stackexchange.com. En général, je dirais que les dépendances mutuelles ne sont pas en eux-mêmes un briseur d'affaire, et qui sont communs dans les modèles comme MVC (d'où la vue et le contrôleur de savoir au sujet de chaque d'autres).

OriginalL'auteur Mark Peters

Une autre solution est de définir une nouvelle classe, appelée SyncResult

public class SyncResult {
    private static final long TIMEOUT = 20000L;
    private String result;

    public String getResult() {
        long startTimeMillis = System.currentTimeMillis();
        while (result == null && System.currentTimeMillis() - startTimeMillis < TIMEOUT) {
            synchronized (this) {
                try {
                    wait(TIMEOUT);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public void setResult(String result) {
        this.result = result;
        synchronized (this) {
            notify();
        }
    }
}

Puis modifiez votre code pour cette

public String getConstraint(int indexFdg) {
    final SyncResult syncResult = new SyncResult();
    AsyncCallback<String> callback = new AsyncCallback<String>() {
        public void onFailure(Throwable caught) {
            caught.printStackTrace();
        }

        public void onSuccess(String result) {
            syncResult.setResult(result);
        }
    };
    SpeicherService.Util.getInstance().getConstraint(indexFdg, callback);
    return syncResult.getResult();
}

La getResult() méthode sera bloqué jusqu'à ce que setResult(String) méthode ni la TIMEOUT atteint.

OriginalL'auteur songlebao

Vous devez vous connecter pour publier un commentaire.

Modifier