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"/>