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).