Detecting changes in an object

Question

I have a relatively simple 3 tier application. Swing client, business logic with JDBC calls to fetch and save data on the server side. My data layer is simply comprised of JDBC calls which I use to populate JavaBeans, which are then returned to the client.
I want an easy way to be able to tell if the object has been changed, regardless of where it is at (client, business logic, etc). If I have a Person object, I want to be able to call person.hasDataChanged(), or something like that.
At first, I simply kept a dirty flag on the object. I then set this dirty flag to TRUE whenever one of the SET methods is called with data which differs from the current value. This works, and is fairly simple. By only setting the flag for set calls that use different data, I can map data to and from window objects without flipping the flag when I don't want to. The only problem with this is that it's possible to change the data from A to B, then set it back to A. At this point my object hasn't really chagned, but the dirty flag says otherwise.
So I thought of storing a copy of the old object within the object itself, but that seems like I'm passing around more data than I need to. Every object is twice as big as it needs to be.
I then tried to create a hash value when the object is retrieved from the database based upon the combined attributes of the object. The hasDataChanged() method creates a new hash value based upon the current data, compares with the old hash value, and returns the results. This doesn't work though, as there is no guarantee that hash values will be unique. It's possible to have data change and not have it be picked up.
So I now have a long string which I create when the object is first created. It is simply a concatonation of each object attributed. The hasDataChanged() method creates a new value string, compares to the old value string, and returns to the result.
Am I missing an obvious solution? Should I stick with the original approach of flipping a flag on the setter, even though it may be incorrect in instances where data is changed multiple times?
Thanks.

Answer 1

In my, opinion, you may be overcomplicating the issue
a little. If an attribute changes and is then changed
back, does it really matter if the object is no longer
differnt from the original. A simple 'dirty' flag is
usually goos enough for most systems.I suppose the worst that could happen is that I update a record in the database with the exact same data. Not the end of the wolrd I suppose. Still, if there was an easy wa to get it right, I would like to do so.
Having said that, If you absolutely must know
if it is different from the persistent version of the
object, you could place your persited data into a
contained object, something like a memento. Then ,
when a change is made, a comparison is made between
the current state and the stored memento. This would
have a higher memory and processing overhead, though.Yeah, I figured that was likely going to be the case. The downside is that the object is heavier; although it may be that it really doesn't matter.
Actually, all of these would require me to figure out when to take the snapshot of the object. They are JavaBeans, so I create them with an empty constructor, and then call setter methods to set the values on the object from a database result set. So I need a way to tel the object, "Ok, any data change after this means you've been altered". I hadn't thought that through all the way.
-Dave