create table XMLROW_COLLECTED (
XMLROWID NUMBER primary key,
XMLCONTENT XMLTYPE);

public class HibernateXMLType implements UserType, Serializable {
//  all other methods are ommitted at present for brevity

public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
         throws HibernateException, SQLException {
      XMLType xmlType = null;
      Document doc = null;
      try {         
         OPAQUE value = null;
         OracleResultSet ors = null;
         if (rs instanceof OracleResultSet) {
            ors = (OracleResultSet)rs;
         } else {
            throw new UnsupportedOperationException("ResultSet needs to be of type OracleResultSet");
         }
         
         value = ors.getOPAQUE(names[0]);
         xmlType = XMLType.createXML(value);
         Clob xmlClob = xmlType.getClobVal();
         doc = XMLUtils.createDocumentObject(xmlClob.getCharacterStream());
      }finally {
         if (null != xmlType) {
            xmlType.close();
         }
      }
      
      return doc;
   }

public void nullSafeSet(PreparedStatement stmt, Object value, int index)
         throws HibernateException, SQLException {
      
      XMLType xmlType = null;
      try {
         //If the value is null then set NULL and return
         if (null == value) {
            stmt.setNull(index, OracleTypes.OPAQUE, "SYS.XMLTYPE");
            return;
         }
         
         if (stmt instanceof OraclePreparedStatement) {
            xmlType = XMLType.createXML(stmt.getConnection(), XMLUtils.toXMLString((Document)value));
            OraclePreparedStatement oracleStmt = (OraclePreparedStatement)stmt;
            oracleStmt.setObject(index, xmlType);
         }else {
            throw new HibernateException("PreparedStatement object must be a OraclePreparedStatement");
         }
      }finally {
         if (null != xmlType) {
            xmlType.close();
         }
      }
   }

public class XMLRowCollected implements Serializable {
   private Long xmlID;
   private HibernateXMLType xmlData;
   
   // Rest is getter/setter methods and default constructor
}

<hibernate-mapping>
   <class name="com.goofy.test.xml.XMLRowCollected" table="TESTINGXMLTYPE">
      <id name="xmlID" unsaved-value="null" type="long">
         <column name="XMLROWID" not-null="true"/>
         <generator class="increment"/>
      </id>
      <property name="xmlData"
         type="com.goofy.test.xml.HibernateXMLType"
         column="XMLCONTENT"
         update="true"
         access="property"
         insert="true"/>
   </class>
</hibernate-mapping>

XMLRowCollected bean = new XMLRowCollected();
bean.setXmlData(xmlDocument);
session.save(bean);

Query query = session.createSQLQuery("select XMLCONTENT from XMLROW_COLLECTED where XMLROWID=1");
List results = query.list();

        <property name="connection.url">jdbc:oracle:thin:@nlsun83:1532:ENID11</property>
        <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
        <property name="connection.pool_size">5</property>
        <property name="show_sql">true</property>

...
<property name="xmlData" type="com.keys.dao.customtypes.HibernateXMLType">
            <column name="DYNAMIC_DATA" />
        </property>

...

package com.keys.dao.customtypes;

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

import oracle.jdbc.OraclePreparedStatement;
import oracle.jdbc.OracleResultSet;
import oracle.sql.OPAQUE;

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;

public class HibernateXMLType implements UserType {
   
    private static final Logger logger = Logger.getLogger(HibernateXMLType.class);
   
    public static final int[] SQL_TYPES = {Types.CLOB};

    public int[] sqlTypes() {
        return SQL_TYPES;
    }

    public Class returnedClass() {
        return java.lang.String.class;
    }

    public boolean equals(Object arg0, Object arg1) throws HibernateException {
        return arg0 == arg1;
    }

    public int hashCode(Object arg0) throws HibernateException {
        return arg0.hashCode();
    }

