Hibernate自定义数据类型映射

      自己需要的数据类型为其写个类实现org.hibernate.usertype.UserType ，实现方法，下面是我写的List类型映射到数据库中的varchar类型.后在hibernate映射文件中的属性类型为List，映射文件写的类型为实现类！

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.apache.tools.ant.util.StringUtils;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;

public class EMailListType implements org.hibernate.usertype.UserType {
 private final static char SPLITTER=';';
 private static final int[] TYPES=new int[]{Types.VARCHAR};
 @SuppressWarnings("unchecked")
 public Object deepCopy(Object value) throws HibernateException {
  System.out.println("in deepCopy...");
  List list=(List)value;
  List<?> ls=new ArrayList();
  ls.addAll(list);
  return ls;
 }

 @SuppressWarnings("unchecked")
 public boolean equals(Object x, Object y) throws HibernateException {
  System.out.println("in equals...");
  if(x==y) return true;
  if(x!=null&&y!=null){
   List xlist=(List)x;
   List ylist=(List)y;
   if(xlist.size()!=ylist.size()) return false;
   for(int i=0;i<xlist.size();i++){
    String s1=(String)xlist.get(i);
    String s2=(String)ylist.get(i);
    if(!s1.equals(s2)) ;
   }
   return true;
  }
  return false;
 }

 public boolean isMutable() {
  System.out.println("in isMuable");
  return false;
 }

 public Object nullSafeGet(ResultSet set, String[] names, Object owner)
   throws HibernateException, SQLException {
  System.out.println("in nullSafeGet...");
  String value=(String)Hibernate.STRING.nullSafeGet(set,names[0]);
  if(value!=null){
   return parse(value);
  }
  return null;
 }

 @SuppressWarnings("unchecked")
 private List<?> parse(String value) {
  System.out.println("in parse...");
  Vector strs=StringUtils.split(value, SPLITTER);
  List<?> emailList=new ArrayList();
  emailList.addAll(strs);
  return strs;
 }

 public void nullSafeSet(PreparedStatement pstm, Object value, int index)
   throws HibernateException, SQLException {
  System.out.println("in nullSafeSet...");
  if(value!=null){
   String str=assemble((List<?>)value);
   Hibernate.STRING.nullSafeSet(pstm, str,index);
  }else{
   Hibernate.STRING.nullSafeSet(pstm, value,index);
  }

 }
 private String assemble(List<?> emailList)
 throws HibernateException {
  System.out.println("in assemble...");
  StringBuffer sb=new StringBuffer();
  for(int i=0;i<emailList.size()-1;i++){
   sb.append(emailList.get(i)).append(SPLITTER);
  }
  sb.append(emailList.get(emailList.size()-1));
  return sb.toString();
 }
 public Class<?> returnedClass() {
  System.out.println("in returnClass...");
  return List.class;
 }

 public int[] sqlTypes() {
  System.out.println("in sqlType...");
  return TYPES;
 }
/**
 * assemble是H3在UserType中新增的，它是H2中CompositeUserType接口中的方法。
 * "用于将二级缓存中获取的缓存数据重新转换为我们指定的对象类型"，
 * 如果该对象的实例是可变的，则在这个方法中至少要做一次deepCopy。
 * cached表示二级缓存中的数据，owner表示被缓存对象的宿主
 */
 public Object assemble(Serializable arg0, Object arg1)
   throws HibernateException {
  System.out.println("in assemble two...");
  return null;
 }
/**
 * disassemble是H3在UserType中新增的，
 * 它是H2中CompositeUserType接口中的方法。
 * “当对象被写入二级缓存之前调用，通过这个方法可以将对象转换为易于在二级缓存中保存的形式，
 * 如对于某些无法序列化的数据，将其转化为序列化形式，典型情况，
 * 如对于当前对象对其它实体对象的引用，我们可以考虑将这种引用关系以id值的形式保存”，
 * 如果该对象的实例是可变的，则在这个方法中至少要做一次deepCopy,参数value表示要被缓存的对象。
 * 返回值是该对象在二级缓存中形式
 */
 public Serializable disassemble(Object arg0) throws HibernateException {
  System.out.println("in disassemble...");
  return null;
 }

 public int hashCode(Object arg0) throws HibernateException {
  System.out.println("in hashCode....");
  return 0;
 }

 public Object replace(Object arg0, Object arg1, Object arg2)
   throws HibernateException {
  System.out.println("in replace...");
  return null;
 }
}

属性emails在java中是java.util.List类型

  <property name="emails" column="emails" type="EMailListType"/>