Resty-GWT benutzerdefinierten Rückruf bei asynchronen Start und Ende

Question

Ich benutze Resty GWT für alle Server-Kommunikation. Ich hätte gerne einen Indikator, der anzeigt, dass die Operation läuft.

Ich halte 2 aproaches:

• progressbar, die im Gange Prozentsatz zeigen;
• Animation, die während des laufenden Betriebs angezeigt wird, jedoch ohne Percentage.

Ich habe angenommen, dass ich benutzerdefinierte Filter mit Rückruf hinzufügen muss. Ich möchte Ereignisse wie: RestyGwtComunicationStart und RestyGwtComunicationEnd oder Rückruf zum Feuer onComunicationStarted und onComunicationEnded feuern. Ich möchte dies an einem Ort, RestyGWT Dispatcher-Konfiguration deklariert haben. Auch wenn es einen Fehler gab, möchte ich den Fehler holen.

Aber ich weiß nicht, wo ich anfangen soll. Es gibt kein Wort darüber in Dokumentationen.

Kann ich Sie um Hilfe bitten? Wie kann ich das machen?

Answer 1

Leider habe ich nicht eine angemessene Antwort bekommen, so entwickelte ich meine eigene Lösung.

Zuerst habe ich hinzugefügt Resty Konfiguration RestyGwtConfig meiner Modulkonfiguration

public class ClientModule extends AbstractPresenterModule { 
    @Override 
    protected void configure() { 
     bind(RestyGwtConfig.class).asEagerSingleton(); 
     install(new DefaultModule.Builder() 
     .defaultPlace(Routing.HOME.url) 
     .errorPlace(Routing.ERROR.url) 
     .unauthorizedPlace(Routing.LOGIN.url) 
     .tokenFormatter(RouteTokenFormatter.class).build()); 
     install(new AppModule()); 
     install(new GinFactoryModuleBuilder().build(AssistedInjectionFactory.class)); 
     bind(ResourceLoader.class).asEagerSingleton(); 
    } 
} 

dann habe ich Gewohnheit distpatcher für alle meine Komunikation Anfragen von resty gwt gesetzt.

import org.fusesource.restygwt.client.Defaults; 
import org.fusesource.restygwt.client.Resource; 
import pl.korbeldaniel.cms.shared.ServiceRouting; 
import com.google.gwt.core.client.GWT; 
import com.google.inject.Inject; 

public class RestyGwtConfig { 
    @Inject 
    public RestyGwtConfig(RestyDispatcher dispatcher) { 
     Defaults.setDispatcher(dispatcher); 
    } 
} 

Dann habe ich hinzugefügt benutzerdefinierte Filter (ProgressIndicatorFilter) zu handhaben Mitteilung der Start und Ende Rückrufe:

import org.fusesource.restygwt.client.Method; 
import org.fusesource.restygwt.client.dispatcher.DefaultFilterawareDispatcher; 
import com.google.gwt.http.client.Request; 
import com.google.gwt.http.client.RequestBuilder; 
import com.google.gwt.http.client.RequestException; 
import com.google.inject.Inject; 

public class RestyDispatcher extends DefaultFilterawareDispatcher { 
    @Inject 
    public RestyDispatcher(ProgressIndicatorFilter progressIndicatorFilter) { 
     addFilter(progressIndicatorFilter); 
    } 
} 

in Verfahren Filterklasse außer Kraft gesetzt filter Ich habe ein Ereignis-Trigger hinzugefügt (eventBus.fireEvent(new IndicatorEvent("Rest-Gwt Comunication started"));) und registrierter Rückruf, hier ist der ganze Code:

import org.fusesource.restygwt.client.Method; 
import org.fusesource.restygwt.client.dispatcher.DispatcherFilter; 
import pl.korbeldaniel.cms.client.template.progressIndicator.IndicatorEvent; 
import com.google.gwt.http.client.RequestBuilder; 
import com.google.inject.Inject; 
import com.google.web.bindery.event.shared.EventBus; 

class ProgressIndicatorFilter implements DispatcherFilter { 
    private AssistedInjectionFactory factory; 
    private EventBus eventBus; 

    @Inject 
    public ProgressIndicatorFilter(AssistedInjectionFactory factory, EventBus eventBus) { 
     this.factory = factory; 
     this.eventBus = eventBus; 
    } 
    @Override 
    public boolean filter(Method method, RequestBuilder builder) { 
     builder.setCallback(factory.createProgressIndicatorCallback(method)); 
     eventBus.fireEvent(new IndicatorEvent("Resty-Gwt Comunication started")); 
     return true; 
    } 
} 

