Question

我使用resty gwt进行所有服务器通信。我想要一些指示器来显示操作正在进行中。

我认为有两种方法：

进度条，将显示进度百分比;
动画，将在操作正在进行时显示，但没有任何优势。

我假设我需要添加带回调的自定义过滤器。我想发布类似：RestyGwtComunicationStart和RestyGwtComunicationEnd的事件，或者回火以发送onComunicationStarted和 onComunicationEnded。我想在一个地方声明这个，RestyGWT Dispatcher配置。如果有错误我想获取错误。

但我不知道从哪里开始。在文件中没有关于它的消息。

我可以请你帮帮忙吗？我怎么能这样做？

Answer 1

因此，如果您想知道已发送请求，则需要在GWT应用中对您进行处理。您可以在触发请求时发送活动。你有多种方法可以做到这一点。

查看文档https://resty-gwt.github.io/documentation/restygwt-user-guide.html

中的Request Dispatcher

然后，如果您想获取进度信息，因为HTTP调用是同步的。所以没有办法轻易做到这一点。

我一直这样做的方法如下：

1）创建第一个调用以使用POST在后端启动处理，这将返回处理的ID

2）然后对您的处理ID执行GET，以返回进度。一旦进度为100％，它将返回结果的ID

3）使用结果ID

获取结果

（最终可以将2和3混合在一起，并在同一DTO中进度为100％时返回结果）

另一种选择是通过将信息从后端推送到前端来替换2）（html5 websocket）

Answer 2

有人已经把它作为一个拉动请求来重新设置。猜猜你可以尝试一下：

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

Answer 3

不幸的是＆＃34; Dispatcher / Callback过滤器＆＃34;功能未在官方文档中描述。但我可以建议下一个解决方案（此代码应放在模块的EntryPoint实现中）：

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))));

    //...
}

Answer 4

不幸的是我没有得到足够的答案，所以我开发了自己的解决方案。

首先，我已将Resty配置RestyGwtConfig添加到我的模块配置

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();
    }
}

然后我为resty gwt的所有通信请求设置了Custom distpatcher。

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);
    }
}

然后我添加了自定义过滤器（ProgressIndicatorFilter）来处理通信的开始和结束回调：

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);
    }
}

在过滤器类方法中覆盖filter我添加了一个事件触发器（eventBus.fireEvent(new IndicatorEvent("Rest-Gwt Comunication started"));）和已注册的回调，这里是完整的代码：

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;
    }
}

注册回调无法直接进行，例如

new ProgressIndicatorDispatcherCallback()

因为我使用依赖注入。所以我创建了一个工厂来协助注射如下：

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

Here和here您可以找到更多辅助注射信息。

这是回调代码：

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"));
    }
}

在异步开始和结束时Resty-GWT自定义回调

4 个答案: