如何强制Hibernate将日期作为java.util.Date而不是Timestamp返回？

Question

情况:

我有一个带有java.util.Date类型变量的persistable类:

import java.util.Date;

@Entity
@Table(name = "prd_period")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Period extends ManagedEntity implements Interval {

   @Column(name = "startdate_", nullable = false)
   private Date startDate;

}

DB中的对应表:

CREATE TABLE 'prd_period' (
  'id_' bigint(20) NOT NULL AUTO_INCREMENT,
 ...
  'startdate_' datetime NOT NULL
)

然后我将Period对象保存到DB:

Period p = new Period();
Date d = new Date();
p.setStartDate();
myDao.save(p);

在那之后如果我试图从DB中提取我的对象,它将返回时间戳类型的变量startDate - 并且我尝试使用的所有地方等于(...)返回false.

问题:有没有办法强制Hibernate将日期作为java.util.Date类型的对象而不是Timestamp返回而不对每个这样的变量进行显式修改(例如,它必须能够正常工作,而不需要对java.util的现有变量进行显式修改.日期类型)？

注意:

我找到了许多显式解决方案,其中使用了注释或修改了setter - 但我有许多带有Date变量的类 - 所以我需要一些集中式解决方案,下面描述的所有内容都不够好:

1. 使用注释@Type: - 将返回java.sql.Date

   @Column
   @Type(type="date")
   private Date startDate;
   

2. 使用注释@Temporal(TemporalType.DATE) - 将返回java.sql.Date

   @Temporal(TemporalType.DATE)
   @Column(name=”CREATION_DATE”)
   private Date startDate;
   

3. 通过修改setter(深层复制) - 将返回java.util.Date

   public void setStartDate(Date startDate) {
       if (startDate != null) {
           this.startDate = new Date(startDate.getTime());
       } else {
           this.startDate = null;
       }
   }
   

4. 通过创建我自己的类型: - 将返回java.util.Date

详情请见:http: //blogs.sourceallies.com/2012/02/hibernate-date-vs-timestamp/

Answer 1

所以,我花了一些时间来解决这个问题并找到了解决方案.它不是一个漂亮的,但至少是一个起点 - 也许有人会补充一些有用的评论.

有关我在进程中找到的映射的一些信息:

• 包含Hibernate类型到属性类型的基本映射的类是org.hibernate.type.TypeFactory.所有这些映射都存储在不可修改的映射中

  private static final Map BASIC_TYPES;
  ...
  basics.put( java.util.Date.class.getName(), Hibernate.TIMESTAMP );
  ...
  BASIC_TYPES = Collections.unmodifiableMap( basics );
  

正如您所见,java.util.Date类型与Hibernate类型相关联org.hibernate.type.TimestampType

• 下一个有趣的时刻 - 创建Hibernate org.hibernate.cfg.Configuration - 包含有关映射类的所有信息的对象.可以像这样提取这些类及其属性:

  Iterator clsMappings = cfg.getClassMappings();
  while(clsMappings.hasNext()){
      PersistentClass mapping = (PersistentClass) clsMappings.next();
      handleProperties(mapping.getPropertyIterator(), map);
  }
  

• 绝大多数属性是org.hibernate.mapping.SimpleValue类型的对象.我们感兴趣的是SimpleValue.getType()方法 - 在此方法中定义了在使用DB时将使用哪种类型来回转换属性值

  Type result = TypeFactory.heuristicType(typeName, typeParameters);
  

此时我明白我无法修改BASIC_TYPES - 所以唯一的方法 - 将SimpleValue对象替换为java.util.Date类型的属性到我的自定义对象,它将能够知道要转换的确切类型.

解决方案:

• 通过扩展HibernatePersistence类并重写其方法createContainerEntityManagerFactory来创建自定义容器实体管理器工厂:

  public class HibernatePersistenceExtensions extends HibernatePersistence {
  
      @Override
      public EntityManagerFactory createContainerEntityManagerFactory(PersistenceUnitInfo info, Map map) {
  
          if ("true".equals(map.get("hibernate.use.custom.entity.manager.factory"))) {
              return CustomeEntityManagerFactoryFactory.createCustomEntityManagerFactory(info, map);
          } else {
              return super.createContainerEntityManagerFactory(info, map);
          }
      }
  }
  

