java - PostgreSQL 自定义类型 + Hibernate 映射

Question

我正在使用 PostgreSQL (9.1) 和 Hibernate (4.1.4)。我想将我的自定义 PostgreSQL 类型映射到 Hibernate 中的对象。

我在 PostgreSQL 中创建了这样的类型:

create type nill_int as (value int8, nill varchar(100));

现在我想在 Hibernate 上映射这个类型:

package my;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.lang.ObjectUtils;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.type.IntegerType;
import org.hibernate.type.StringType;
import org.hibernate.type.Type;
import org.hibernate.usertype.CompositeUserType;

public class PGNillableIntegerType implements CompositeUserType {

    @Override
    public String[] getPropertyNames() {
        return new String[] {"value","nill"};
    }

    @Override
    public Type[] getPropertyTypes() {
        return new Type[] {IntegerType.INSTANCE, StringType.INSTANCE};
    }

    @Override
    public Object getPropertyValue(Object component, int property)
            throws HibernateException {
        if( component == null ) {
            return null;
        }

        final NillableInteger nillable = (NillableInteger)component;
        switch (property) {
            case 0: {
                return nillable.getValue();
            }
            case 1: {
                return nillable.getNill();
            }
            default: {
                throw new HibernateException("Invalid property index [" + property + "]");
            }
        }
    }

    @Override
    public void setPropertyValue(Object component, int property, Object value)
            throws HibernateException {
        if(component == null)
            return;

        final NillableInteger nillable = (NillableInteger) component;
        switch (property) {
            case 0: {
                nillable.setValue((Integer)value);
                break;
            }
            case 1: {
                nillable.setNill((String)value);
                break;
            }
            default: { 
                throw new HibernateException("Invalid property index [" + property + "]");
            }
        }
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names,
            SessionImplementor session, Object owner)
            throws HibernateException, SQLException {

        assert names.length == 2;
        Integer value = (Integer) IntegerType.INSTANCE.get(rs, names[0], session);
        String nill = (String) StringType.INSTANCE.get(rs, names[1], session);

        return new NillableInteger(value, nill);
    }

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index,
            SessionImplementor session) throws HibernateException, SQLException {
        if(value == null) {
            IntegerType.INSTANCE.set(st, null, index, session);
            StringType.INSTANCE.set(st, null, index + 1, session);
        } else {
            final NillableInteger nillable = (NillableInteger)value;
            IntegerType.INSTANCE.set(st, nillable.getValue(), index, session);
            StringType.INSTANCE.set(st, nillable.getNill(), index + 1, session);
        }
    }

    @Override
    public Class returnedClass() {
        return NillableInteger.class;
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return ObjectUtils.equals(x, y);
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        assert (x != null);
        return x.hashCode();
    }



    @Override
    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    @Override
    public boolean isMutable() {
        return false;
    }

    @Override
    public Serializable disassemble(Object value, SessionImplementor session)
            throws HibernateException {
        return (Serializable) value;
    }

    @Override
    public Object assemble(Serializable cached, SessionImplementor session,
            Object owner) throws HibernateException {
        return cached;
    }

    @Override
    public Object replace(Object original, Object target,
            SessionImplementor session, Object owner) throws HibernateException {
        return original;
    }


}

并在我的实体中使用它:

package my;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.TableGenerator;

import org.hibernate.annotations.Type;


@Entity
@Table(name = "test_test")
public class TestObj {

    @Id
    @GeneratedValue(strategy = GenerationType.TABLE, generator = "IdGenerator")
    @TableGenerator(
        name = "IdGenerator",
        pkColumnValue = "test",
        table="SeqTable",
        allocationSize=1, initialValue=1)
    private Long id;

    private String test;

    @Type(type = "my.PGNillableIntegerType")
    @Column(columnDefinition = "nill_int")
//  @Columns(columns = {
//          @Column(name = "val"),
//          @Column(name = "reason")
//  })
    private NillableInteger nill;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTest() {
        return test;
    }

