1 轉換器的基本概念
在Hibernate之中並沒有涉及到過多的複雜數據類型,在整個開發裏面見到最多的幾種類型:int\Integer、double\Double、String、Date,並且每種操作在進行數據庫保存的時候都會自動的填充到PreparedStatement接口的操作裏面。
但是很多時候這樣的操作可能並不能夠全部滿足於當前需求,假設說現在有如下的一張數據表,在這張數據表裏面它希望可以保存多個email地址。
(UserTypeProject)
範例:創建數據表
-- 刪除數據表
DROP TABLE IF EXISTS member;
-- 創建數據表
CREATE TABLE member(
mid INT,
mname varchar(50),
memails TEXT,
CONSTRAINT pk_mid PRIMARY KEY(mid)
);
需要讓一個用戶保存有多個email地址,而多個email地址之間使用|
分隔,但是在程序之中不希望出現這樣複雜的數據,希望程序裏面使用的是List集合。
org.hibernate.usertype.UserType
接口裏面定義有如下的一組操作方法。在這個接口裏面定義有如下的抽象方法:
(1)public Object assemble(Serializable cached, Object owner) throws HibernateException
:對象的反序列化操作,可以按照用戶的需求將List集合轉化爲字符串。
(2)public Object deepCopy(Object value) throws HibernateException
:深度拷貝,就是全部拷貝,整個Hibernate有一個持久態,持久態如何知道修改呢?至少需要有個比較操作,所以這個方法是在持久態發生變化的時候自己調用的。
(3)public Serializable disassemble(Object value) throws HibernateException
:序列化操作對象,例如將字符串拆分爲List集合。
(4)public boolean equals(Object x, Object y) throws HibernateException
:負責對象的比較操作,對象狀態改變依靠對象比較完成。
(5)public int hashCode(Object x) throws HibernateException
:返回對象哈希碼。
(6)public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException
:數據讀取的時候所執行的操作方法。
(7)public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws HibernateException, SQLException
:設置數據的時候所執行的方法。
(8)public Object replace(Object original, Object target, Object owner) throws HibernateException
:替換對象。
(9)public Class returnedClass()
:得到返回的類型。
(10)public int[] sqlTypes()
:返回SQL的操作類型。
所有的操作方法之所以那麼多,就是因爲Hibernate本身的Session緩存不可關閉,那麼必須要保證持久態可以正常操作。
2 實現List與String的轉換
既然已經有了UserType的處理接口,那麼就可以輕鬆實現之前提出的List與String的轉換處理。
範例:定義一個專門用於轉換的處理類
package org.lks.usertype;
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.Iterator;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;
/**
* 此時的這個工具就可以實現List集合與String間的互相轉換
* @author hhybigfool
*
*/
public class ListAndStringUserType implements UserType{
/**
* 反序列化操作,當用戶進行數據保存的時候,需要將List集合變爲String型數據
*/
@Override
public Object assemble(Serializable cached, Object owner) throws HibernateException {
StringBuffer buf = new StringBuffer();
List<String> all = (List<String>) owner; //將接收到傳入的List集合
Iterator<String> iter = all.iterator();
while(iter.hasNext()){
buf.append(iter.next()).append("|");
}
return buf.toString();
}
@Override
public Object deepCopy(Object value) throws HibernateException {
if(value != null){ //有內容
List<String> oldList = (List<String>) value;
List<String> newList = new ArrayList<String>();
newList.addAll(oldList); //整體增加
return newList;
}
return null;
}
/**
* 在數據讀取完成之後,POJO類裏面應該用的是List集合
*/
@Override
public Serializable disassemble(Object value) throws HibernateException {
String str = (String) value;
List<String> all = new ArrayList<String>();
String[] result = str.split("\\|");
for(int i = 0; i < result.length; i++){
all.add(result[i]);
}
return (Serializable)all;
}
@Override
public boolean equals(Object x, Object y) throws HibernateException {
return x.equals(y); //交由每個POJO類的equals()比較完成
}
@Override
public int hashCode(Object x) throws HibernateException {
return x.hashCode();
}
@Override
public boolean isMutable() {
return true;
}
@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
throws HibernateException, SQLException {
// 當取得數據之後需要將數據變爲List集合
return this.disassemble(rs.getString(names[0]));
}
@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
throws HibernateException, SQLException {
//
if( value == null){
st.setNull(index, Types.NULL);
}else{
st.setString(index, this.assemble(session, value).toString());
}
}
@Override
public Object replace(Object original, Object target, Object owner) throws HibernateException {
return original;
}
@Override
public Class returnedClass() {
return List.class;
}
@Override
public int[] sqlTypes() {
return new int[]{Types.VARCHAR};
}
}
如果要使用轉換器,重點是在於POJO類的定義上。
package org.lks.pojo;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.Type;
/**
* Member entity. @author MyEclipse Persistence Tools
*/
@SuppressWarnings("serial")
@Entity
@Table(name = "member", catalog = "hedb")
public class Member implements java.io.Serializable {
// Fields
private Integer mid;
private String mname;
private List<String> memails = new ArrayList<String>();
// Constructors
/** default constructor */
public Member() {
}
/** minimal constructor */
public Member(Integer mid) {
this.mid = mid;
}
// Property accessors
@Id
@Column(name = "mid", unique = true, nullable = false)
public Integer getMid() {
return this.mid;
}
public void setMid(Integer mid) {
this.mid = mid;
}
@Column(name = "mname", length = 50)
public String getMname() {
return this.mname;
}
public void setMname(String mname) {
this.mname = mname;
}
@Column(name = "memails", length = 65535)
@Type(type="org.lks.usertype.ListAndStringUserType")
public List<String> getMemails() {
return this.memails;
}
public void setMemails(List<String> memails) {
this.memails = memails;
}
}
也就是說在處理此字段的時候,將利用給定的轉換器進行轉換處理。
範例:測試代碼
package org.lks.test;
import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Member;
public class TestMemberInsert {
public static void main(String[] args) {
Member vo = new Member();
vo.setMid(1001);
vo.setMname("lks");
vo.getMemails().add("[email protected]");
vo.getMemails().add("[email protected]");
vo.getMemails().add("[email protected]");
vo.getMemails().add("[email protected]");
vo.getMemails().add("[email protected]");
HibernateSessionFactory.getSession().save(vo);
HibernateSessionFactory.getSession().beginTransaction().commit();
HibernateSessionFactory.closeSession();
System.exit(0);
}
}
此時會利用轉換器自動的將List集合變爲指定格式的字符串。
範例:觀察讀取操作
package org.lks.test;
import org.lks.dbc.HibernateSessionFactory;
import org.lks.pojo.Member;
public class TestMemberGet {
public static void main(String[] args) {
Member vo = (Member) HibernateSessionFactory.getSession().get(Member.class, 1001);
System.out.println(vo);
HibernateSessionFactory.closeSession();
System.exit(0);
}
}
這種轉換操作是看你的實際需求來定的,有些時候可能用戶傳遞的數據就是這樣。
目的是爲了不破壞核心流程,數據層做的不應該是數據處理,應該是CRUD。
3 實現JSON數據轉換
JSON在實際的開發之中使用非常廣泛,所以有些時候進行數據傳遞的操作中也會使用JSON結構進行保存,所以下面再轉換器的基礎上做一個擴充,定義一個JSON的轉換器。
範例:ListAndJSONUserType
package org.lks.usertype;
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.Iterator;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
/**
* 此時的這個工具就可以實現List集合與String間的互相轉換
* @author hhybigfool
*
*/
public class ListAndJSONUserType implements UserType{
/**
* 反序列化操作,當用戶進行數據保存的時候,需要將List集合變爲JSON型數據
*/
@Override
public Object assemble(Serializable cached, Object owner) throws HibernateException {
JSONObject obj = new JSONObject();
List<String> all = (List<String>) owner; //將接收到傳入的List集合
JSONArray array = new JSONArray();
Iterator<String> iter = all.iterator();
while(iter.hasNext()){
array.add(iter.next());
}
obj.put("emails", array);
System.out.println("JSON: " + obj);
return obj.toString();
}
@Override
public Object deepCopy(Object value) throws HibernateException {
if(value != null){ //有內容
List<String> oldList = (List<String>) value;
List<String> newList = new ArrayList<String>();
newList.addAll(oldList); //整體增加
return newList;
}
return null;
}
/**
* 在數據讀取完成之後,POJO類裏面應該用的是List集合
*/
@Override
public Serializable disassemble(Object value) throws HibernateException {
JSONObject obj = JSONObject.fromObject(value);
List<String> all = new ArrayList<String>();
JSONArray array = obj.getJSONArray("emails");
for(int i = 0; i < array.size(); i++){
all.add(array.getString(i));
}
return (Serializable)all;
}
@Override
public boolean equals(Object x, Object y) throws HibernateException {
return x.equals(y); //交由每個POJO類的equals()比較完成
}
@Override
public int hashCode(Object x) throws HibernateException {
return x.hashCode();
}
@Override
public boolean isMutable() {
return true;
}
@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
throws HibernateException, SQLException {
// 當取得數據之後需要將數據變爲List集合
return this.disassemble(rs.getString(names[0]));
}
@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
throws HibernateException, SQLException {
//
if( value == null){
st.setNull(index, Types.NULL);
}else{
st.setString(index, this.assemble(session, value).toString());
}
}
@Override
public Object replace(Object original, Object target, Object owner) throws HibernateException {
return original;
}
@Override
public Class returnedClass() {
return List.class;
}
@Override
public int[] sqlTypes() {
return new int[]{Types.VARCHAR};
}
}
隨後修改之前的Member.java類中定義的轉換器。
@Column(name = "memails", length = 65535)
@Type(type="org.lks.usertype.ListAndJSONUserType")
public List<String> getMemails() {
return this.memails;
}
實現了JSON與List的轉換,實際上這種轉換的意義很大,因爲很多時候前臺頁面需要的只是一個JSON結構,那麼這樣如果數據庫裏面直接保存的就是JSON數據,那麼前臺直接讀取JSON總比要通過對象轉換更方便。