    public Object nullSafeGet( ResultSet rs, String [ ] names, Object arg2 ) throws HibernateException, SQLException {
       
        logger.debug(rs.getClass().getName());
       
        org.apache.tomcat.dbcp.dbcp.DelegatingResultSet drs = (org.apache.tomcat.dbcp.dbcp.DelegatingResultSet)rs;
        OracleResultSet ors = (OracleResultSet)drs.getInnermostDelegate();
        OPAQUE op = ors.getOPAQUE ( names[0] );
       
        if(op != null) {
            oracle.xdb.XMLType xt = oracle.xdb.XMLType.createXML ( op );
            return xt.getStringVal();
        } else {
            return null;
        }
       
        /*  This is the code to return document instead of just a plain string

        DOMReader reader = new DOMReader ();
        org.dom4j.Document document = reader.read ( xt.getDOM () );
        return document.getRootElement ();// getClobVal();
       
        */

    }



    public void nullSafeSet( PreparedStatement st, Object value, int index ) throws HibernateException, SQLException {

        String conName = "";
        OraclePreparedStatement ost = null;
       
        try {
       
            org.apache.tomcat.dbcp.dbcp.DelegatingPreparedStatement dpstmt = (org.apache.tomcat.dbcp.dbcp.DelegatingPreparedStatement)st;
            ost = (OraclePreparedStatement)dpstmt.getInnermostDelegate();

            Connection conn = ost.getConnection ();
            conName = conn.getClass ().getName ();

            // Get the oracle connection class for checking
            Class oracleConnectionClass = Class.forName ( "oracle.jdbc.driver.OracleConnection" );

            /*  This is code to insert a Document object rather than just a plain string
            if ( oracleConnectionClass.isAssignableFrom ( conn.getClass () ) ) {
                ost.setOPAQUE ( index, oracle.xdb.XMLType.createXML ( conn, ( (Element) value ).asXML () ) );// (OPAQUE)
            }
            */
           
            if(value != null) {
                if ( oracleConnectionClass.isAssignableFrom ( conn.getClass () ) ) {
                    ost.setOPAQUE ( index, oracle.xdb.XMLType.createXML(conn, (String)value));// (OPAQUE)
                } else {
                    throw new HibernateException ( "JDBC connection object must be a oracle.jdbc.OracleConnection !! "
                            + "Connection class is " + conn.getClass ().getName () );
                }
            }
           
         

        } catch ( SQLException e ) {
            logger.error("SQL Exception: " + e, e);
            throw e;
        } catch ( HibernateException e ) {
            logger.error("Hibernate Exception: " + e, e);
            throw e;
        } catch ( ClassCastException e ) {
            logger.error("Class Cast Exception:"  + e, e);
            // could not find the class with reflection
            throw new HibernateException ( "Unable to case a required class.\n" + e.getMessage () + "  -- value class:"
                    + conName );
        } catch ( ClassNotFoundException e ) {
            // could not find the class with reflection
            logger.error("ClassNotFoundException:"  + e, e);
            throw new HibernateException ( "Unable to find a required class.\n" + e.getMessage () );
        }
    }


...


}

public class ModelLocale  {

public String getXmlData() {
        return xmlData;
    }

    public void setXmlData(String xmlData) {
        this.xmlData = xmlData;
    }


}

   /**
    * Finds a model's detailed information by model id
    */
   public ModelLocale findById(ModelLocaleId id) throws DAOException {
      logger.debug("Entering findById() for id = " + id);

      Session session = sessionFactory.openSession();
      Transaction tx = null;

      ModelLocale model = null;

      try {
         tx = session.beginTransaction();

         model = (ModelLocale) session.get(ModelLocale.class, id);

         tx.commit();
      } catch (Exception e) {
         logger.error("Database error shile searchin for model id = " + id + ": " + e);
         if (tx != null)
            tx.rollback();
         throw new DAOException(e);
      } finally {
         session.close();
      }

      return model;
   }