10 13Hibernate之轉換器

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總比要通過對象轉換更方便。