@Entity
public class Item {
    private UUID uuid;
}

public class DialectResolver extends BasicDialectResolver {

    public DialectResolver() {
        super("PostgreSQL", PostgreSQLDialect.class);
    }

    public static class PostgreSQLDialect extends org.hibernate.dialect.PostgreSQLDialect {
        public PostgreSQLDialect() {
            addTypeOverride(new PostgresUUIDType() {
                @Override
                protected boolean registerUnderJavaType() {
                    return true;
                }
            });
        }
    }
}

package  net.zorq.censeo.domain;

import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.descriptor.ValueBinder;
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.UUIDTypeDescriptor;
import org.hibernate.type.descriptor.sql.BasicBinder;
import org.hibernate.type.descriptor.sql.BasicExtractor;
import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.UUID;

/**
* @author David Beaumont
* @see org.hibernate.type.PostgresUUIDType
*/
public class UUIDType extends AbstractSingleColumnStandardBasicType<UUID> {
    public static final UUIDType INSTANCE = new UUIDType();

    public UUIDType() {
        super( UUIDSqlTypeDescriptor.INSTANCE, UUIDTypeDescriptor.INSTANCE );
    }

    @Override
    public String getName() {
        return "custom-uuid";
    }

    public static class UUIDSqlTypeDescriptor implements SqlTypeDescriptor {
        public static final UUIDSqlTypeDescriptor INSTANCE = new UUIDSqlTypeDescriptor();

        @Override
        public int getSqlType() {
            return Types.OTHER;
        }

        @Override
        public boolean canBeRemapped() {
            return true;
        }

        @Override
        public <X> ValueBinder<X> getBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
            return new BasicBinder<X>( javaTypeDescriptor, this ) {
                @Override
                protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException {
                    /**
                     * This check ensures the normal path is taken for UUIDs on
                     * other databases. This is the single place where this
                     * class differs from that bundled in Hibernate at
                     * org.hibernate.type.PostgresUUIDType
                     */
                    if(st.getConnection().getMetaData().getDriverName().equals("org.postgresql.Driver")) {
                        st.setObject( index, javaTypeDescriptor.unwrap( value, UUID.class, options ), Types.OTHER );
                    } else {
                        st.setObject( index, javaTypeDescriptor.unwrap( value, UUID.class, options ));
                    }

                }
            };
        }

        @Override
        public <X> ValueExtractor<X> getExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
            return new BasicExtractor<X>( javaTypeDescriptor, this ) {
                @Override
                protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
                    return javaTypeDescriptor.wrap( rs.getObject( name ), options );
                }
            };
        }
    }
}

package net.zorq.censeo.util;

import org.hibernate.HibernateException;

import java.sql.Types;

/**
* Needed to keep UUIDs in H2 working after specifying a user type to make
* UUIDs use Postgres' native type in production.
* This needs doing because in Hibernate 4 you can no longer add type overrides
* per dialect. See: https://forum.hibernate.org/viewtopic.php?p=2451813
* @see net.zorq.censeo.domain.UUIDType
* @author David Beaumont
*/
public class H2Dialect extends org.hibernate.dialect.H2Dialect {

    public String getTypeName(int code, long length, int precision, int scale) throws HibernateException {
        if(code == Types.OTHER) {
            return "binary(16)";
        } else {
            return super.getTypeName(code, length, precision, scale);
        }
    }

}

public class PostgresUuidDialect extends PostgreSQL9Dialect {

    @Override
    public void contributeTypes(final TypeContributions typeContributions, final ServiceRegistry serviceRegistry) {
        super.contributeTypes(typeContributions, serviceRegistry);
        typeContributions.contributeType(new InternalPostgresUUIDType());
    }

    protected static class InternalPostgresUUIDType extends PostgresUUIDType {

        @Override
        protected boolean registerUnderJavaType() {
            return true;
        }
    }
}