自定义数据类型映射

自定义数据类型映射 ：

Hibernate 提供了自定义映射类型接口，允许用户以编程的方式创建自定义映射类型，以便把持久化类的任意类型的属性映射到数据库中。

 

现在我们以一个简单的例子来说明自定义数据类型映射的思想和用法，对于 T_User 对象需要增加一个 email 属性用于保存用户的邮件地址，同时要求一个用户可以有多个邮件地址，系统在发送邮件时将向这些地址同时发送。

  根据我们以往的项目经验主要有两种思路：

   （ 1 ）、为 T_User 表增加 email1,email2…… 等字段。

   （ 2 ）、增加一个 T_Email 表， T_User 表通过主键与之关联。

第 1 种方式实现不够优雅，并且在 email 数量上和可查询性上受到较大的局限，但是由于是单表操作开发难度较小，性能相对较高。

第 2 种方式比较完美的体现了设计意图，也无 email 数量限制且易于查询，但是仅仅为了一个 email 就增加一张表未免有些小题大做。

其实我们可以将一个用户的所有 email 信息都存在 T_User 表中的 email 字段中，每个 email 用分号分开，这样我们就得到了一个大字符串，但是这就需要上层的程序逻辑处理，我们的目的是为数据逻辑层及业务逻辑层提供更加易于操作的对象。 Hibernate 中的 UserType 接口正是为我们实现这一目的准备的，通过实现该接口我们可以定义我们自己的类型，并且可加入相应的数据解析逻辑，而且他还会带来一个好处那就是重用性（所有需要保存 email 的实体都可以共用该类型）。根据这里的情况如果我们将 email 映射为 List 类型将会是一个不错的选择，如何将 email 映射为 List 类型呢？下面我们将会看到。

T_User 表

T_User

id     number   <pk> name varchar2(50) age    number image    BLOB resume   CLOB email     varchar2(500)

首先我们先来认识一下 UserType 接口：

 

 

 

public interface UserType{

 /**

返回 UserType 所映射字段的 sql 类型 (java.sql.Types)

返回类型时 int[], 其中包含映射各自段的 sql 代码

（ UserType 可以映射到一个或多个字段）

 **/

 public int[] getTypes();

 /**

   
UserType.nullSafeGet() 所返回的自定义数据类型

 **/

 public Class returnedClass();

 /**

自定数据类型的对比方法

此方法用于做脏数据检查，参数 x,y 分别代表属性当前值和属性的快照值

如果 equals 方法返回 false, 则 Hibernate 将认为数据发生变化，并将变化更新到数据库中

 **/

 public boolean equals(Object x,Object y) throws HibernateException;

 /**

当 Hibernate 加载数据时会调用该方法，该方法会从底层 JDBC ResultSet 读取数据，将其

转化为自定义类型后返回，该方法要求对可能出现的 null 值作处理， names 中包含了当前自定义类型的映射字段名称。

 **/

 public Object nullSafeGet(ResultSet rs,String[] names,Objec owner) throws HibernateException,SQLException;

 /**

   本方法将在 Hibernate 进行数据库保存时被调用我们可以通过 PrepareStatement 将自定义数据

   写入数据库

 **/

 public void nullSafeSet(PrepareStatement st,Object value,int index) throws HibernateException,SQLException;

/**

  提供自定义类型的完全复制方法本方法将用于构造返回对象，当 nullSafeGet 方法被调用后，我们

  获得了自定义数据对象。在向用户返回自定义数据之前， deepCopy 方法将被调用，它将根据自定

  义数据对象构造完全拷贝，并将此拷贝返回给用户使用。

  此时，我们就得到了自定义数据对象的两个版本，第一个是从数据库读取的原始版本将由 Hibernate 负责维护，复制版本将由用户使用，原版本用作稍后的脏数据检查依据； Hibernate 将在脏数据检查过程中将这两个版本数据进行比对 ( 通过调用 equals 方法 ) ，如果数据发生变化 (equals 将返回 false) ，则执行对应的持久化操作。

**/

public Object deepCopy(Object value) throws HibernateException;

/**

  判断本实例是否是可变的， Hibernate 在处理不可变类型时会采取一些性能优化措施。

**/

 public boolean isMutable();

}

实现我们的 EmailList ，实现了 UserType 接口代码如下：

public class EmailList implements UserType{

 private List emails;

 private static final char SPLIT=”;”;

 private static final int[] TYPES=new int[]{Types.VARCHAR};

