Hibernate: Custom Collection Types
At 11:50 PM on Apr 19, 2005, R.J. Lorimer
On Monday's tip ( Hibernate: Discriminators and Table-Per-Subclass ) it was claimed by a reader that one major failing of Hibernate was that you couldn't inject your own collection types when faced with a list, set, map, or other collection mapping in your hibernate mapping file. As of Hibernate 3 this statement is 100% wrong. While there is a small degree of effort on your part, it is most-decidedly possible. I plan to show you how today (as I couldn't leave it alone myself).
The first step is to implement the org.hibernate.usertype.UserCollectionType interface. This API helps hibernate work with your collection without concern of the implementation. Truthfully, Hibernate doesn't care at all what API your collection implementation actually implements - it could be a com.javalobby.tnt.WidgerFurmuzzitContainer , and Hibernate could still map it. However, my goal here is to show you how to replace a default implementation with a custom one.
Since I have no implementation of java.util.Set to use, I'll just refer to the Javolution javolution.util.FastSet , which has the benefit of being arguably faster than a standard set implementation.
Here is an implementation of UserCollectionType that returns a fast set. As you are looking below, note how much possibility there is for common subclasses that provide custom set/list/map implementations:
package com.javalobby.tnt.hib;
import java.util.*;
import javolution.util.FastSet;
import org.hibernate.HibernateException;
import org.hibernate.collection.*;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.usertype.UserCollectionType;
public class FastSetType implements UserCollectionType {
public FastSetType() {
}
// could be common for all collection implementations.
public boolean contains(Object collection, Object obj) {
Set set = (Set)collection;
return set.contains(obj);
}
// could be common for all collection implementations.
public Iterator getElementsIterator(Object collection) {
return ((Set)collection).iterator();
}
// common for list-like collections.
public Object indexOf(Object collection, Object obj) {
return null;
}
// factory method for certain collection type.
public Object instantiate() {
return new FastSet();
}
// standard wrapper for collection type.
public PersistentCollection instantiate(SessionImplementor session, CollectionPersister persister) throws HibernateException {
// Use hibernate's built in persistent set implementation
//wrapper
return new PersistentSet(session);
}
// could be common implementation for all collection implementations
public void replaceElements(
Object collectionA,
Object collectionB,
CollectionPersister persister,
Object owner,
Map copyCache,
SessionImplementor implementor) throws HibernateException {
Set setA = (Set)collectionA;
Set setB = (Set)collectionB;
setB.clear();
setB.addAll(setA);
}
// standard wrapper for collection type.
public PersistentCollection wrap(SessionImplementor session, Object colllection) {
// Use hibernate's built in persistent set implementation
//wrapper.
return new PersistentSet(session, (Set)colllection);
}
}
Then, we simply need to tell our mapping file to use our custom type - I'll reuse the mapping file from Monday's tip:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.javalobby.tnt.hib.User" table="USER" lazy="false">
<id name="id" type="long" column="ID">
<generator class="identity" />
</id>
<discriminator column="type" type="string"/>
<property name="firstName" column="first_name"/>
<property name="lastName" column="last_name"/>
<subclass name="com.javalobby.tnt.hib.Employee" discriminator-value="employee">
<join table="employee">
<key column="id"/>
<property name="jobTitle" column="job_title"/>
<many-to-one name="supervisor" column="supervisor_id" not-null="true" />
</join>
<subclass name="com.javalobby.tnt.hib.Employer" discriminator-value="employer">
<set
name="subordinates"
collection-type="com.javalobby.tnt.hib.FastSetType"
>
<key column="supervisor_id" not-null="true"/>
<one-to-many class="com.javalobby.tnt.hib.Employee"/>
</set>
<join table="employer">
<key column="id"/>
<property name="companyCarBrand" column="company_car_brand"/>
</join>
</subclass>
</subclass>
</class>
</hibernate-mapping>
That's it! Now, when Hibernate hits the set declaration, it will try to use your UserCollectionType implementation to create the collection, and then subsequently wrap that collection with the persistent collection type.
Note that to support a custom collection type (not List, Set, or Map), you'll not only have to provide custom implementations of all methods in the UserCollectionType, but you also need to provide an implementation of PersistentCollection (since Hibernate only ships with implementations for standard Java collections).
