// ok, stel dat je in de view zit waarbij je een client aan het toevoegen bent of aan het editen, en je klikt op 'Save':

public class EditClientPresenter implements Presenter {
	public interface Display {
		HasClickHandlers getSaveButton();
		...
	}
	public void bind() {
		this.display.getSaveButton().addClickHandler(new ClickHandler() {
			public void onClick(ClickEvent event) {
				doSave();
			}
		});
	private void doSave() {
		client.setFirstName(display.getFirstName().getValue());
		client.setLastName(display.getLastName().getValue());
		client.setEmailAddress(display.getEmailAddress().getValue());

		rpcService.updateClient(client, new AsyncCallback<Client>() {
			public void onSuccess(Client result) {
				eventBus.fireEvent(new ClientUpdatedEvent(result));
			}

			public void onFailure(Throwable caught) {
				Window.alert("Error updating client");
			}
		});
	}
}

// zo, en dan nu nog hoe die event wordt afgevangen (precies zoals wij hebben met onze ESB):
public class ClientUpdatedEvent extends GwtEvent<ClientUpdatedEventHandler> {
	public static Type<ClientUpdatedEventHandler> TYPE = new Type<ClientUpdatedEventHandler>();
	private final Client updatedClient;

	public ClientUpdatedEvent(Client updatedClient) {
		this.updatedClient = updatedClient;
	}

	public Client getUpdatedClient() {
		return updatedClient;
	}

	@Override
	public Type<ClientUpdatedEventHandler> getAssociatedType() {
		return TYPE;
	}

	@Override
	protected void dispatch(ClientUpdatedEventHandler handler) {
		handler.onClientUpdated(this);
	}
}
public interface ClientUpdatedEventHandler extends EventHandler {
	void onClientUpdated(ClientUpdatedEvent event);
}

// en hier wordt ie afgevangen:
public class AppController implements Presenter, ValueChangeHandler<String> {
	private void bind() {
		...
		eventBus.addHandler(ClientUpdatedEvent.TYPE,
				new ClientUpdatedEventHandler() {
					public void onClientUpdated(ClientUpdatedEvent event) {
						doClientUpdated();
					}
				});
	}
	private void doClientUpdated() {
		History.newItem(AppState.VIEW_CLIENTS.getToken());
	}
}

// maar dan nog die rpcService waarmee alles ook nog naar de server wordt gestuurd:
public interface ClientsServiceAsync {
	...
	public void updateClient(Client client, AsyncCallback<Client> callback);
}

// de daadwerkelijke server-side implementatie hiervan bijv.:
public class ClientsServiceImpl extends RemoteServiceServlet implements
		ClientsService {
	...
	public Client updateClient(Client client) {
		clients.remove(client.getId());
		clients.put(client.getId(), client);
		return client;
	}
}