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总比要通过对象转换更方便。