Mapping Dates and Time Zones with Hibernate, Part 2: Few Solutions

Go back to Part 1 of this article

In the first part of this article I was talking about the problems when mapping date/time to a database table using Hibernate. In part two I will talk about the solutions.

The quick Way: Use Property Access Type and implement the Setter

Tell Hibernate to use setter and getter methods for field access, instead of using reflection to modify the entity object's fields directly. To do so, you have to put the Hibernate annotations above the getter methods, instead of the class attributes. You MUST move the annotation of the @Id field to the getter to enable property access. But you should do it with all field annotations, for better clarity. You can find a more detailed discussion of Hibernate property access here and here.
Once you did so, you can implement a setter method for the calendar field, which takes the calendar object provided by Hibernate, and creates a new object with the right time zone and date information from it:

package entity; ... public class GMTDateEntity implements Serializable {         ...     private Integer pk;     private Calendar calendar;     @Id     @Column(name = "pk", nullable = false)     @GeneratedValue(strategy = GenerationType.IDENTITY)     public Integer getPk() {         return pk;     }     @Temporal(TemporalType.TIMESTAMP)     @Column(name = "calendartime")     public Calendar getCalendar() {          return calendar;     }     public void setCalendar(Calendar calendar) {          //create new calendar in GMT time zone         this.calendar = new GregorianCalendar(TimeZone.getTimeZone("GMT"));                 //set calendar fields         this.calendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));         this.calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH));         this.calendar.set(Calendar.DATE, calendar.get(Calendar.DATE));         this.calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY));         this.calendar.set(Calendar.MINUTE, calendar.get(Calendar.MINUTE));         this.calendar.set(Calendar.SECOND, calendar.get(Calendar.SECOND));         this.calendar.set(Calendar.MILLISECOND, calendar.get(Calendar.MILLISECOND));                 //recalculate calendar time millis         this.calendar.getTime();      }      ... }

Because the time zone information is the only thing that is wrong in Hibernate's calendar object, we simply create a new calendar object in the correct time zone, and then copy all required fields from Hibernate's object to our new object. The final call to getTime() will recalculate the calendars internal time milliseconds based on the field and time zone information. Unfortunately, the actual recalculation-methods are protected in java.util.Calendar for reasons I just don't know. So we have to use this less elegant workaround.

The elegant Way: Create a custom Hibernate User Type 

If for any reason you cannot use Hibernate property access, you will have to stick to the advanced art of programming and create a custom user type, which does the mapping from DB result set to Java object for you. Explanation of user type implementation would be beyond topic of this article. But you can find a very good introduction here. Just be aware, that you have to create a mutable user type, as java.util.Calendars are mutable objects.
To put everything short, here is the user type implementation that will serve our purpose:

package usertypes; import java.io.Serializable; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Types; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.TimeZone; import org.hibernate.Hibernate; import org.hibernate.HibernateException; import org.hibernate.usertype.UserType; public class GmtCalendarUserType implements UserType, Serializable {     private static final long serialVersionUID = 1L;        //The interesting methods:     @Override     public void nullSafeSet(PreparedStatement statement, Object value, int index)             throws HibernateException, SQLException {         // we have to be null-safe         if (value == null) {           Hibernate.CALENDAR.nullSafeSet(statement, null, index);            return;         }            // we have a Calendar here         Calendar cal = (Calendar) value;         // cut millis, as SQL Server uses only 1/300 precision         long millis = cal.getTimeInMillis();         millis = millis - (millis % 1000);         cal.setTimeInMillis(millis);         // simply delegate to hibernate's built in method         Hibernate.CALENDAR.nullSafeSet(statement, cal, index);     }     @Override     public Object nullSafeGet(ResultSet resultSet, String[] columnNames,             Object owner) throws HibernateException, SQLException {         // we cannot do it like this, because it would initialize the calendar         // in the jvm's default timezone:         // Calendar cal = (Calendar) Hibernate.CALENDAR.nullSafeGet(resultSet,         // columnNames);         // return cal;         // We have to create the Calendar object from the DB date string         String timeString = (String) Hibernate.STRING.nullSafeGet(resultSet,                 columnNames);         if (timeString == null)             return null;         try {             Date date = this.parseDbDateString(timeString);             // Init calendar in GMT             Calendar retValue = new GregorianCalendar(                     TimeZone.getTimeZone("GMT"));             retValue.setTime(date);             // calculate calendar fields             retValue.getTime();             return retValue;         } catch (ParseException e) {             throw new HibernateException("Could not parse datestring from DB.",                     e);         }     }     private Date parseDbDateString(String dateString) throws ParseException {         // create gmt time zone         TimeZone gmtZone = TimeZone.getTimeZone("GMT");         // create db date format (cut millis)         String pattern = "yyyy-MM-dd HH:mm:ss";         SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);         dateFormat.setTimeZone(gmtZone);         return dateFormat.parse(dateString);     }     //The other UserType methods:        @Override     public Object assemble(Serializable cached, Object owner)             throws HibernateException {         return this.deepCopy(cached);     }     @Override     public Object deepCopy(Object object) throws HibernateException {         if (object == null)             return null;         // we have a calendar here         Calendar cal = (Calendar) object;         return cal.clone();     }     @Override     public Serializable disassemble(Object value) throws HibernateException {         return (Serializable) this.deepCopy(value);     }     @Override     public boolean equals(Object object1, Object object2)             throws HibernateException {         if (object1 == object2) {             return true;         }         if ((object1 == null) || (object2 == null))             return false;         return object1.equals(object2);     }     @Override     public int hashCode(Object value) throws HibernateException {         return value.hashCode();     }     @Override     public boolean isMutable() {         // Calendar is mutable         return true;     }     @Override     public Object replace(Object original, Object target, Object owner)             throws HibernateException {         return this.deepCopy(original);     }     @Override     public Class returnedClass() {         return Calendar.class;     }     @Override     public int[] sqlTypes() {         return new int[] { Types.TIMESTAMP };     } }

The nullSafeSet method will inject our Java object into the SQL statement. As Hibernate handles Calendars correctly when persisting, you simply delegate this task to Hibernate here. But since I'm using MS SQL Server in this example, I have to deal with the different precisions of Java dates (1 millisecond prec.) and SQL Server datetime types (1/300 second prec.). I choose the simple way here and simply cut the millis.

The nullSafeGet method does a little more of tweaking. This is where the result set is mapped to our Java Calendar object. If we would use Hibernate's built in mapping here (as in the commented block in this method), we would get the Calendar with the JVM time zone set. So we have to treat the datetime from the SQL result set as a string, and parse the date in GMT from it and create a new GMT GregorianCalendar.

Once we've finished our UsertType, all we have to do is to annotate our GMTDateEntity object to use it:

package entity; ... @Entity @Table(name = "datetestgmt") //Declare the UserType on the class @TypeDef(name = "gmtCalendar", typeClass = GmtCalendarUserType.class) public class GMTDateEntity implements Serializable { ...          //Use the UserType on the attribute     @Type(type = "gmtCalendar")     @Column(name = "calendartime")     private Calendar calendar;   ... }

Go back to Part 1 of this article