Observable vs Custom Events

Question

Hi.
I'm creating a project that uses the MVC design pattern, and being eager to make sure I follow the best practices I have a couple of questions. When notifying a 'View' of changes to the 'Model' is it preferable to effect this notfication using the Observer/Observable pattern, or through a custom eventListener? I can understand that the Observer/Observable way of doing things allows the View to be completely independant of the Model. However if I were to use custom events and eventListeners it would certainly make things easier to read and implement (my model is quite a large beast, comprising of multiple sub-models), as I would be able to provide more information about the change with each notification.
Is the answer to this just personal preference, or is there a convention?
Thanks in advance.

Answer 1

EventListener is an example of the [Subject] Observer
pattern.
If you are using swing/awt then use EventListener, if
you wish to decouple your implementation from
swing/awt, then implement your own solution based on
the [Subject] Observer pattern.I disagree. Swing/awt have nothing to do with this. EventListener, EventObject, Observer, and Observable all belong to java.util. In theory you could do this without using any of these classes and making the event and listeners yourself without extending anything from java.util.
Observer and Observable is good for a one to one relationship. It is quick, easy to do, and you don't have a lot to worry about. Multiple Observers watching one Observable is also nice. It is when you start watching multiple Observable classes that things get messy. Observer has one method that all Observable classes call. You have to do a lot of checking to see which class the Observable is before you know how to handle it.
IMO the biggest disadvantage to Observer and Observable, is that something must extend Observable. This is bad if the class you want to observe extends something else. Instances of Observer and Observable are also bound tightly together.
Events and Listeners are not bound together. Typically once the event is processed, it is disposed unless you want to save it and use it over and over. When using multiple listeners and events, you would implement each listener (or make anonymous) and it would have its own methods for a specific event, and not one large update method that handles everything. The events would be constructed as needed, and passed to the listeners.
You are not limited to extend Event like you are with Observable. If you tried to handle an Observable the same way as an Event, you would have to register the Observable with the Observer, notify the Observer, then remove the Observable.
Event/Listener is awesome for multithreading. You could write a Thread and Queue to manage all of your events (Similar to the AWTEventQueue). A class could put an event into the queue to be processed at a later time (or right away) by another thread. The Observer/Observable relationship cannot support this easily.
The disadvantage is that you have to handle sending an event to each listener manually, where the Observer/Observable handles that on its own.
In summary, Observer/Observable is a slightly more limitted version of Event/Listener, but it handles notifying the Observer/Listener on its own.