 public boolean isMutable(){

    return false;

}
 public int[] sqlTypes(){

 return TYPES;

}

public Class returnedClass(){

 return List.class;

}

/**

  创建一个新的 List 实例，包含原有 List 实例所有的元素

**/

public Object deepCopy(Object value) throws HibernateException{

 List sourcelist=(List)value;

 List targetlist=new ArrayList();

 targetlist.addAll(sourcelist);

 return targetlist;

}

/**

  判断 email list 是否发生变化

**/

public boolean equals(Object x,Object y) throws HibernateException{

 if(x==y)return ture;

 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=xlist.get(i).toString();

      String str2=ylist.get(i).toString();

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

     }

     return true;

}

return false;

}

/**

  从 ResultSet 中取出 email 字段，并将其解析为 List 类型后返回

**/

public Object nullSafeGet(ResuleSet rs String[] names,Object owner)

 throws HibernateException,SQLException{

 String value=(String)Hibernate.STRING.nullSafeGet(rs,name[0]);

 if(value!=null){

   return parse(value);

 }

 else{

   return null;

}

}

/**

  将 List 型的 email 信息组装成字符串之后保存到 email 字段

**/

public void nullSafeSet(PrepareStatement st,Object value,int index)

 throws HibernateException,SQLException{

 if(value!=null){

   String str=assemble((List)value);

   Hibernate.STRING.nullSafeSet(st,str,index);

 }

 else{

   Hibernate.STRING.nullSafeSet(st,value,index);

 }

}

/**

  将 String 拼装为一个字符串，以 ”;” 分隔

**/

private String assemble(List list){

 StringBuffer buffer=new StringBuffer();

 for(int i=0;i<list.size()-1;i++){

    buffer.append(list.get(i).toString()).append(SPLIT);

 }

 buffer.append(list.get(list.size()-1).toString());

 return buffer.toString();

}

/**

  将以 ”;” 分隔的字符串解析为一个字符串数组

**/

public List parse(String value){

 List emaillist=new ArrayList();

 String[] strs=org.apache.commons.lang.StringUtils.split(SPLIT);

 for(int i=0;i<strs.length;i++){

    emaillist.add(strs[i]);

 

}

return emaillist;

}

}

 

TUser.hbm.xml

<hibernate-mapping>

 <class name=”com.neusoft.hibernate.entity.TUser” table=”T_USER”>

 <id…../>

 <property……/>

 <property name=”email” column=”email” type=”com.neusoft.hibernate.entity.type.EMallist” />

 </class>

</hibernate-mapping>

 

测试程序：

TUser user=(TUser)session.load(TUser.class,new Integer(2));

List list=user.getEmail();

for(int i=0;i<list.size();i++){

 System.out.println(list.get(i));

}

list.add(“zhao-xin@neusoft.com”);

Transaction trans=session.beginTransaction();

 session.save(user);

trans.commit();

观察数据库发现 email 字段已经以 ”;” 分隔的形势存在，同样在读取时，我们也无需面对原始的 ”;” 分隔字符串，转而只需处理 List 型数据即可。

使用 UserType 处理大数据对象：

还记得我们在上一篇文章有关大数据对象映射技术中留下的伏笔吗？现在我们就来兑现，我们将使用 UserType 构造自定义数据类型，来给出一个大数据对象的通用解决方案（针对 Oracle 数据库）。下面的 StringClobType 实现了这一目标。

public class StringClobType implements UserType{

 private static final String ORACLE_DRIVER_NAME=”Oracle JDBC driver”;

 private static final int ORACLE_DRIVER_MAJOR_VERSION=9;

 private static final int ORACLE_DRIVER_MINOR_VERSION=0;

 

 public int[] sqlTypes(){

   return new int[]{Types.CLOB};

 }

 public Class returnedClass(){

   return String.class;

 }

 public boolean equals(Object x,Object y){

   return org.apache.commons.lang.ObjectUtils.equals(x,y);

 }

 public Object nullSafeGet(Resultset rs,String[] names,Object owner)

throws HibernateException,SQLException{

 Clob clob=rs.getClob(names[0]);

return (clob==null?null:clob.getSubString(1,(int)clob.length()));

}

public void nullSafeSet(PrepareStatement st,Object value,int index)

