stereovolumetype.java

Hiberante程序高手秘籍的源代码

package com.oreilly.hh;

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

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;

/**
 * Manages persistence for the {@link StereoVolume} composite type.
 */
public class StereoVolumeType implements CompositeUserType {
	
    /**
     * Get the names of the properties that make up this composite type,
     * and that may be used in a query involving it.
     */
    public String[] getPropertyNames() {
        // Allocate a new response each time, because arrays are mutable
        return new String[] { "left", "right" };
    }

    /**
     * Get the types associated with the properties that make up this
     * composite type.
     *
     * @return the types of the parameters reported by
     *         {@link #getPropertynames}, in the same order.
     */
    public Type[] getPropertyTypes() {
        return new Type[] { Hibernate.SHORT, Hibernate.SHORT };
    }
    
    /**
     * Look up the value of one of the properties making up this composite
     * type.
     *
     * @param component a {@link StereoVolume} instance being managed.
     * @param property the index of the desired property.
     * @return the corresponding value.
     * @see #getPropertyNames
     */
    public Object getPropertyValue(Object component, int property) {
        StereoVolume volume = (StereoVolume)component;
        short result;

        switch (property) {

        case 0:
            result = volume.getLeft();
            break;
            
        case 1:
            result = volume.getRight();
            break;

        default:
            throw new IllegalArgumentException("unknown property: " +
                                               property);
        }

        return new Short(result);
    }

    /**
     * Set the value of one of the properties making up this composite
     * type.
     *
     * @param component a {@link StereoVolume} instance being managed.
     * @param property the index of the desired property.
     * @object value the new value to be established.
     * @see #getPropertyNames
     */
    public void setPropertyValue(Object component, int property, Object value)
    {
        StereoVolume volume = (StereoVolume)component;
        short newLevel = ((Short)value).shortValue();
        switch (property) {

        case 0:
            volume.setLeft(newLevel);
            break;
            
        case 1:
            volume.setRight(newLevel);
            break;

        default:
            throw new IllegalArgumentException("unknown property: " +
                                               property);
        }
    }

    /**
     * Determine the class that is returned by {@link #nullSafeGet}.
     *
     * @return {@link StereoVolume}, the actual type returned
     * by {@link #nullSafeGet}.
     */
    public Class returnedClass() {
		return StereoVolume.class;
    }
	
    /**
     * Compare two instances of the class mapped by this type for persistence
     * "equality".
     *
     * @param x first object to be compared.
     * @param y second object to be compared.
     * @return <code>true</code> iff both represent the same volume levels.
     * @throws ClassCastException if x or y isn't a {@link StereoVolume}.
     */
    public boolean equals(Object x, Object y) {
        if (x == y) {  // This is a trivial success
            return true;
        }
        if (x == null || y == null) {  // Don't blow up if either is null!
            return false;
        }
        // Now it's safe to delegate to the class' own sense of equality
        return ((StereoVolume)x).equals(y);
    }
	
    /**
     * Return a deep copy of the persistent state, stopping at
     * entities and collections.
     *
     * @param value the object whose state is to be copied.
     * @return the same object, since enumeration instances are singletons.
     * @throws ClassCastException for non {@link StereoVolume} values.
     */
    public Object deepCopy(Object value) {
        if (value == null) return null;
        StereoVolume volume = (StereoVolume)value;
        return new StereoVolume(volume.getLeft(), volume.getRight());
    }
	
    /**
     * Indicates whether objects managed by this type are mutable.
     *
     * @return <code>true</code>, since {@link StereoVolume} is mutable.
     */
    public boolean isMutable() {
        return true;
    }
	
    /**
     * Retrieve an instance of the mapped class from a JDBC {@link ResultSet}.
     *
     * @param rs the results from which the instance should be retrieved.
     * @param names the columns from which the instance should be retrieved.
     * @param session, an extension of the normal Hibernate session interface
     *        that gives you much more access to the internals.
     * @param owner the entity containing the value being retrieved.
     * @return the retrieved {@link StereoVolume} value, or <code>null</code>.
     * @throws HibernateException if there is a problem performing the mapping.
     * @throws SQLException if there is a problem accessing the database.
     */
    public Object nullSafeGet(ResultSet rs, String[] names,
                              SessionImplementor session, Object owner)
	throws HibernateException, SQLException
    {
        Short left = (Short) Hibernate.SHORT.nullSafeGet(rs, names[0]);
        Short right = (Short) Hibernate.SHORT.nullSafeGet(rs, names[1]);
		
        if (left == null || right == null) {
            return null;  // We don't have a specified volume for the channels
        }

        return new StereoVolume(left.shortValue(), right.shortValue());
    }
	
    /**
     * Write an instance of the mapped class to a {@link PreparedStatement}, 
     * handling null values.
     *
     * @param st a JDBC prepared statement.
     * @param value the StereoVolume value to write.
     * @param index the parameter index within the prepared statement at which
     *        this value is to be written.
     * @param session, an extension of the normal Hibernate session interface
     *        that gives you much more access to the internals.
     * @throws HibernateException if there is a problem performing the mapping.
     * @throws SQLException if there is a problem accessing the database.
     */
    public void nullSafeSet(PreparedStatement st, Object value, int index,
                            SessionImplementor session)
	throws HibernateException, SQLException
    {
        if (value == null) {
            Hibernate.SHORT.nullSafeSet(st, null, index);
            Hibernate.SHORT.nullSafeSet(st, null, index + 1);
        }
        else {
            StereoVolume vol = (StereoVolume)value;
            Hibernate.SHORT.nullSafeSet(st, new Short(vol.getLeft()), index);
            Hibernate.SHORT.nullSafeSet(st, new Short(vol.getRight()),
                                        index + 1);
        }
    }
	
    /**
     * Reconstitute a working instance of the managed class from the cache.
     *
     * @param cached the serializable version that was in the cache.
     * @param session, an extension of the normal Hibernate session interface
     *        that gives you much more access to the internals.
     * @param owner the entity containing the value being retrieved.
     * @return a copy of the value as a {@link StereoVolume} instance.
     */
    public Object assemble(Serializable cached, SessionImplementor session,
                           Object owner)
    {
        // Our value type happens to be serializable, so we have an easy out.
        return deepCopy(cached);
    }

    /**
     * Translate an instance of the managed class into a serializable form to
     * be stored in the cache.
     *
     * @param session, an extension of the normal Hibernate session interface
     *        that gives you much more access to the internals.
     * @param value the StereoVolume value to be cached.
     * @return a serializable copy of the value.
     */
    public Serializable disassemble(Object value,
                                    SessionImplementor session) {
        return (Serializable) deepCopy(value);
    }
}