JSP开发中hibernate的映射枚举操作方法

来源:爱站网时间:2020-10-08编辑:网友分享
​​​​​​​hibernate是一个框架结构,其实使用hibernate通常不需要再编写SQL语言了,本文是爱站技术频道小编带给大家的JSP开发中hibernate的映射枚举操作方法,需要的朋友可以参考下文的介绍。

hibernate是一个框架结构,其实使用hibernate通常不需要再编写SQL语言了,本文是爱站技术频道小编带给大家的JSP开发中hibernate的映射枚举操作方法,需要的朋友可以参考下文的介绍。

JSP 中Hibernate实现映射枚举类型

问题:

Java BO类Gender是枚举类型,想在数据库中存成字符串格式,如何编写hbm.xml?

public enum Gender{  
 UNKNOWN("Unknown"),  
 MALE("Male"),  
 FEMALE("Female"); 
   
 private String key; 
 private Gender(final String key) { 
  this.key = key; 
 } 
 public getGender(String key) { 
  for (Gender gender : Gender.values()) { 
   if (key.euqals(gender.getKey())) 
    return gender;       
  } 
  throw new NoSuchElementException(key); 
 } 
} 

使用UserType:

public class GenderUserType implements UserType {  
 
  private static int[] typeList = { Types.VARCHAR};  
 
 /* 
  * Return the SQL type codes for the columns mapped by this type. 
  * The codes are defined on java.sql.Types. */ 
 /**设置和Gender类的sex属性对应的字段的SQL类型 */  
 public int[] sqlTypes() { 
   return typeList; 
 } 
 
 /*The class returned by nullSafeGet().*/ 
 /** 设置GenderUserType所映射的Java类:Gender类 */ 
 public Class returnedClass() { 
   return Gender.class;  
 }  
 
 /** 指明Gender类是不可变类 */  
 public boolean isMutable() { 
   return false; 
 } 
 
 /* 
 * Return a deep copy of the persistent state, stopping at entities and at 
 * collections. It is not necessary to copy immutable objects, or null 
 * values, in which case it is safe to simply return the argument. 
 */ 
 /** 返回Gender对象的快照,由于Gender类是不可变类, 因此直接将参数代表的Gender对象返回 */  
 public Object deepCopy(Object value) {  
  return (Gender)value;  
 }  
 
 /** 比较一个Gender对象是否和它的快照相同 */ 
 public boolean equals(Object x, Object y) { 
  //由于内存中只可能有两个静态常量Gender实例,  
  //因此可以直接按内存地址比较  
  return (x == y);  
 }  
 public int hashCode(Object x){  
   return x.hashCode();  
 }  
 
 /* 
 * Retrieve an instance of the mapped class from a JDBC resultset. Implementors 
 * should handle possibility of null values. 
 */ 
 /** 从JDBC ResultSet中读取key,然后返回相应的Gender实例 */ 
 public Object nullSafeGet(ResultSet rs, String[] names, Object owner) 
               throws HibernateException, SQLException{  
   //从ResultSet中读取key 
   String sex = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);  
   if (sex == null) { return null; }  
   //按照性别查找匹配的Gender实例  
   try {  
    return Gender.getGender(sex);  
   }catch (java.util.NoSuchElementException e) {  
    throw new HibernateException("Bad Gender value: " + sex, e);  
   }  
 } 
 
 /* 
 * Write an instance of the mapped class to a prepared statement. Implementors 
 * should handle possibility of null values. 
 * A multi-column type should be written to parameters starting from index. 
 */ 
 /** 把Gender对象的key属性添加到JDBC PreparedStatement中 */ 
 public void nullSafeSet(PreparedStatement st, Object value, int index)  
                throws HibernateException, SQLException{  
  String sex = null;  
  if (value != null)  
    sex = ((Gender)value).getKey();  
  Hibernate.String.nullSafeSet(st, sex, index);  
 }  
 
 /* 
 * Reconstruct an object from the cacheable representation. At the very least this 
 * method should perform a deep copy if the type is mutable. (optional operation) 
 */ 
 public Object assemble(Serializable cached, Object owner){ 
   return cached; 
 }  
  
 /* 
   * Transform the object into its cacheable representation. At the very least this 
   * method should perform a deep copy if the type is mutable. That may not be enough 
   * for some implementations, however; for example, associations must be cached as 
   * identifier values. (optional operation) 
  */ 
  public Serializable disassemble(Object value) { 
     return (Serializable)value;  
  }  
 
 /* 
 * During merge, replace the existing (target) value in the entity we are merging to 
 * with a new (original) value from the detached entity we are merging. For immutable 
 * objects, or null values, it is safe to simply return the first parameter. For 
 * mutable objects, it is safe to return a copy of the first parameter. For objects 
 * with component values, it might make sense to recursively replace component values. 
 */ 
 public Object replace(Object original, Object target, Object owner){ 
    return original;  
 }  
} 

然后再hbm.xml中定义映射关系:

延伸:

为每个枚举类型定义一个UserType是比较麻烦的,可以定义一个抽象类。

例如扩展下例即可适用于所有保存为index的枚举类型

public abstract class OrdinalEnumUserType> implements UserType {  
 
  protected Class clazz; 
   
  protected OrdinalEnumUserType(Class clazz) { 
    this.clazz = clazz; 
  }  
  
  private static final int[] SQL_TYPES = {Types.NUMERIC};  
  public int[] sqlTypes() {  
    return SQL_TYPES;  
  }  
  
  public Class> returnedClass() {  
    return clazz;  
  }  
  
  public E nullSafeGet(ResultSet resultSet, String[] names, Object owner)  
               throws HibernateException, SQLException {     
 
    //Hibernate.STRING.nullSafeGet(rs, names[0]) 
    int index = resultSet.getInt(names[0]); 
    E result = null;  
    if (!resultSet.wasNull()) {  
      result = clazz.getEnumConstants()[index];  
    }  
    return result;  
  }  
  
  public void nullSafeSet(PreparedStatement preparedStatement, 
     Object value,int index) throws HibernateException, SQLException {  
    if (null == value) {  
      preparedStatement.setNull(index, Types.NUMERIC);  
    } else {  
      //Hibernate.String.nullSafeSet(st, sex, index); 
      preparedStatement.setInt(index, ((E)value).ordinal());  
    }  
  }  
  
  public Object deepCopy(Object value) throws HibernateException{  
    return value;  
  }  
  
  public boolean isMutable() {  
    return false;  
  }  
  
  public Object assemble(Serializable cached, Object owner)  
throws HibernateException { 
     return cached; 
  }  
 
  public Serializable disassemble(Object value) throws HibernateException {  
    return (Serializable)value;  
  }  
  
  public Object replace(Object original, Object target, Object owner) 
throws HibernateException {  
    return original;  
  }  
  public int hashCode(Object x) throws HibernateException {  
    return x.hashCode();  
  }  
  public boolean equals(Object x, Object y) throws HibernateException {  
    if (x == y)  
      return true;  
    if (null == x || null == y)  
      return false;  
    return x.equals(y);  
  }  
} 

以上内容就是爱站技术频道小编为大家带来的JSP开发中hibernate的映射枚举操作方法,我们可以选择爱站技术频道进行学习,我们程序员需要解决各种疑难杂症。

上一篇:jsp源码之输出代码

下一篇:JSP开发中Struts2 URL中文乱码的解决方案

您可能感兴趣的文章

相关阅读

热门软件源码

最新软件源码下载