Java 对象、更改字段侦听器、设计模式

Question

There is a class:

public class MyClass {
private String field1;
private String field2;
private String field3;
// getters, setters
}

Then we update some fields

MyClass myClass = new MyClass();
myClass.setField1("field1");
myClass.setField2(null);

How can I know which fields of MyClass were tried to be changed (invoked, in the example above field1 and field2)?
What is the best solution for that? Maybe some design-pattern?
One option is to create HashSet of changed fields for this object as an additional property and update it inside each setter but it does not seem nice.
Should it be something like Proxy object which will be intercept all method calls (ie setXXX()) (through Java reflection?) or anything else?

UPDATE
It seems that each setter should invoke some inner method what does not seem nice as I said. And I don't need to notify any other objects about changes. I would like to store all states in this object and have access to these changes later.
In details: if method setFieldX invoked then fieldX should be marked to be updated later
PS All fields have different names.
Any other solutions except reflection (I want to populate object via pure setter)?

Answer 1

If you want to implement using conventional design-pattern approach, I would recommend using Observer Pattern

Have a Listener for set field event of your class

public interface FieldListener {

    public void fieldValueChanged(String fieldName, Object newValue);
}

Make a class implement this listener (Observer)

public class SampleObserver implements FieldListener {

    @Override
    public void fieldValueChanged(String fieldName, Object newValue) {
        System.out.println(fieldName + " - got set with value - " + newValue);
    }

}

have a place-holder for your listeners in the Observable class (in your case MyClass ) and whenever the set method gets called, just fire the event.

public class MyClass {

    List<FieldListener> listeners = new ArrayList<FieldListener>(); // the placeholder for listeners

    private String field1;
    private String field2;

    /**
     * @param field1 the field1 to set
     */
    public void setField1(String field1) {
        fireEvent("field1", field1);
        this.field1 = field1;
    }
    /**
     * @param field2 the field2 to set
     */
    public void setField2(String field2) {
        fireEvent("field2", field2);
        this.field2 = field2;
    }

    public void addListener(FieldListener l) {
        if(l != null) listeners.add(l);
    }

    public void fireEvent(String fieldName, Object newValue) {
        for(FieldListener l : listeners) {
            l.fieldValueChanged(fieldName, newValue);
        }
    }

    public static void main(String [] args) {
        MyClass m = new MyClass();
        m.addListener(new SampleObserver());
        m.setField1("s");
        m.setField2("v");
    }

}

Answer 2

I think what you are searching the a java.bean.PropertyChangeListener which is the Observer-Pattern in Java.

Basically you add code to all setters to call the method in the PropertyChangeListener to inform all observers that the value is changed.

This is the normal Java way.

Answer 3

Sounds like you want the Observer / Observable pattern. Basically a state listener registers (observes) with the myClass object to receive a notification when something changes.

Answer 4

That's hard to say, because we don't know why you need to monitor the fields and what neds to be done with the changes.

One thing you could do is to add listeners to your object (Observer pattern), so that classes, interested in the changes, can get notified about it. This of course works only if you have access to the interested classes and can modify them accordingly.

If you have no access and anybody can call your methods, you might have to go via reflection. If you need a better answer, you must give more details.

Update

Since you only want to keep track of it internaly via setters, then you can simply put in your setter, whatever you need to keep track of the changes. One solution could be to create a separate class, which stores the changes. So whenever you do some update, you call the tracker class and tell it the information you want to keep track of, like old value, new value, timestamp, whatever.

Answer 5

I realize I am late to the party and that the other answers here are valid, but I wanted to offer an alternative that might be simpler for anyone else that comes looking.

My suggestion is to use Optional for your fields but not for your getters/setters. In this way anything that is not Optional.empty() has been changed/updated.

import java.util.Optional;

public class MyClass
{
    private Optional<String> field1 = Optional.empty();
    private Optional<String> field2 = Optional.empty();
    private Optional<String> field3 = Optional.empty();

    public String getField1()
    {
        return field1.orElse(null);
    }

    public void setField1(String value)
    {
        field1 = Optional.ofNullable(value);
    }

    public String getField2()
    {
        return field2.orElse(null);
    }

    public void setField2(String value)
    {
        field2 = Optional.ofNullable(value);
    }

    public String getField3()
    {
        return field3.orElse(null);
    }

    public void setField3(String value)
    {
        field3 = Optional.ofNullable(value);
    }
}