Question

I’m trying to get my head around observer pattern, and conceptually – I get it, it seems REALLY beneficial for lots of stuff…

however… in all the examples and reading I’m doing – it seems all the examples use a “single” data point, and a single class to manage that data point, so of course if ‘x’ changes, notify some other (registered) class…

what does one do when there are multiple methods in a class that MAY change multiple data points? – are the “observers” supposed to register for a specific ‘method’ – or do you add an ‘onchange’ method –

Take for example a USER object, with some normal CRUD methods, ‘insert’, ‘update’, ‘delete’… each of those methods ‘changes’ the data.

if I have 2 observers – an ‘logging’ object, and a UI object ties to the username… clearly the logging object will want to know about ANY of the data changing while the UI object may only care about the username.

how does one handle these multiple data points – you would (hopefully) NOT write your code to update EACH data point separately – and register to ‘watch’ each !!! that’ would be ridiculous.

For arguments sake – assume the ‘attributes’ of user are 100 data points – (first,middle,last,dob,username,email,password,lastlogin,etc…) and an “updateUser” method fires – changing ONLY the lastlogin… does the ‘notification’ handle the conditional logic that decides NOT to alert the UI – or is the UI alerted (as it’s an observer of ‘user’ – and the UI object has a method to handle notification, and IT does the conditional logic to decide that ‘lastlogin’ doesn’t interest it.????

Answer 1

You don’t have to register your observers for every method. You can categorize your observers, for example:

 private Observer[] updateObservers;
 private Observer[] usernameUpdateObservers;

When an observer registers itself, it has to know what group to put itself in. Then your User class will notify the appropriate groups;

  public void setUsername(String username) {
    this.username = username;
    notify(updateObservers);
    notify(usernameUpdateObservers);
  }

  public void setEmail(String email) {
    this.email = email;
    notify(updateObservers);
  }

However, when you are observing every action of an object, a Proxy might be a better fit. I’ll give you a little java example (now there are ways to do this in java dynamically, but to illustrate the point, here’s the long version).

 public interface User {
   void setUsername(String username);
   void setEmail(String email);
 }

 public class LoggingUserProxy implements User {
   private User user;

   public LoggingUserProxy(User user) { this.user = user; }

   public void setUsername(String username) {
     user.setUsername(username);
     log("updated username to " + username);
   }

   public void setEmail(String email) {
     user.setEmail(email);
     log("updated emailto " + email);
   }

Now when I create my user, I wrap it in the proxy

   User user = new LoggingUserProxy(realUser);

The interface is unchanged and your User object is not polluted with all of the notify() calls.