Question

I have a problem with Observer pattern.

First, I have a HttpHelper class to get data from server, I used it as Observerable.

 public class HttpHelper extends Observable,Runnable{
    public void run(){
      //do long task to get data
      String result = getData();
      setChanged();
      notifyObservers(result);
   }
 } 

The DataManager class get data from HttpHerlper when completed, then do some business task.

public class DataManager implements Observer {
    public void doTask(){
    HttpHelper helper = new HttpHelper();
    helper.addObserver(this); 
    Thread thread = new Thread(helper);
    thread.start();
    }
    public void update(Observable obj, Object data) {
       if (data instanceof String) {
         // do some stuff with this data
         // Then I want to notify the result to the view
         Model model = doSomething(data);
         notify(model)
       }
    }
}

Finaaly, View class will update data when DataManager complete task.

  public class View{
       private void getData(){
           DataManager manager = new DataManager()
           manager.doTask();
       }
       public void update(Observable obj, Object data) {

       }
 }

Should I use Observer again? And how can I do that?
P/s: for some reason, HttpHelper and DataManager must be separated.

Update: Here is the class structure
https://www.dropbox.com/s/givn6vzvqr4cgye/bkd.png

Answer 1

IMO, the relationship between HttpHelper and DataManager doesn’t need an observer pattern. It seems to be just a callback to notify the manager that the processing is done. Observers are better suited for dispatching events to multiple, different listeners via a common interface, not to a single listener. Having said that, what you have will work. Check this article on implementing callbacks if you want to follow my advice

Now, for the relationship between the manager and the view i do agree that you should use an observer pattern, this will allow you to create different views that react differently to the same events. This means that it’s DataManager that should extend Observable, and every view listening it should implement Observer

Finally, i have to say that if you plan on having different types of events, the JDK observable and observer (java.util) mechanism is not very clean. My biggest criticism is that the second argument of update is an Object, so you end up with a huge list of if else where you need to check instanceof like in your example, which in general is not good practice. An alternative is to use the event notification mechanism from the UI classes (like EventObject and EventListener) , they are part of the UI classes but are really more generic than just UIs. see this other question

Oh and if you can, try to avoid cascading events. It makes code hard to read and debug. Maybe the view could observe directly the HttpHelper??