程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> 網頁編程 >> JSP編程 >> 關於JSP >> JSP 中Hibernate實現映射枚舉類型

JSP 中Hibernate實現映射枚舉類型

編輯:關於JSP

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 <tt>java.sql.Types</tt>. */ 
 /**設置和Gender類的sex屬性對應的字段的SQL類型 */  
 public int[] sqlTypes() { 
   return typeList; 
 } 
 
 /*The class returned by <tt>nullSafeGet()</tt>.*/ 
 /** 設置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 <tt>index</tt>. 
 */ 
 /** 把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中定義映射關系:

<hibernate-mapping package="" default-lazy="true" default-cascade="save-update,merge,persist"> 
  <typedef name="Gender" class="com.alpha.hibernate.GenderUserType"> 
    <property name="gender" type="Gender"> 
        <column name="GENDER" not-null="true"> 
        </column> 
    </property> 

延伸:

為每個枚舉類型定義一個UserType是比較麻煩的,可以定義一個抽象類。

例如擴展下例即可適用於所有保存為index的枚舉類型

public abstract class OrdinalEnumUserType<E extends Enum<E>> implements UserType {  
 
  protected Class<E> clazz; 
   
  protected OrdinalEnumUserType(Class<E> 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);  
  }  
} 

感謝閱讀,希望能幫助到大家,謝謝大家對本站的支持!

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved