emaillist.java~67~

Hibernate的自定义类型的列子 用JBuilder开发

package bean;

import org.hibernate.*;
import org.hibernate.usertype.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.io.Serializable;

import java.util.*;
import java.sql.Types;

public class EMailList implements UserType {
    private List emails;
    private static final char SPLITTER = ';';
    private static final int[] TYPES = new int[]{Types.VARCHAR};

    /**
     * 返回UserType所映射字段的SQL类型(java.sql.Types)
     * 返回类型为int[],其中包含了映射各字段的SQL类型代码
     * (UserType可以映射到一个或多个字段)
     * @return int[]
     */
    public int[] sqlTypes() {
        return TYPES;
    }

    /**
     * UserType.nullSafeGet()所返回的自定义数据类型
     * @return Class
     */
    public Class returnedClass() {
        return List.class;
    }

    /**
     * 自定义数据类型的对比方法
     * 此方法将作用脏数据检查,参数x,y分别为数据的两个副本
     * 如果equals方法返回false,则Hibernate将认为数据发生变化,并将
     * 变化更新到数据库表中
     * @param object Object
     * @param object1 Object
     * @return boolean
     * @throws HibernateException
     */
    //判断email list是否发生改变
    public boolean equals(Object x, Object y) throws
            HibernateException {
        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 str1 = (String)xList.get(i);
                String str2 = (String)yList.get(i);

                if(!str1.equals(str2)) return false;
            }
            return true;
        }
        return false;
    }


    public int hashCode(Object object) throws HibernateException {
        return 0;
    }

    /**
    * 从JDBC ResultSet读取数据,将其转换为自定义类型后返回
    * (此方法要求对可能出现的null值进行处理)
    * names中包含了当前自定义类型的映射字段名称
    * @param object Object
    * @return int
    * @throws HibernateException
    */
   //从ResultSet中取出email字段,并将其解析为List类型后返回
    public Object nullSafeGet(ResultSet rs, String[] names,
                              Object owner) throws SQLException,
            HibernateException {
        String value = (String)Hibernate.STRING.nullSafeGet(rs,names[0]);
        if(value != null){
            return parse(value);
        }else{
            return null;
        }
    }

    /**
     * 将以";"分隔的字符串解析为一个字符串数组
     * @param value String
     * @return List
     */

    public List parse(String value){
        String[] strs = org.apache.commons.lang.StringUtils.split(value,SPLITTER);
        List emailList = new ArrayList();
        for(int i = 0; i < strs.length; i++){
            emailList.add(strs[i]);
        }
        return emailList;
    }

    /**
     * 本方法将在Hibernate进行数据保存时被调用
     * 我们可以通过PreparedStatement将自定义数据写入对应的库表字段
     * @param preparedStatement PreparedStatement
     * @param object Object
     * @param _int int
     * @throws SQLException
     * @throws HibernateException
     */
    public void nullSafeSet(PreparedStatement preparedStatement, Object object,
                            int _int) throws SQLException, HibernateException {
        System.out.println("Set method has invoked!");
        if(value ! = null){

        }
    }

    /**
     * 提供自定义类型的完全复制方法
     * 本方法将用作构造返回对象
     * 当nullSafeGet方法调用之后,我们获得了自定义数据对象.在向用户
     * 返回自定义数据之前,deepCopy方法将被调用,它将根据自定义数据对象
     * 构造一个完全拷贝,并将此拷贝返回给用户使用.
     * 此时,我们就可以得到了自定义数据对象的两个版本,第一个是从数据库读出
     * 的原始版本,其二是我们通过deepCopy构造的复制版本,原始版本将由Hibernate
     * 负责维护,复制版本将由用户使用,原始版本用作稍后对脏数据检查的依据;
     * Hibernate将在数据检查过程中将这两个把版本进行比对(通过调用equals方法),
     * 如果数据发生了变化(equals返回false),则执行对应的持久化操作
     *
     * @ object a copy
     * @throws HibernateException
     */
    //创建一个新的List实例,包含原有List实例中的所有元素
    public Object deepCopy(Object object) throws HibernateException {
        List sourcelist = (List)object;
        List targetlist = new ArrayList();
        targetlist.addAll(sourcelist);
        return targetlist;
    }

    public boolean isMutable() {
        return false;
    }

    public Serializable disassemble(Object object) throws HibernateException {
        return null;
    }

    /**
     * 将String拼装为一个字符串,以";"分隔
     * @param serializable Serializable
     * @param object Object
     * @return Object
     * @throws HibernateException
     */
    public Object assemble(Serializable serializable, Object obj) throws
            HibernateException {
       return null;
    }

    public String myAssemble(List emailList){
       StringBuffer strBuf = new StringBuffer();
       for(int i = 0; i < emailList.size() - 1; i++){
           strBuf.append(emailList.get(i)).append(SPLITTER);
       }
       strBuf.append(emailList.get((emailList.size()-1)));
       return strBuf.toString();

    }

    public Object replace(Object object, Object object1, Object object2) throws
            HibernateException {
        return null;
    }
}