So senden Sie eine GWT RequestFactory-Anforderung erneut

Question

Ist es möglich, eine RequestFactory-Übertragung erneut zu senden? Ich möchte das Äquivalent von diesem tun: How to resend a GWT RPC request bei der Verwendung von RequestFactory. Es ist ziemlich einfach, die gleiche Nutzlast von einer vorherigen Anfrage erneut zu senden, aber ich muss auch einen Aufruf an dieselbe Methode senden. Hier ist meine RequestTransport Klasse, und ich bin der Hoffnung, nur „Wiederzündungs“ die ursprüngliche Anforderung nach Pflege Einnahme von, in diesem Fall eine Anforderung an den Benutzer-Anmeldeinformationen:

package org.greatlogic.rfexample2.client; 

import com.google.gwt.http.client.Request; 
import com.google.gwt.http.client.RequestBuilder; 
import com.google.gwt.http.client.RequestCallback; 
import com.google.gwt.http.client.Response; 
import com.google.web.bindery.requestfactory.gwt.client.DefaultRequestTransport; 
/** 
* Every request factory transmission will pass through the single instance of this class. This can 
* be used to ensure that when a response is received any global conditions (e.g., the user is no 
* longer logged in) can be handled in a consistent manner. 
*/ 
public class RFERequestTransport extends DefaultRequestTransport { 
//-------------------------------------------------------------------------------------------------- 
private IClientFactory _clientFactory; 
//================================================================================================== 
private final class RFERequestCallback implements RequestCallback { 
private RequestCallback _requestCallback; 
private RFERequestCallback(final RequestCallback requestCallback) { 
    _requestCallback = requestCallback; 
} // RFERequestCallback() 
@Override 
public void onError(final Request request, final Throwable exception) { 
    _requestCallback.onError(request, exception); 
} // onError() 
@Override 
public void onResponseReceived(final Request request, final Response response) { 
    if (response.getStatusCode() == Response.SC_UNAUTHORIZED) { 
    _clientFactory.login(); 
    } 
    else { 
    _clientFactory.setLastPayload(null); 
    _clientFactory.setLastReceiver(null); 
    _requestCallback.onResponseReceived(request, response); 
    } 
} // onResponseReceived() 
} // class RFERequestCallback 
//================================================================================================== 
@Override 
protected void configureRequestBuilder(final RequestBuilder builder) { 
    super.configureRequestBuilder(builder); 
} // configureRequestBuilder() 
//-------------------------------------------------------------------------------------------------- 
@Override 
protected RequestCallback createRequestCallback(final TransportReceiver receiver) { 
    return new RFERequestCallback(super.createRequestCallback(receiver)); 
} // createRequestCallback() 
//-------------------------------------------------------------------------------------------------- 
void initialize(final IClientFactory clientFactory) { 
    _clientFactory = clientFactory; 
} // initialize() 
//-------------------------------------------------------------------------------------------------- 
@Override 
public void send(final String payload, final TransportReceiver receiver) { 
    String actualPayload = _clientFactory.getLastPayload(); 
    TransportReceiver actualReceiver; 
    if (actualPayload == null) { 
    actualPayload = payload; 
    actualReceiver = receiver; 
    _clientFactory.setLastPayload(payload); 
    _clientFactory.setLastReceiver(receiver); 
    } 
    else { 
    actualReceiver = _clientFactory.getLastReceiver(); 
    } 
    super.send(actualPayload, actualReceiver); 
} // send() 
//-------------------------------------------------------------------------------------------------- 
} 

Answer 1

Basierend auf dem Vorschlag von Thomas habe ich versucht, eine weitere Anfrage zu senden, und nur die Nutzlast und Empfänger in der RequestTransport.send()-Methode ersetzt, und das hat funktioniert; Ich nehme an, dass kein weiterer Kontext von der Anforderungsfactory beibehalten wird und dass die Antwort vom Server ausreicht, um zu ermitteln, was zum Entpacken der Antwort über die request und response hinaus unternommen werden muss, die an die RequestCallback.onResponseReceived()-Methode zurückgegeben werden. Wenn jemand meinen Code sehen möchte, dann lass es mich wissen und ich poste ihn hier.

Answer 2

Es ist möglich, aber Sie haben eine Menge machen.

Ich hatte die gleiche Idee. Und ich suchte nach einer guten Lösung für ungefähr 2 Tage. Ich habe versucht, den Serveraufruf auf RequestContext.java und auf anderen Klassen abzufangen. Aber wenn Sie das tun, müssen Sie Ihre eigene Implementierung für fast jede Klasse von gwt-Requestfactories machen. Also entschied ich mich für einen viel einfacheren Ansatz.

Überall, wo ich einen Request abgefeuert habe, habe ich die Antwort bearbeitet und erneut abgefeuert. Natürlich muss man darauf achten, dass man nicht in eine Schleife kommt.