CODEWITHSUNDEEP
eventsgwtevent-handling
Bhoot
Bhoot

Reputation: 1541

Seemingly redundant event and event handlers

I will explain with an example. My GWT project has a Company module, which lets a user add, edit, delete, select and list companies.

Of these, the add, edit and delete operations lands back the user on the CompanyList page. Thus, having three different events - CompanyAddedEvent, CompanyUpdatedEvent and CompanyDeletedEvent, and their respective event handlers - seems overkill to me, as there is absolutely not difference in their function.

Is it OK to let a single event manage the three operations? One alternative I think is to use some event like CompanyListInvokedEvent. However, somewhere I think its not appropriate, is the event actually is not the list being invoked, but a company being added/updated/deleted.

If it had been only a single module, I would have get the task done with three separate events. But other 10 such modules are facing this dilemma. It means 10x3 = 30 event classes along with their 30 respective handlers. The number is large enough for me to reconsider. What would be a good solution to this?

UPDATE -

@ColinAlworth's answer made me realize that I could easily use Generics instead of my stupid solution. The following code represents an event EntityUpdatedEvent, which would be raised whenever an entity is updated.

Event handler class -

public class EntityUpdatedEvent<T> extends GwtEvent<EntityUpdatedEventHandler<T>>{

    private Type<EntityUpdatedEventHandler<T>> type;
    private final String statusMessage;

    public EntityUpdatedEvent(Type<EntityUpdatedEventHandler<T>> type, String statusMessage) {
        this.statusMessage = statusMessage;
        this.type = type;
    }

    public String getStatusMessage() {
        return this.statusMessage;
    }

    @Override
    public com.google.gwt.event.shared.GwtEvent.Type<EntityUpdatedEventHandler<T>> getAssociatedType() {
        return this.type;
    }

    @Override
    protected void dispatch(EntityUpdatedEventHandler<T> handler) {
        handler.onEventRaised(this);
    }
}

Event handler interface -

public interface EntityUpdatedEventHandler<T> extends EventHandler {
    void onEventRaised(EntityUpdatedEvent<T> event);
}

Adding the handler to event bus - 

eventBus.addHandler(CompanyEventHandlerTypes.CompanyUpdated, new EntityUpdatedEventHandler<Company>() {

    @Override
    public void onEventRaised(EntityUpdatedEvent<Company> event) {
        History.newItem(CompanyToken.CompanyList.name());
        Presenter presenter = new CompanyListPresenter(serviceBundle, eventBus, new CompanyListView(), event.getStatusMessage());
        presenter.go(container);
    }
});

Likewise, I have two other Added and Deleted generic events, thus eliminating entire redundancy from my event-related codebase.

Are there any suggestions on this solution?

P.S. > This discussion provides more insight on this problem.

Upvotes: 2

Views: 343

Answers (1)

Colin Alworth
Colin Alworth

Reputation: 18331

To answer this question, let me first pose another way of thinking about this same kind of problem - instead of events, we'll just use methods.

In my tiered application, two modules communicate via an interface (notice that these methods are all void, so they are rather like events - the caller doesn't expect an answer back):

package com.acme.project;

public interface CompanyServiceInteface {
  public void addCompany(CompanyDto company) throws AcmeBusinessLogicException;

  public void updateCompany(CompanyDto company) throws AcmeBusinessLogicException;

  public void deleteCompany(CompanyDto company) throws AcmeBusinessLogicException;
}

This seems like overkill to me - why not just reduce the size of this API to one method, and add an enum argument to simplify this. This way, when I build an alternative implementation or need to mock this in my unit tests, I just have one method to build instead of three. This gets to be clearly overkill when I make the rest of my application - why not just ObjectServiceInterface.modify(Object someDto, OperationEnum invocation); to work for all 10 modules?

One answer is that you might want want to drastically modify the implementation of one but not the others - now that you've reduced this to just one method, all of this belongs inside that switch case. Another is that once simplified in this way, the inclination often to further simplify - perhaps to combine create and update into just one method. Once this is done, all callsites must make sure to fulfill all possible details of that method's contract instead of just the one specific one.

If the receivers of those events are simple and will remain so, there may be no good reason to not just have a single ModelModifiedEvent that clearly is generic enough for all possible use cases - perhaps just wrapping the ID to request that all client modules refresh their view of that object. If a future use case arises where only one kind of event is important, now the event must change, as must all sites that cause the event to be created so that they properly populate this new field.

Java shops typically don't use Java because it is the prettiest language, or because it is the easiest language to write or find developers for, but because it is relatively easy to maintain and refactor. When designing an API, it is important to consider future needs, but also to think about what it will take to modify the current API - your IDE almost certainly has a shortcut key to find all invocations of a particular method or constructor, allowing you to easily find all places where that is used and update them. So consider what other use cases you expect, and how easily the rest of the codebase can be udpated.

Finally, don't forget about generics - for my example above, I would probably make a DtoServiceInterface to simplify matters, so that I just declare the one interface with three methods, and implement it and refer to it as needed. In the same way, you can make one set of three GwtEvent types (with *Handler interfaces and possibly Has*Handlers as well), but keep them generic for all possible types. Consider com.google.gwt.event.logical.shared.SelectionEvent<T> as an example here - in your case you would probably want to make the model object type a parameter so that handlers can check which type of event they are dealing with (remember that generics are erased in Java), or source from one EventBus for each model type.

Upvotes: 4

Related Questions