einen Rückruf Die Registrierung konnte nicht gerade nach vorne getan werden, wie

new ProgressIndicatorDispatcherCallback()

Ursache verwende ich Dependency Injection. Also habe ich eine Fabrik erstellt Injektion wie folgt zu unterstützen:

public interface AssistedInjectionFactory { 
    ProgressIndicatorDispatcherCallback createProgressIndicatorCallback(Method method); 
} 

Here und here Sie können mehr Assisted Injection Infos. Hier

ist der Rückruf-Code:

class ProgressIndicatorDispatcherCallback implements RequestCallback { 
    private RequestCallback requestCallback; 
    private EventBus eventBus; 

    @Inject 
    public ProgressIndicatorDispatcherCallback(@Assisted Method method, EventBus eventBus) { 
     this.requestCallback = method.builder.getCallback(); 
     this.eventBus = eventBus; 
    } 
    @Override 
    public void onResponseReceived(Request request, Response response) { 
     endComunicationFireIvent(); 
     requestCallback.onResponseReceived(request, response); 
    } 
    @Override 
    public void onError(Request request, Throwable exception) { 
     endComunicationFireIvent(); 
     requestCallback.onError(request, exception); 
    } 
    private void endComunicationFireIvent() { 
     eventBus.fireEvent(new IndicatorEvent("Rest-Gwt Comunication ended")); 
    } 
} 

Answer 2

Wenn Sie also wissen möchten, dass eine Anfrage gesendet wurde, liegt es an Ihnen in Ihrer GWT-App, das zu behandeln. Sie können ein Ereignis senden, wenn Sie Ihre Anfrage auslösen. Sie haben mehrere Möglichkeiten, dies zu tun.

Werfen Sie einen Blick auf Antrag Dispatcher in der doc https://resty-gwt.github.io/documentation/restygwt-user-guide.html

Dann, wenn Sie Fortschritt Informationen erhalten möchten, wie HTTP-Aufrufe synchron sind. Also gibt es keine Möglichkeit, das leicht zu machen.

Die Art, wie ich es zu tun habe, ist die folgende:

1) einen ersten Anruf erstellen Verarbeitung im Backend mit einem POST, dies wird wieder die ID Ihre Verarbeitung

2) zu initiieren Führen Sie dann einen GET auf Ihre Verarbeitungs-ID aus, die den Fortschritt zurückgibt. Sobald der Fortschritt 100% ist, wird es die ID des Ergebnisses zurück

3) Holen Sie sich das Ergebnis mit dem Ergebnis, ID

(Sie 2 mischen und 3 zusammen schließlich und Ergebnis zurück, wenn Fortschritt 100% in der ist gleiche DTO)

eine weitere Option ist 2) zu ersetzen, indem Informationen von Backend Frontend schieben (html5 websocket)

Answer 3

Jemand bereits tat es als Pull-Anfrage an resty. Raten Sie Sie es versuchen können:

https://github.com/resty-gwt/resty-gwt/pull/151

Answer 4

„Dispatcher/Callback Filter“ -Funktion in der offiziellen Dokumentation nicht beschrieben Leider. Aber ich kann nächste Lösung vorschlagen (dieser Code sollte in Entrypoint-Implementierung des Moduls platziert werden):

public void onModuleLoad() { 
    //... 

    //used to show busy indicator before send HTTP request   
    DispatcherFilter busyIndicatorDispatcherFilter = new DispatcherFilter() { 
     @Override 
     public boolean filter(Method method, RequestBuilder builder) { 
      BusyIndicator.show(); 
      return true; 
     } 
    }; 
    //used to show busy indicator after HTTP response recieved 
    CallbackFilter busyIndicatorCallbackFilter = new CallbackFilter() { 
     @Override 
     public RequestCallback filter(Method method, Response response, RequestCallback callback) { 
      BusyIndicator.hide(); 
      return callback; 
     } 
    }; 
    //registering FilterawareDispatcher (and busy indicator filters) as default Dispatcher 
    Defaults.setDispatcher(new DefaultFilterawareDispatcher(
      busyIndicatorDispatcherFilter, 
      new DefaultDispatcherFilter(new DefaultCallbackFactory(busyIndicatorCallbackFilter)))); 

    //... 
}