emaillist.java

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 st, Object value,
                            int index) throws SQLException, HibernateException {
        System.out.println("Set method has invoked!");
        if (value != null) {
            String str = myAssemble((List)value);
            Hibernate.STRING.nullSafeSet(st,str,index);
        }else{
            Hibernate.STRING.nullSafeSet(st,value,index);
        }
    }

    /**
     * 提供自定义类型的完全复制方法
     * 本方法将用作构造返回对象
     * 当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;
    }
}