Question

So I have a class with three fields that maps to a table using hibernate

Class Widget
{
     String field1;
     String field2;
     String field3;
}

On application startup a number of instances these widgets will be added to the database from an external files, but when I exit the application I need to know which (if any) of these fields have been changed by the user since the application was started, so the changes can be saved back to the files. I also need to store the original value for logging purposes.

I can’t work whether I need a status field in the table or whether there is already a way of doing this using Hibernate/Database.

EDIT:A good solution to the program was given below . however the main reason I am using Hibernate is to reduce memory consumption so storing the original values when changed is not a good solution for me , I want everthing stored in the database. So I have create this new question How do I store a copy of each entity I add to database in Hibernate

Answer 1

Given an entity like the following you can track changes on one of it’s field (while preserving its original value too).

@Entity
@Table(schema = "test", name = "test")
public final class Test {

  private static final int ORIGINAL = 0;
  private static final int CURRENT = 1;

  private Integer id;

  // holds the original and current state of the field
  private final AtomicReferenceArray<String> field = new AtomicReferenceArray<>(2);

  @Id
  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  @Transient
  public String getOriginalField() {
    return field.get(ORIGINAL);
  }

  @Basic
  public String getField() {
    return field.get(CURRENT);
  }

  public void setField(String field) {
    this.field.compareAndSet(ORIGINAL, null, field);
    this.field.set(CURRENT, field);
  }

  @PreUpdate
  public void preUpdate() {
    System.out.format("Original: %s, New: %s\n", getOriginalField(), getField());
  }

  ...

}

If there is a single row in a database like this:

     id: 1
  field: a
version: 2011-12-02 11:24:00

before the field gets updated (say, from a to b) you’ll get the following output.

Original: d, New: b

The original value gets preserved even if the the entity is updated multiple times and both state can be accessed through the corresponding getters (getField and getOriginalField—you can get more creative than me in the naming :).

This way, you can spare yourself from creating version columns in your database and also can hide the implementation details from clients.

Instead of an AtomicReferenceArray you could use arrays, lists, etc, to track all changes like this way.

The @PreUpdate isn’t necessary of course, but this way you can be notified of changes in the entity’s state and atomically save the updated fields into file. There more annotations like these: see the documentation for javax.persistence for other annotation types.