时间戳

首页 > 解决方案 > 如何用观察者模式观察同一类型的不同属性？

java - 如何用观察者模式观察同一类型的不同属性？

问题描述

我在 MVC 应用程序中实现了观察者模式，因此 bean 可以监听模型中的变化。由于我使用的是 Java8，因此我使用的是 Java.util 中的 Observer 和 Observable。这是我编码的部分内容：

import java.util.Observable;
import java.util.Observer;

public class UserBean implements Observer{
   private Integer userId;
   private String userName;
   private String userEmail;
   /* getters and setters */
  
   @Override
   public void update(Observable o, Object object) {
       if(object instanceof Integer)
           setUserId((Integer)object);
       else if(object instanceof String)
           setUserName((String)object);
   }
}

public class UserModel extends Observable {

    private Integer id;
    private String name;
    private String email;
    /* getters */
    public void setId(Integer id){
        this.id = id;
        setChanged();
        notifyObservers(id);
    }

    public void setName(String name){
        this.name = name;
        setChanged();
        notifyObservers(name);
    }

    public void setEmail(String email){
        this.name = email;
        // how can i listen for this change?
        /*setChanged();
        notifyObservers(email);*/
    }
}

我认为实现是正确的，因为在我进行的一个简单测试中，bean 类正确读取了对 Id 和 Names 的更改，但我意识到我无法监听电子邮件属性的更改，因为在 bean 类中我正在使用“instanceof”来了解我必须更新哪个值。

有一种方法可以识别哪个变量发生了变化？我应该实现自己版本的 Observer 和 Observable 类，而不是使用 Java.Util？我认为使用第二种解决方案，我可以为每个属性定义一个更新方法，但我不知道如何在 Java 中管理同步过程。

标签： javaobserver-pattern

解决方案

该update方法中的第一个参数是一个Observable. 那是您的UserModel对象已更改，因此它包含所有更新的数据。因此，您可以使用它来传递已更改的对象的名称，而不是使用第二个参数来传递对象的新值（或使用 an ，因为它更简洁一些）。enum

解决方案可能如下所示：

用户豆：

import java.util.Observable;
import java.util.Observer;

import observer.UserModel.ChangedValue;

public class UserBean implements Observer {
    
    private Integer userId;
    private String userName;
    private String userEmail;
    /* getters and setters */
    
    @Override
    public void update(Observable o, Object object) {
        if (o instanceof UserModel && object instanceof ChangedValue) {
            UserModel userModel = (UserModel) o;
            ChangedValue changed = (ChangedValue) object;
            
            switch (changed) {
                case EMAIL:
                    setEmail(userModel.getEmail());
                    break;
                case ID:
                    setUserId(userModel.getId());
                    break;
                case NAME:
                    setUserName(userModel.getName());
                    break;
                default:
                    throw new IllegalStateException("Unexpected ChangedValue type: " + changed);
                
            }
        }
    }
    
    //...
}

用户模型：

import java.util.Observable;

public class UserModel extends Observable {
    
    public enum ChangedValue {
        ID, //
        NAME, //
        EMAIL, //
        //...
    }
    
    private Integer id;
    private String name;
    private String email;
    
    //...
    
    public void setId(Integer id) {
        this.id = id;
        setChanged();
        notifyObservers(ChangedValue.ID);//use the enum types as parameters here
    }
    
    public void setName(String name) {
        this.name = name;
        setChanged();
        notifyObservers(ChangedValue.NAME);
    }
    
    public void setEmail(String email) {
        this.name = email;
        setChanged();
        notifyObservers(ChangedValue.EMAIL);
    }
}

注意：就像评论中提到的那样，通用方法会更好，以避免对象强制转换。它可以与此实现类似地使用。只需添加一些通用参数，但想法保持不变。

推荐阅读