简要分析Java的Hibernate框架中的自定义类型

public interface UserType { 
  /** 
   * Return the SQL type codes for the columns mapped by this type. The 
   * codes are defined on java.sql.Types. 
   */ 
  public int[] sqlTypes(); 
 
  /** 
   * The class returned by nullSafeGet(). 
   */ 
  public Class returnedClass(); 
 
  /** 
   * Compare two instances of the class mapped by this type for persistence "equality". 
   * Equality of the persistent state. 
   */ 
  public boolean equals(Object x, Object y) throws HibernateException; 
 
  /** 
   * Get a hashcode for the instance, consistent with persistence "equality" 
   */ 
  public int hashCode(Object x) throws HibernateException; 
 
  /** 
   * Retrieve an instance of the mapped class from a JDBC resultset. Implementors 
   * should handle possibility of null values. 
   */ 
  public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException; 
 
  /** 
   * 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. 
   */ 
  public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException, SQLException; 
 
  /** 
   * 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. 
   */ 
  public Object deepCopy(Object value) throws HibernateException; 
 
  /** 
   * Are objects of this type mutable&＃63; 
   * 
   * @return boolean 
   */ 
  public boolean isMutable(); 
 
  /** 
   * 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) 
   * 
   * @param value the object to be cached 
   * @return a cachable representation of the object 
   * @throws HibernateException 
   */ 
  public Serializable disassemble(Object value) throws HibernateException; 
 
  /** 
   * 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) throws HibernateException; 
 
  /** 
   * 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) throws HibernateException; 
} 

package org.hibernate.tutorial.domain; 
import java.io.Serializable; 
import java.util.List; 
public class User implements Serializable{ 
  public Long id; 
  private String name; 
  private List emails; 
    省略Get/Set方法 
} 

package org.hibernate.tutorial.domain; 
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 org.hibernate.Hibernate; 
import org.hibernate.HibernateException; 
import org.hibernate.usertype.UserType; 
 
public class EmailList implements UserType { 
 
  private static final char SPLITTER = ';'; 
  private static final int[] TYPES = new int[] {Types.VARCHAR}; 
   
  private String assemble(List emailList) { 
    StringBuilder strBuf = new StringBuilder(); 
    for (int i = 0; i 

import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.ArrayList; 
import junit.framework.TestCase; 
 
import org.hibernate.EntityMode; 
import org.hibernate.Session; 
import org.hibernate.SessionFactory; 
import org.hibernate.Transaction; 
import org.hibernate.cfg.Configuration; 
import org.hibernate.tutorial.domain.User; 
 
public class HibernateTest extends TestCase{ 
 
  private Session session = null; 
   
  protected void setUp() throws Exception { 
     
    Configuration cfg = new Configuration().configure(); 
    SessionFactory sessiOnFactory= cfg.buildSessionFactory(); 
     
    session = sessionFactory.openSession(); 
 
  } 
   
  public void testInsert(){ 
    Transaction tran = null; 
    try{ 
      tran = session.beginTransaction(); 
       
      User user = new User(); 
       
      user.setName("shun"); 
       
      List list = new ArrayList(); 
       
      list.add("12312@sfsdf.com"); 
      list.add("123@123.com"); 
 
      user.setEmails(list); 
      session.save(user); 
       
      tran.commit(); 
    } catch (Exception ex) { 
      ex.printStackTrace(); 
      if (tran != null){ 
        tran.rollback(); 
      } 
    } 
  } 
   
  protected void tearDown() throws Exception { 
    session.close(); 
  } 
} 

java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.lang.String 

if(xList.size() != yList.size()) return false; 

X:[[12312@sfsdf.com, 123@123.com]]Y:[12312@sfsdf.com, 123@123.com]