     throws HibernateException,SQLException{

   DatebaseMetaData dbMetaData=st.getConnection().getMetaData();

   if(value==null){

    st.setNull(index,sqlTypes()[0]);

}

// 本实现只适用于 Oracle 数据库 9.0 以上版本

if(ORACLE_DRIVER_NAME.equals(dbMetaData.getDriverName())){

 if((dbMetaData.getDriverMajorVersion()>=ORACLE_DRIVER_MAJOR_VERSION)

     && (dbMetaData.getDriverMinorVersion()>=ORACLE_DRIVER_MINOR_VERSION)){

       try{

        // 通过动态加载方式避免编译期间对 Oracle JDBC 的依赖

        Class oracleClobClass=Class.forName(“oracle.sql.CLOB”);

        // 动态调用 createTemporary 方法

        Class partypes[]=new Class[3];

        partypes[0]=Connection.class;

        partypes[1]=Boolean.class;

        partypes[2]=Integer.class;

        Method createTemporaryMethod=

oracleClobClass.getDeclaredMethod(“createTemporary”,partypes);

        Field durationSessionField=oracleClobClass.getField(“DURATION_SESSION”);

        Object[] arglist=new Object[3];

        Connection conn=st.getConnection().getMetaData().getConnection();

        // 数据库连接类型必须为 OracleConnection ，某些应用服务器会使用自带的

        //Oracle JDBC Wrapper, 如 Weblogic, 这里需要特别注意

　　　　 Class oracleConnectionClass=Class.forName(“oracle.jdbc.OracleConnection”);

        if(!oracleConnectionClass.isAssignableForm(conn.getClass())){

          throw new HibernateException(“Must be a oracle.jdbc.OracleConnection:”

+conn.getClass.getName());

        }

        agrlist[0]=conn;

        arglist[1]=Boolean.class;

        arglist[2]=durationSessionField.get(null);

       

        Object tempClob=createTemporaryMethod.invoke(null,arglist);

        partypes[0]=Integer.TYPE;

        Method openMethod=oracleClobClass.getDeclaredMethod(“open”,partypes);

        Field modeReadWriteField=oracleClobClass.getField(“MODE_READWRITE”);

        arglist=new Object[1];

        arglist[0]= modeReadWriteField.get(null);

        openMethod.invoke(tempClob,arglist);// 按读写模式打开Ｃｌｏｂ对象的输入流

        Method getCharacterOutputStreamMethod=oracleClobClass.getDeclaredMethod(

                                               “getCharacterOutputStream”,null);

        // 调用 getCharacterOutputStream 方法

        Writer tempClobWriter=

(Writer)getcharacterOutputStreamMethod.invoke(tempClob,null);

        // 将数据写入 Clob

        tempClobWriter.write((String)value);

        tempClobWriter.flush();

        tempClobWriter.close();

        // 关闭 Clob 流

　　　　 Method closeMethod=oracleClobClass.getDeclareMethod(“close”,null);

        closeMethod.invoke(tempClob,null);

        st.setClob(index,(Clob)tempClob);

       }catch(ClassNotFoundException ce){

         throw new HibernateException(“Unable to find a require class./n”+ce.getMessage());

       } catch(NoSuchMethodException me){

         throw new HibernateException(

“Unable to find a require method./n”+me.getMessage());

       } catch(NoSuchFieldException fe){

         throw new HibernateException(“Unable to find a require field./n”+fe.getMessage());

       } catch(IllegalAccessException ae){

         throw new HibernateException(

“Unable to find a require method or field./n”+ae.getMessage());

       }catch(InvocationTargetException ie){

         throw new HibernateException(ie.getMessage());

       }catch(IOException oe){

         throw new HibernateException(oe.getMessage());

       }

}else{

 throw new HibernateException(“No CLOBS support.Use driver version”+

ORACLE_DRIVER_MAJOR+”,minor ”

+ORACLE_DRIVER_MINOR_VERSION);

}

}else{

 String str=(String)value;

 StringReader r=new StringReader(str);

 st.setCharacterStream(index,r,str.length());

}

}

 

public Object deepCopy(Object value){

 if(value==null)

    return null;

 return new String((String)value);

}

public boolean isMutable(){

 return false;

}

}

上面这段代码重点在 nullSafeSet 方法的实现，在该方法中通过 java reflection 机制摆脱了编译期的

Oracle JDBC 原生类依赖，同时借助 Oracle JDBC 提供的原生功能完成 Clob 字段的写入，该代码是从 Ali Ibrahim,Scott Miller 的代码修改而来，支持 Oracle 9 以上版本， Oracle 8 对应的实现参照

http://www.hibernate.org/56.html 网址提供的解决方案。另外此代码必须运行在最新版的

Oracle JDBC Driver 上。