I’ve building a new website project with GWT, so I thought I’d take the opportunity to try GWTP, which provides an MVP framework for GWT. I’ve previously used bare GWT to do much the same thing while developing OnlineGlom, but I hoped it could be easier. Both are really for structuring client-side UI and behaviour.
Once you’ve got your GWT application built, you can almost forget how difficult it was to create the basic structure. So I’ve taken the time to describe both the old (GWT) way and the new (GWTP) way of doing things to remind myself how much better life is with GWTP. I mostly just discuss how the activities/presenters and views interact in the two systems. You would need to learn a bit more to write a full application. If you are familiar with GWT, you might skip to the GWTP section.
You’ll see that, even with GWTP, the code is far from concise, but that’s hard to avoid completely with Java, particularly when trying to split code into Presenters and Views, and splitting implementation and interface. Overall, I really wish that GWTP was just part of GWT with the old GWT Activities deprecated. Then people could focus on this one right way of doing things, and making it even better.
For GWT, I refer to my old OnlineGlom project. For GWTP, I refer to the little murrayc-gwtp-appengine-example project I created recently.
GWT: Activities/Views/Places
GWT provides the Activities and Places framework, and suggests you create Views for your UI. That page has a good overview and explanation, but I’ll go over the parts here too.
Place
GWT’s Activities and Places framework is mixed up with GWT’s history support, which lets the different states of your application have URLs that can appear in browser bookmarks and history. That’s how we have a “history token”, which describes a Place.
For instance, for each main location in your app, you would have SomethingPlace, extending GWT’s Place. Here’s an example from OnlineGlom: DetailsPlace is for a page that shows the details from a database record.
The @Prefix(“details“) annotation on its Tokenizer tells GWT that this place can handle URLs that begin with/ #/details, such as http:://onlineglom.something.com/#/details?table=things?primaryKey=123. The Place class takes the place’s parameters in its constructor and stores them. Those parameters usually refer to the ?something=blah parameters in the URLs.
getPlace() constructs a Place object from a token (mostly a URL), and getToken() constructs a token from a Place object. There isn’t any convenience API to avoid the tedious splitting and concatenation of strings, though we created a couple of helper methods for this in OnlineGlom.
Activity
Each place in your app will have an Activity, whose constructor will take an instance of your derived Place class. For instance, in OnlineGlom, the DetailsActivity takes a DetailsPlace. The Activity can use the Place’s getter methods to discover what the URL’s parameters have specified.
Your app will derive an ActivityMapper that maps the places to the Activities. For instance, in OnlineGlom, our DataActivityMapper‘s getActivity() method instantiates a DetailsActivity when it gets a DetailsPlace.
You’ll pass your ActivityMapper when creating an ActivityManager. For instance, in OnlineGlom, we create an ActivityManager that takes our DataActivityMapper. You’ll then call setDisplay() on your ActivityManager, passing an AcceptsOneWidget that will be used to show your activitity’s View.
This is already a lot of boilerplate code for some basic functionality.
View
Each place has a View. You’ll have one view interface and at least one implementation of that interface. For instance, OnlineGlom has its DetailsView interface and its DetailsViewImpl class that implements that interface. Your Activity can call methods on the view to make it show appropriate UI for the Activity’s state.
GWT has no base View class or interface, though we created a base View class for OnlineGlom, which has a View.Presenter interface implemented by all the Activities. Each Activity can then call setPresenter(this) on the view, giving the view a way to respond back to the Activity, such as telling the Activity that the user has clicked on something that should take the user to a new location.
Your ClientFactoryImpl, which implements your ClientFactory interface, instantiates the view implementation based on the view interface. For instance, OnlineGlom’s ClientFactoryImpl creates a DetailsViewImpl when asked for a DetailsView.
Your Activity takes your ClientFactory and uses it to create its View. For instance, in OnlineGlom’s DetailsActivity constructor, which was itself called by the DetailsActivityManager that I mentioned earlier. The actual ClientFactoryImpl is instantiated by a call to GWT.create(ClientFactory.class), using the ClientFactory to ClientFactoryImpl mapping in a .gwt.xml file. For instance, in OnlineGlom.gwt.xml:
<!-- Use ClientFactoryImpl by default --> <replace-with class="org.glom.web.client.ClientFactoryImpl"> <when-type-is class="org.glom.web.client.ClientFactory" /> </replace-with>
In theory, you might want different implementations of your View interface for different devices. Maybe you’d have DetailsViewMobileImpl, for instance, but that’s not a technique that I’ve personally found useful. However, allowing multiple implementations of the View also allows testing of your Activity by mocking the View, letting you test logic without having to test UI behaviour at the same time.
Again, you can see that you have to implement lots of repetitive boilerplate code and you might wonder why you need to bother.
GWTP: Presenters/Views/Places
GWTP uses Presenters rather than Activities, but they are much the same thing: code that tells your UI View what to do without telling the UI View how to do it. But GWTP requires less repetitive code, by using dependency injection with GIN (GUICE for GWT) to tie the pieces together.
If you are returning to Java after some time away then Dependency Injection is your Tirimasu. This Google I/O 2009: Big Modular Java with GUICE talk seems to be an excellent introduction to dependency injection in general, and dependency injection with GUICE.
For instance, this lets us add a parameter to a constructor, and as long as the constructor has the @Inject annotation, and as long as we’ve told GIN (or GUICE) what implementation types to use, GIN (or GUICE) can end up calling that constructor with an appropriate instance for the parameter.
Place
WIth GWTP, you don’t need to implement any actual Place classes. Instead, you just use the @NameToken annotation on your Presenter’s proxy (declared via the @ProxyStandard annotation). For instance, in murrayc-gwtp-appengine-example’s ThingPresenter:
@ProxyStandard @NameToken(NameTokens.THING) interface MyProxy extends ProxyPlace { }
That NameTokens.THING is just a string constant that I’ve put together with the others.
Presenter
Your Presenter should derive from GWTP’s Presenter, which is a generic class that takes your View interface and your Proxy interface.
For instance in murrayc-gwtp-appengine-example’s ThingPresenter:
public class ThingPresenter extends Presenter<ThingPresenter.MyView, ThingPresenter.MyProxy>
The presenters’s prepareFromRequest() override uses simple getParameter() calls to get the URL’s parameters, without the need for a separate Place class and manual string parsing. For instance, in ThingPresenter’s prepareFromRequest():
@Override public void prepareFromRequest(final PlaceRequest request) { super.prepareFromRequest(request); final String thingId = request.getParameter(NameTokens.THING_PARAM_THING_ID, null);
View
Your View should extend GWTP’s ViewImpl and implement your Presenter’s View interface. For instance:
public class ThingView extends ViewImpl implements ThingPresenter.MyView
However, you will very often want to derive instead from GWTP’s ViewWithUiHandlers, specifying a small UiHandlers interface you’ve created, so your View can notify its presenter about user interaction. For instance, in murrayc-gwtp-appengine-example’s ThingView:
public class ThingView extends ViewWithUiHandlers<ThingUserEditUiHandlers> implements ThingPresenter.MyView {
That ThingUserEditUiHandler should also be implemented by the presenter. For instance, in ThingPresenter:
public class ThingPresenter extends Presenter<ThingPresenter.MyView, ThingPresenter.MyProxy> implements ThingUserEditUiHandlers {
And your presenters’s View interface should extend HasUiHandlers. For instance, in ThingPresenter:
interface MyView extends View, HasUiHandlers<ThingUserEditUiHandlers> {
The View can then indirectly call a method on the presenter like so:
getUiHandlers().onThingChosen("blah");
However, you must first call your view’s setUIHandler() from your presenters constructor, like so:
getView().setUiHandlers(this);
Modules
Each Presenter/View should have a Module. For instance, murrayc-gwtp-appengine-example’s ThingModule links the presenter and view together like so:
public class ThingModule extends AbstractPresenterModule { @Override protected void configure() { bindPresenter(ThingPresenter.class, ThingPresenter.MyView.class, ThingView.class, ThingPresenter.MyProxy.class); } }
These sub-modules would then be combined in one module for the whole application. For instance:
public class ApplicationModule extends AbstractPresenterModule @Override protected void configure() { install(new ThingModule()); install(new UserProfileModule());
This is where you can control the dependency injection. By providing a different ApplicationModule or different sub-modules, you can cause different implementations to be instantiated. For instance, to create mock Views.
Events: Communication Between Presenters
You application might have several nested presenters on a page, so one presenter might need to respond to a change to another presenter. GWTP lets us do this by defining our own GwtEvent. For instance, murrayc-gwtp-appengine-example’s ThingUserAddedEvent:
public class ThingUserAnswerAddedEvent
extends GwtEvent<ThingUserAnswerAddedEvent.EventHandler> {
One presenter may then fire that event, by calling its fire() method, providing any parameters needed by the event.
A presenter may handle the event by implementing your event’s EventHandler interface. For instance, in murrayc-gwtp-appengine-example’s UserHistoryRecentPresenter:
public class UserHistoryRecentPresenter extends PresenterWidget<UserHistoryRecentPresenter.MyView> implements ThingUserAnswerAddedEvent.EventHandler {
And then registering the presenter as a handler for the event, with GWTP’s addRegisteredHandler(). For instance in UserHistoryRecentPresenter’s constructor:
addRegisteredHandler(ThingUserAnswerAddedEvent.TYPE, this);
You must also use GWTP’s @ProxyEvent annotation (see this too) on the handler method:
@ProxyEvent @Override public void onThingUserAnswerAdded(final ThingUserAnswerAddedEvent event) {
What about WidgetPresenters and their UiHandlers? Can You extend Your post?
What do you mean by “WidgetPresenters”. Do you mean “PresenterWidget”? A presenter that extends Presenter or PresenterWidget can implement your UIHandlers interface just like the example here. I don’t think that is affected by whether you use a PresenterWidget or a Presenter.
For instance: https://github.com/murraycu/murrayc-gwtp-appengine-example/blob/master/src/main/java/com/murrayc/murraycgwtpexample/client/application/menu/MenuPresenter.java#L36