Java World Knowledge Sharing Portal: Simple GWT MVP Pattern Example

Let try to build GWT MVP Pattern example. This will ask user to enter two number and in return will give addition of this two number.

Eclipse View of GWT MVP Project

This are the code of the files :-

SiddhuMVPExample.html

SiddhuMVPExample.gwt.xml

HelloViewImpl.ui.xml

HelloView

package com.test.client.ui;

import com.google.gwt.place.shared.Place;

import com.google.gwt.user.client.ui.IsWidget;

public interface HelloView extends IsWidget

{

String getFirstNumber();

String getSecondNumber();

void setAnswer(String answer);

void setPresenter(Presenter listener);

public interface Presenter

{

void goTo(Place place);

void buttonAddClicked();

}

HelloViewImpl

package com.test.client.ui;

import com.google.gwt.core.client.GWT;

import com.google.gwt.event.dom.client.ClickEvent;

import com.google.gwt.uibinder.client.UiBinder;

import com.google.gwt.uibinder.client.UiField;

import com.google.gwt.uibinder.client.UiHandler;

import com.google.gwt.user.client.ui.Composite;

import com.google.gwt.user.client.ui.TextBox;

import com.google.gwt.user.client.ui.Widget;

public class HelloViewImpl extends Composite implements HelloView

{

private static HelloViewImplUiBinder uiBinder = GWT.create(HelloViewImplUiBinder.class);

interface HelloViewImplUiBinder extends UiBinder

{

}

@UiField TextBox FirstNumber;

@UiField TextBox SecondNumber;

@UiField TextBox Answer;

private Presenter listener;

public HelloViewImpl()

{

initWidget(uiBinder.createAndBindUi(this));

}

@Override

public void setPresenter(Presenter listener)

{

this.listener = listener;

}

@Override

public String getFirstNumber() {

return FirstNumber.getText();

}

@Override

public String getSecondNumber() {

return SecondNumber.getText();

}

@Override

public void setAnswer(String answer) {

Answer.setText(answer);

}

@UiHandler("buttonAdd")

void buttonAddClicked(ClickEvent e)

{

listener.buttonAddClicked();

}

HelloPlace

package com.test.client.place;

import com.google.gwt.place.shared.Place;

import com.google.gwt.place.shared.PlaceTokenizer;

public class HelloPlace extends Place

{

private String firstNumber;

private String secondNumber;

private String answer;

private String helloName;

public String getFirstNumber() {

return firstNumber;

}

public void setFirstNumber(String firstNumber) {

this.firstNumber = firstNumber;

}

public String getSecondNumber() {

return secondNumber;

}

public void setSecondNumber(String secondNumber) {

this.secondNumber = secondNumber;

}

public String getAnswer() {

return answer;

}

public void setAnswer(String answer) {

this.answer = answer;

}

public HelloPlace(String token)

{

this.helloName = token;

}

public String getHelloName()

{

return helloName;

}

public static class Tokenizer implements PlaceTokenizer

{

@Override

public String getToken(HelloPlace place)

{

return place.getHelloName();

}

@Override

public HelloPlace getPlace(String token)

{

return new HelloPlace(token);

}

AppActivityMapper

package com.test.client.mvp;

import com.google.gwt.activity.shared.Activity;

import com.google.gwt.activity.shared.ActivityMapper;

import com.google.gwt.place.shared.Place;

import com.test.client.ClientFactory;

import com.test.client.activity.HelloActivity;

import com.test.client.place.HelloPlace;

public class AppActivityMapper implements ActivityMapper {

private ClientFactory clientFactory;

/**

* AppActivityMapper associates each Place with its corresponding

* {@link Activity}

* @param clientFactory

* Factory to be passed to activities

public AppActivityMapper(ClientFactory clientFactory) {

super();

this.clientFactory = clientFactory;

}

/**

* Map each Place to its corresponding Activity. This would be a great use

* for GIN.

@Override

public Activity getActivity(Place place) {

// This is begging for GIN

if (place instanceof HelloPlace)

return new HelloActivity((HelloPlace) place, clientFactory);

else

return null;

}

AppPlaceHistoryMapper

package com.test.client.mvp;

import com.google.gwt.place.shared.PlaceHistoryMapper;

import com.google.gwt.place.shared.WithTokenizers;

import com.test.client.place.HelloPlace;

/**

* PlaceHistoryMapper interface is used to attach all places which the

* PlaceHistoryHandler should be aware of. This is done via the @WithTokenizers

* annotation or by extending PlaceHistoryMapperWithFactory and creating a

* separate TokenizerFactory.

@WithTokenizers( { HelloPlace.Tokenizer.class })

public interface AppPlaceHistoryMapper extends PlaceHistoryMapper {

}

HelloActivity

package com.test.client.activity;

import com.google.gwt.activity.shared.AbstractActivity;

import com.google.gwt.core.client.GWT;

import com.google.gwt.event.shared.EventBus;

import com.google.gwt.place.shared.Place;

import com.google.gwt.user.client.rpc.AsyncCallback;

import com.google.gwt.user.client.ui.AcceptsOneWidget;

import com.test.client.ClientFactory;

import com.test.client.GreetingService;

import com.test.client.GreetingServiceAsync;

import com.test.client.place.HelloPlace;

public class HelloActivity extends AbstractActivity implements com.test.client.ui.HelloView.Presenter {

// Used to obtain views, eventBus, placeController

// Alternatively, could be injected via GIN

private ClientFactory clientFactory;

// Name that will be appended to "Hello,"

//private String answer;

com.test.client.ui.HelloView helloView;

private final GreetingServiceAsync greetingService = GWT

.create(GreetingService.class);

public HelloActivity(HelloPlace place, ClientFactory clientFactory) {

//this.answer = place.getAnswer();

this.clientFactory = clientFactory;

}

/**

* Invoked by the ActivityManager to start a new Activity

@Override

public void start(AcceptsOneWidget containerWidget, EventBus eventBus) {

helloView = clientFactory.getHelloView();

helloView.setPresenter(this);

containerWidget.setWidget(helloView.asWidget());

}

/**

* Ask user before stopping this activity

@Override

public String mayStop() {

return "Please hold on. This activity is stopping.";

}

/**

* Navigate to a new Place in the browser

public void goTo(Place place) {

clientFactory.getPlaceController().goTo(place);

}

@Override

public void buttonAddClicked() {

String fnumber = helloView.getFirstNumber();

String snumber = helloView.getSecondNumber();

// to check if code is coming here we can add following below line and can check we are getting answer

// From here only our RPC call is remaining.

/*int answer = Integer.parseInt(fnumber) + Integer.parseInt(snumber);

helloView.setAnswer(""+answer);*/

greetingService.getAddValue(fnumber, snumber, new AsyncCallback() {

@Override

public void onSuccess(String result) {

helloView.setAnswer(result);

}

@Override

public void onFailure(Throwable caught) {

helloView.setAnswer(""+caught);

}

});

}

ClientFactory

package com.test.client;

import com.google.gwt.event.shared.EventBus;

import com.google.gwt.place.shared.PlaceController;

import com.test.client.ui.HelloView;

public interface ClientFactory

{

EventBus getEventBus();

PlaceController getPlaceController();

HelloView getHelloView();

}

ClientFactoryImpl

package com.test.client;

import com.google.gwt.event.shared.EventBus;

import com.google.gwt.event.shared.SimpleEventBus;

import com.google.gwt.place.shared.PlaceController;

import com.test.client.ui.HelloView;

import com.test.client.ui.HelloViewImpl;

public class ClientFactoryImpl implements ClientFactory

{

private static final EventBus eventBus = new SimpleEventBus();

private static final PlaceController placeController = new PlaceController(eventBus);

private static final HelloView helloView = new HelloViewImpl();

@Override

public EventBus getEventBus()

{

return eventBus;

}

@Override

public HelloView getHelloView()

{

return helloView;

}

@Override

public PlaceController getPlaceController()

{

return placeController;

}

GreetingService

package com.test.client;

import com.google.gwt.user.client.rpc.RemoteService;

import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

/**

* The client-side stub for the RPC service.

@RemoteServiceRelativePath("greet")

public interface GreetingService extends RemoteService {

String getAddValue(String firstNumber, String secondNumber) throws IllegalArgumentException;

}

GreetingServiceAsync

package com.test.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

/**

* The async counterpart of GreetingService.

public interface GreetingServiceAsync {

void getAddValue(String firstNumber, String secondNumber, AsyncCallback callback)

throws IllegalArgumentException;

}

SiddhuMVPExample

package com.test.client;

import com.google.gwt.activity.shared.ActivityManager;

import com.google.gwt.activity.shared.ActivityMapper;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.core.client.GWT;

import com.google.gwt.event.shared.EventBus;

import com.google.gwt.place.shared.Place;

import com.google.gwt.place.shared.PlaceController;

import com.google.gwt.place.shared.PlaceHistoryHandler;

import com.google.gwt.user.client.ui.RootPanel;

import com.google.gwt.user.client.ui.SimplePanel;

import com.test.client.mvp.AppActivityMapper;

import com.test.client.mvp.AppPlaceHistoryMapper;

import com.test.client.place.HelloPlace;

/**

* Entry point classes define onModuleLoad().

public class SiddhuMVPExample implements EntryPoint {

/**

* Create a remote service proxy to talk to the server-side Greeting service.

private final GreetingServiceAsync greetingService = GWT

.create(GreetingService.class);

private Place defaultPlace = new HelloPlace("World!");

private SimplePanel appWidget = new SimplePanel();

/**

* This is the entry point method.

public void onModuleLoad() {

// Create ClientFactory using deferred binding so we can replace with different

// impls in gwt.xml

ClientFactory clientFactory = GWT.create(ClientFactory.class);

EventBus eventBus = clientFactory.getEventBus();

PlaceController placeController = clientFactory.getPlaceController();

// Start ActivityManager for the main widget with our ActivityMapper

ActivityMapper activityMapper = new AppActivityMapper(clientFactory);

ActivityManager activityManager = new ActivityManager(activityMapper, eventBus);

activityManager.setDisplay(appWidget);

// Start PlaceHistoryHandler with our PlaceHistoryMapper

AppPlaceHistoryMapper historyMapper= GWT.create(AppPlaceHistoryMapper.class);

PlaceHistoryHandler historyHandler = new PlaceHistoryHandler(historyMapper);

historyHandler.register(placeController, eventBus, defaultPlace);

RootPanel.get().add(appWidget);

// Goes to place represented on URL or default place

historyHandler.handleCurrentHistory();

}

FieldVerifier

package com.test.shared;

/**

* FieldVerifier validates that the name the user enters is valid.

* This class is in the shared package because we use it in both

* the client code and on the server. On the client, we verify that the name is

* valid before sending an RPC request so the user doesn't have to wait for a

* network round trip to get feedback. On the server, we verify that the name is

* correct to ensure that the input is correct regardless of where the RPC

* originates.

* When creating a class that is used on both the client and the server, be sure

* that all code is translatable and does not use native JavaScript. Code that

* is not translatable (such as code that interacts with a database or the file

* system) cannot be compiled into client-side JavaScript. Code that uses native

* JavaScript (such as Widgets) cannot be run on the server.

public class FieldVerifier {

/**

* Verifies that the specified name is valid for our service.

* In this example, we only require that the name is at least four

* characters. In your application, you can use more complex checks to ensure

* that usernames, passwords, email addresses, URLs, and other fields have the

* proper syntax.

* @param name the name to validate

* @return true if valid, false if invalid

public static boolean isValidName(String name) {

if (name == null) {

return false;

}

return name.length() > 3;

}

package com.test.server;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.test.client.GreetingService;

/**
* The server side implementation of the RPC service.
*/
@SuppressWarnings("serial")
public class GreetingServiceImpl extends RemoteServiceServlet implements GreetingService {

public String getAddValue(String firstNumber, String secondNumber) throws IllegalArgumentException {
String result;
int i=Integer.parseInt(firstNumber)+ Integer.parseInt(secondNumber);
result=String.valueOf(i);
return result;
}
}