• 创建Hibernate配置对象,修改java.util.Date属性的值ojects,然后创建自定义实体管理器工厂.

  public class ReattachingEntityManagerFactoryFactory {
  
  
      @SuppressWarnings("rawtypes")
      public static EntityManagerFactory createContainerEntityManagerFactory(
      PersistenceUnitInfo info, Map map) {
          Ejb3Configuration cfg = new Ejb3Configuration();
  
          Ejb3Configuration configured = cfg.configure( info, map );
  
          handleClassMappings(cfg, map);
  
          return configured != null ? configured.buildEntityManagerFactory() : null;
      }
  
      @SuppressWarnings("rawtypes")
      private static void handleClassMappings(Ejb3Configuration cfg, Map map) {
          Iterator clsMappings = cfg.getClassMappings();
          while(clsMappings.hasNext()){
               PersistentClass mapping = (PersistentClass) clsMappings.next();
               handleProperties(mapping.getPropertyIterator(), map);
          }
      } 
  
  
  
      private static void handleProperties(Iterator props, Map map) {
  
          while(props.hasNext()){
               Property prop = (Property) props.next();
               Value value = prop.getValue();
               if (value instanceof Component) {
                   Component c = (Component) value;
                   handleProperties(c.getPropertyIterator(), map);
               } else {
  
                   handleReturnUtilDateInsteadOfTimestamp(prop, map);
  
               }
           }
  
      private static void handleReturnUtilDateInsteadOfTimestamp(Property prop, Map map) {
          if ("true".equals(map.get("hibernate.return.date.instead.of.timestamp"))) {
              Value value = prop.getValue();
  
              if (value instanceof SimpleValue) {
                  SimpleValue simpleValue = (SimpleValue) value;
                  String typeName = simpleValue.getTypeName();
                  if ("java.util.Date".equals(typeName)) {
                      UtilDateSimpleValue udsv = new UtilDateSimpleValue(simpleValue);
                      prop.setValue(udsv);
                  }
              }
          }
      }
  
  }
  

正如您所看到的,我只是遍历每个属性,并将UtilDateSimpleValue的SimpleValue-object替换为java.util.Date类型的属性.这是一个非常简单的类 - 它实现了与SimpleValue对象相同的接口,例如org.hibernate.mapping.KeyValue.在构造函数中传递原始的SimpleValue对象 - 因此每次调用UtilDateSimpleValue都会被重定向到原始对象,但有一个例外 - 方法getType(...)返回我的自定义类型.

public class UtilDateSimpleValue implements KeyValue{

    private SimpleValue value;

    public UtilDateSimpleValue(SimpleValue value) {
        this.value = value;
    }

    public SimpleValue getValue() {
        return value;
    }

    @Override
    public int getColumnSpan() {
        return value.getColumnSpan();
    }

    ...

    @Override
    public Type getType() throws MappingException {
        final String typeName = value.getTypeName();

        if (typeName == null) {
                throw new MappingException("No type name");
        }

        Type result = new UtilDateUserType();

        return result;
    }
    ...
}

• 最后一步是UtilDateUserType的实现.我只是扩展原始的org.hibernate.type.TimestampType并覆盖它的方法get(),如下所示:

  public class UtilDateUserType extends TimestampType{
  
      @Override
      public Object get(ResultSet rs, String name) throws SQLException {
          Timestamp ts = rs.getTimestamp(name);
  
          Date result = null;
          if(ts != null){
              result = new Date(ts.getTime());
          }
  
          return result;
      }
  }
  

就这些.有点棘手,但现在每个java.util.Date属性都作为java.util.Date返回,而不对现有代码(注释或修改setter)进行任何其他修改.正如我在Hibernate 4或更高版本中发现的那样,有一种更简单的方法来替换你自己的类型(详见这里:Hibernate TypeResolver).欢迎任何建议或批评.

Answer 2

使用自定义UserType的一个简单替代方法是在setter中为持久化bean中的date属性构造一个新的java.util.Date,例如:

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.Column;

@Entity
public class Purchase {

    private Date date;

    @Column
    public Date getDate() {
        return this.date;
    }

    public void setDate(Date date) {
        // force java.sql.Timestamp to be set as a java.util.Date
        this.date = new Date(date.getTime());
    }

}

Answer 3

方法1和2显然不起作用,因为java.sql.Date根据JPA/Hibernate规范获取对象,而不是java.util.Date.从方法3和方法4开始,我宁愿选择后者,因为它更具说明性,并且可以同时使用字段和getter注释.

您已经在引用的博客文章中列出了解决方案4,因为@tscho非常友好地指出.也许defaultForType(见下文)应该为您提供您正在寻找的集中式解决方案.当然,仍然需要区分日期(没有时间)和时间戳字段.

为了将来参考,我将在此处留下使用您自己的Hibernate UserType的摘要:

要使Hibernate为您提供java.util.Date实例,可以使用@Type和@TypeDef注释来定义java.util.Date java类型与数据库的不同映射.

请参阅此处核心参考手册中的示例.

1. 实现UserType来执行实际的管道(转换为/从java.util.Date转换),例如命名TimestampAsJavaUtilDateType

2. 在一个实体或package-info.java中添加@TypeDef注释 - 两者都将在会话工厂中全局可用(请参阅上面的手动链接).您可以使用defaultForType在类型的所有映射字段上应用类型转换java.util.Date.

   @TypeDef
     name = "timestampAsJavaUtilDate",
     defaultForType = java.util.Date.class, /* applied globally */
     typeClass = TimestampAsJavaUtilDateType.class
   )
   

3. (可选)defaultForType您可以单独使用@Type注释字段/ getter ,而不是:

   @Entity
   public class MyEntity {
      [...]
      @Type(type="timestampAsJavaUtilDate")
      private java.util.Date myDate;
      [...]
   }
   

PS建议一个完全不同的方法:我们通常只是不使用equals()来比较Date对象.相反,我们使用带有方法的实用程序类来比较两个Date实例的日历日期(或其他分辨率,如秒),而不管确切的实现类型.这对我们来说效果很好.