    public void setTest(String test) {
        this.test = test;
    }

    public NillableInteger getNill() {
        return nill;
    }

    public void setNill(NillableInteger nill) {
        this.nill = nill;
    }

}

NillableInteger 看起来像这样:

package my;

import javax.persistence.Column;
import javax.persistence.Entity;

public class NillableInteger {

    private Integer value;
    private String nill;

    public NillableInteger() {

    }

    public NillableInteger(String str) {
        str = str.substring(1,str.length()-1);
        String[] splitted = str.split(",");
        value = Integer.parseInt(splitted[0]);
        nill = splitted[1];
    }

    public NillableInteger(Integer value, String nill) {
        this.value = value;
        this.nill = nill;
    }

    @Override
    public String toString() {
        return "(" + value + "," + nill + ")";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((nill == null) ? 0 : nill.hashCode());
        result = prime * result + ((value == null) ? 0 : value.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        NillableInteger other = (NillableInteger) obj;
        if (nill == null) {
            if (other.nill != null)
                return false;
        } else if (!nill.equals(other.nill))
            return false;
        if (value == null) {
            if (other.value != null)
                return false;
        } else if (!value.equals(other.value))
            return false;
        return true;
    }

    public String getNill() {
        return nill;
    }
    public void setNill(String nill) {
        this.nill = nill;
    }
    public Integer getValue() {
        return value;
    }
    public void setValue(Integer value) {
        this.value = value;
    }

}

这个配置会抛出这样的东西:

org.hibernate.MappingException: property mapping has wrong number of columns: my.TestObj.nill type: my.PGNillableIntegerType

当我在 TestObj 中使用 @Columns 注释而不是 @Column 时一切正常，但这会在 中创建两个单独的列>test_test 表(TestObj 映射表)，类型为integer 和character varying(255)。我想要实现的是，在表中将有一列类型为 nill_int(创建自定义 PostgreSQL 类型)并且 Java 对象将如上所示。

有什么想法吗？

谢谢，阿瑞克

Answer 1

好的，这就是我为实现上述目标所做的工作:我已将我的类型更改为如下所示:

package my;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;


public class PGNillableIntegerType implements UserType {

    @Override
    public int[] sqlTypes() {
        return new int[] { Types.OTHER };
    }

    @Override
    public Class returnedClass() {
        return NillableInteger.class;
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names,
            SessionImplementor session, Object owner)
            throws HibernateException, SQLException {

        return new NillableInteger(rs.getString(names[0]));
    }

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index,
            SessionImplementor session) throws HibernateException, SQLException {
        if(value == null) {
            st.setObject(index, null, Types.OTHER);
        } else {
            final NillableInteger nillable = (NillableInteger)value;
            st.setObject(index, nillable.toString(), Types.OTHER);
//          IntegerType.INSTANCE.set(st, nillable.getValue(), index, session);
//          StringType.INSTANCE.set(st, nillable.getNill(), index + 1, session);
        }
    }

    @Override
    public Object replace(Object original, Object target, Object owner)
            throws HibernateException {
        return original;
    }

    public Object assemble(Serializable cached, Object owner)
            throws HibernateException {
        return cached;
    }

    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    public Serializable disassemble(Object value) throws HibernateException {
        return (Serializable) value;
    }

    public boolean equals(Object arg0, Object arg1) throws HibernateException {
        return arg0.equals(arg1);
    }

    public int hashCode(Object object) throws HibernateException {
        return object.hashCode();
    }

    public boolean isMutable() {
        return false;
    }



}

现在您可以在 columnDefinition 中将 @Column 与 PostgreSQL 类型一起使用。不幸的是，问题是 hibernate 查询(经过一些搜索 - 我认为唯一的方法是使用 SQL 查询 like this - 如果有人知道如何使用 HQL 或标准来做到这一点，那就太好了......)。