<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="hibernate.test.CompositeUserTypeEntity" table="CompositeUserType">
<id name="id" column="id" type="string">
   <generator class="uuid.hex"/>
</id>

<property name="usertype" type="hibernate.test.MyCompositeUserType">
    <column name="intValue"/>
    <column name="floatValue"/>
    <column name="datetimeValue"/>
    <column name="stringValue"/>
</property>
</class>
</hibernate-mapping>

package hibernate.test;

import java.io.Serializable;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;

public class CompositeUserTypeEntity implements Serializable {

    private String id;

    private MyCompositeUserType usertype;

    public CompositeUserTypeEntity() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
   
    public MyCompositeUserType getUsertype() {
        return usertype;
    }

    public void setUsertype(MyCompositeUserType usertype) {
        this.usertype = usertype;
    }
   
    public String toString() {
        return new ToStringBuilder(this).append("id", getId()).toString();
    }

    public boolean equals(Object other) {
        if (!(other instanceof CompositeUserTypeEntity)) return false;
        CompositeUserTypeEntity castOther = (CompositeUserTypeEntity) other;
        return new EqualsBuilder().append(this.getId(), castOther.getId())
                .isEquals();
    }

    public int hashCode() {
        return new HashCodeBuilder().append(getId()).toHashCode();
    }

}

CREATE TABLE [dbo].[CompositeUserType] (
   [id] [char] (32) COLLATE Chinese_PRC_CI_AS NOT NULL ,
   [intValue] [int] NULL ,
   [floatValue] [float] NULL ,
   [stringValue] [varchar] (100) COLLATE Chinese_PRC_CI_AS NULL ,
   [datetimeValue] [datetime] NULL
) ON [PRIMARY]

package hibernate.test;

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

import net.sf.hibernate.CompositeUserType;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.engine.SessionImplementor;
import net.sf.hibernate.type.Type;

import org.apache.commons.lang.builder.EqualsBuilder;

public class MyCompositeUserType implements CompositeUserType {

    public String[] getPropertyNames() {
        return new String[] { "intValue", "floatValue", "stringValue",
                "datetimeValue"};
    }

    public Type[] getPropertyTypes() {
        return new Type[] { Hibernate.INTEGER, Hibernate.FLOAT, Hibernate.STRING,
                Hibernate.TIMESTAMP};
    }

    public Object getPropertyValue(Object component, int property)
            throws HibernateException {
        Component c = (Component) component;
        switch (property) {
        case 0:
            return c.getIntValue();
        case 1:
            return c.getFloatValue();
        case 2:
            return c.getStringValue();
        case 3:
            return c.getDatetimeValue();
        }
        throw new IllegalArgumentException();
    }

    public void setPropertyValue(Object component, int property, Object value)
            throws HibernateException {
        Component c = (Component) component;
        switch (property) {
        case 0:
            c.setIntValue(((Integer) value));
            return;
        case 1:
            c.setFloatValue(((Float) value));
            return;
        case 2:
            c.setStringValue(((String) value));
            return;
        case 3:
            c.setDatetimeValue(((java.sql.Date) value));
            return;
        }
        throw new IllegalArgumentException();
    }

    public Class returnedClass() {
        return Component.class;
    }

    public boolean equals(Object x, Object y) throws HibernateException {
        if (x == y) return true;
        if (x == null || y == null) return false;

        Component c1 = (Component) x;
        Component c2 = (Component) y;

        return new EqualsBuilder().append(c1.getIntValue(), c2.getIntValue())
                .append(c1.getFloatValue(), c2.getFloatValue()).append(
                        c1.getStringValue(), c2.getStringValue()).append(
                        c1.getDatetimeValue(), c2.getDatetimeValue())
                .isEquals();
    }

    public Object nullSafeGet(ResultSet rs, String[] names,
            SessionImplementor session, Object owner)
            throws HibernateException, SQLException {       
        Integer intValue = (Integer)Hibernate.INTEGER.nullSafeGet(rs, names[0]);
        Float floatValue = (Float)Hibernate.FLOAT.nullSafeGet(rs, names[1]);
        String stringValue = (String)Hibernate.STRING.nullSafeGet(rs, names[2]);
        java.sql.Date datetimeValue = (java.sql.Date)Hibernate.TIMESTAMP.nullSafeGet(rs, names[3]);
       
        Component c = new Component();
        c.setIntValue(intValue);
        c.setFloatValue(floatValue);
        c.setStringValue(stringValue);
        c.setDatetimeValue(datetimeValue);
        return c;
    }

    public void nullSafeSet(PreparedStatement st, Object value, int index,
            SessionImplementor session) throws HibernateException, SQLException {
        Component c;
        if (value == null)
            c = new Component();
        else
            c = (Component) value;

        Hibernate.INTEGER.nullSafeSet(st, c.getIntValue(), index);
        Hibernate.FLOAT.nullSafeSet(st, c.getFloatValue(), index + 1);
        Hibernate.STRING.nullSafeSet(st, c.getStringValue(), index + 2);
        Hibernate.TIMESTAMP.nullSafeSet(st, c.getDatetimeValue(), index + 3);
    }

    public Object deepCopy(Object value) throws HibernateException {
        Component result = null;
        if (value == null) {
            result = null;
        } else {
            Component c = (Component) value;
            result = new Component();
            result.setIntValue(c.getIntValue());
            result.setFloatValue(c.getFloatValue());
            result.setStringValue(c.getStringValue());
            result.setDatetimeValue(c.getDatetimeValue());
        }
        return result;
    }

    public boolean isMutable() {
        return true;
    }

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

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

}

package hibernate.test;

import java.io.Serializable;
import java.sql.Date;

public class Component implements Serializable {
    private Integer intValue;
    private Float floatValue;
    private String stringValue;
    private Date datetimeValue;
   
    public Date getDatetimeValue() {
        return datetimeValue;
    }

    public void setDatetimeValue(Date datetimeValue) {
        this.datetimeValue = datetimeValue;
    }

    public Float getFloatValue() {
        return floatValue;
    }

    public void setFloatValue(Float floatValue) {
        this.floatValue = floatValue;
    }

    public Integer getIntValue() {
        return intValue;
    }

    public void setIntValue(Integer intValue) {
        this.intValue = intValue;
    }

    public String getStringValue() {
        return stringValue;
    }

    public void setStringValue(String stringValue) {
        this.stringValue = stringValue;
    }
}