JSP中Hibernate实现映射枚举类型

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); 
 } 
} 

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;  
 }  
} 

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<&＃63;> 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);  
  }  
}