精通hibernate学习笔记（6）[映射类型]
Hibernate映射类型分为两种：内置映射类型和客户化映射类型，内置映射类型负责把常见的java类型映射到相应的sql类型；另外，用户可以实现UserType或CompositeUserType接口，来定制客户化映射类型，这样可以把用户定义 的java类型映射到数据库表的相应字段。
1、内置映射类型
1.1 java基本类型的hibernate映射类型
1.2 java时间和日期类型的hibernate映射类型
1.3 Java大对象类型的hibernate映射类型
注意：不允许使用这些数据类型来定义持久化类的OID。
CLOB：字符串大对象(Character Large Object)
BLOB：表示二进制大对象(Binary Large Object)
MySql中不支持标准SQL的CLOB类型，MySQL中使用TEXT,MEDIUMTEXT,LONGTEXT类型类表示长度超过255的长文本数据，分别为0~65535,0~16777215,0~4294967295字节。
如果持久化类的某个字段为java.sql.Clob或java.sql.Blob实例时，映射设置如下：
<property name="description" type="clob" column="DESCRIPTION">
在应用程序中通过Hibernate来保存java.sql.Clob或java.sql.Blob实例时，必须包括以下两个步骤：
a. 在数据库事务中先保存一个空的Blob或Clob实例。
b. 接着锁定这条记录，更新在a中保存的实例，把二进制数据或长文本数据写到Blob或Clob实例中。
例：
Session session = sessionFactory.openSession();
Transaction tx = session.begainTransaction();
customer = new Customer();
//现保存空的clob实例
customer.setDescription(Hibernate.createClob(" "));
session.save(customer);
session.flush();
//锁定这条记录
session.refresh(customer,LockMode.UPGRADE);
oracle.sql.Clob clob = (Oracle.sql.Clob)customer.getDescription();
//把长文本数据写到Clob实例中
java.io.Writer.pw=clob.getCharacterOutputStream();
pw.write(longText);//longText表示一个长度〉255的字符串
pw.close();
tx.commit();
session.close();
尽管java.sql.Clob和java.sql.Blob是处理java大对象的有效方式，但是使用二者受到以下两点限制：
a. 如果在持久化类中定义了一个该类型的属性，只有在一个数据库事务中，这样的实例才会有效。
b. 有些数据库系统的jdbc驱动程序不支持这样的类型。
如果在java程序中处理图片或长文件的二进制数据，使用byte[]比Blob更方便，处理长度>255的字符串使用String比Clob更方便。
1.4 JDK自带的个别java类的hibernate映射类型
1.5 使用映射类型
在以下情况下必须显示指定映射文件中的hibernate映射类型：
a. 如果希望通过hbm2java工具由映射文件来生成持久化类，必须在映射文件中显式指定映射类型
b. 一个java类型对应多个Hibernate映射类型的场合。如：java.util.Date，可以对应Hibernate的映射类型中的date，time，timestamp。
2、客户化映射类型
2.1 用户化映射类型取代Hibernate组件
曾经用组件来映射Customer类的Address类型的homeAddress属性和comAddress属性，同样可以用自定义映射类型来实现。
把Address设计为不可变类，即当创建了这种类的实例以后，就不允许修改它的属性。java中所有基本类型的包装类都是不可变类：Integer,Long等。创建用户自己的不可变类时，可以考虑以下设计模式：
a. 把属性定义为private final类型。
b. 不对外公开set方法
c. 只对外公开get方法
d. 允许在构造方法中设置所有属性。
e. 覆盖Object类的equals和hashCode方法，在equals方法中根据对象的属性值来比较两个对象是否相等，保证用equals方法比较相等的两个对象的hashCode方法返回值也相等。
package mypack;
import java.io.Serializable;
public class Address implements Serializable ...{
private final String province;
private final String city;
private final String street;
private final String zipcode;
public Address(String province, String city, String street, String zipcode) ...{
this.street = street;
this.city = city;
this.province = province;
this.zipcode = zipcode;
}
public String getProvince() ...{
return this.province;
}
public String getCity() ...{
return this.city;
}
public String getStreet() ...{
return this.street;
}
public String getZipcode() ...{
return this.zipcode;
}
public boolean equals(Object o)...{
if (this == o) return true;
if (!(o instanceof Address)) return false;
final Address address = (Address) o;
if(!province.equals(address.province)) return false;
if(!city.equals(address.city)) return false;
if(!street.equals(address.street)) return false;
if(!zipcode.equals(address.zipcode)) return false;
return true;
}
public int hashCode()...{
int result;
result= (province==null?0:province.hashCode());
result = 29 * result + (city==null?0:city.hashCode());
result = 29 * result + (street==null?0:street.hashCode());
result = 29 * result + (zipcode==null?0:zipcode.hashCode());
return result;
}
}
package mypack;
import net.sf.hibernate.*;
import java.sql.*;
public class AddressUserType implements UserType ...{
private static final int[] SQL_TYPES = ...{Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR};
public int[] sqlTypes() ...{ return SQL_TYPES; }
public Class returnedClass() ...{ return Address.class; }
public boolean isMutable() ...{ return false; }
public Object deepCopy(Object value) ...{
return value; // Address is immutable
}
public boolean equals(Object x, Object y) ...{
if (x == y) return true;
if (x == null || y == null) return false;
return x.equals(y);
}
public Object nullSafeGet(ResultSet resultSet,
String[] names,
Object owner)
throws HibernateException, SQLException ...{
if (resultSet.wasNull()) return null;
String province = resultSet.getString(names[0]);
String city = resultSet.getString(names[1]);
String street = resultSet.getString(names[2]);
String zipcode = resultSet.getString(names[3]);
return new Address(province,city,street,zipcode);
}
public void nullSafeSet(PreparedStatement statement,Object value,int index)
throws HibernateException, SQLException ...{
if (value == null) ...{
statement.setNull(index, Types.VARCHAR);
statement.setNull(index+1, Types.VARCHAR);
statement.setNull(index+2, Types.VARCHAR);
statement.setNull(index+3, Types.VARCHAR);
} else ...{
Address address=(Address)value;
statement.setString(index, address.getProvince());
statement.setString(index+1, address.getCity());
statement.setString(index+2, address.getStreet());
statement.setString(index+3, address.getZipcode());
}
}
}
<property name="homeAddress" type="mypack.AddressUserType" >
<column name="HOME_STREET" length="15" />
<column name="HOME_CITY" length="15" />
<column name="HOME_PROVINCE" length="15" />
<column name="HOME_ZIPCODE" length="6" />
</property>
<property name="comAddress" type="mypack.AddressUserType" >
<column name="COM_STREET" length="15" />
<column name="COM_CITY" length="15" />
<column name="COM_PROVINCE" length="15" />
<column name="COM_ZIPCODE" length="6" />
</property>
注：映射文件列的顺序要与自定义type中的列名对应顺序一致，如果不一致可能会取出的数据没错，但是库表中的数据列的位置不一致，同时可能出现类型不匹配。能取出一致数据的地原因是nullSafeSet和nullSafeGet中列的顺序一致！