handy

<hibernate-mapping package="streaming.entity">
  <class name="Foo">
     <id column="id" length="36" name="id">
      <generator class="uuid"/>
    </id>
    <property name="data"  type="CustomBlobType">
         <column name="data" sql-type="bytea"></column>
    </property>
  </class>
</hibernate-mapping>

package streaming.type;

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

import streaming.type.BlobStream;

import org.springframework.jdbc.support.lob.LobCreator;
import org.springframework.jdbc.support.lob.LobHandler;
import org.springframework.orm.hibernate3.support.AbstractLobType;

public class CustomBlobType extends AbstractLobType {

	//called when the column is to be retrieved from db
	protected Object nullSafeGetInternal(ResultSet rs, String[] names, Object owner, LobHandler lobHandler)
					throws SQLException {

		InputStream is = lobHandler.getBlobAsBinaryStream(rs, names[0]);

		return new BlobStream(is);
	}

	//called when the data is to be stroed in db
	protected void nullSafeSetInternal(PreparedStatement ps, int index, Object value, LobCreator lobCreator)
					throws SQLException {
		if (value != null) {
			BlobStream blob = (BlobStream) value;
			lobCreator.setBlobAsBinaryStream(ps, index, blob.getStream(), blob.getLength());

		} else {
			lobCreator.setBlobAsBytes(ps, index, null);
		}
	}

	/**
	 * defines what type of object that this class returns or gets as a a parameter
	 * when the above methods are called.
	 *
	 * @return Class
	 */
	public Class returnedClass() {
		return BlobStream.class;
	}

	/**
	 * Return the SQL type codes for the columns mapped by this type. The codes
	 * are defined on <tt>java.sql.Types</tt>.
	 *
	 * @see java.sql.Types
	 * @return int[] the typecodes
	 */
	public int[] sqlTypes() {
		return new int[] { Types.BLOB };
	}
}

 <bean id="defaultLobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler" />
 <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >
		<property name="lobHandler" ref="deafultLobHandler"/>
		<property name="dataSource" ref="dataSource" />
		<property name="mappingLocations" ref="mappingLocations"/>
		<property name="hibernateProperties">
		...
		</property>
</bean>

<typedef name="CustomBlobType" class="streaming.type.CustomBlobType"></typedef>

package streaming.handler;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.apache.commons.dbcp.PoolableConnection;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.postgresql.PGConnection;
import org.postgresql.jdbc3.Jdbc3Connection;
import org.postgresql.largeobject.LargeObject;
import org.postgresql.largeobject.LargeObjectManager;
import org.springframework.jdbc.support.lob.AbstractLobHandler;
import org.springframework.jdbc.support.lob.LobCreator;
import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;

public class PostgresLobHandler extends AbstractLobHandler {

	protected final Log logger = LogFactory.getLog(getClass());

	private NativeJdbcExtractor nativeJdbcExtractor;

	/**
	 * @param nativeJdbcExtractor
	 *            the nativeJdbcExtractor to set
	 */
	public void setNativeJdbcExtractor(NativeJdbcExtractor nativeJdbcExtractor) {
		this.nativeJdbcExtractor = nativeJdbcExtractor;
	}

	public InputStream getBlobAsBinaryStream(ResultSet rs, int columnIndex) throws SQLException {

		InputStream is = null;
		try {
			PGConnection pgConn = getPostgresConnection(rs.getStatement());
			if (pgConn != null) {
				// Get the Large Object Manager to perform operations with
				LargeObjectManager lobj = pgConn.getLargeObjectAPI();

				long oid = rs.getLong(columnIndex);
				LargeObject obj = lobj.open(oid, LargeObjectManager.READ);
				is = obj.getInputStream();
			}

		} catch (ClassNotFoundException e) {
			this.logger.error("Error", e);
		}
		return is;
	}
	//other methods

	/**
	 * Retrieve the underlying PGConnection, using a NativeJdbcExtractor if set.
	 */
	protected PGConnection getPostgresConnection(Statement st) throws SQLException, ClassNotFoundException {

		PGConnection pgConn = null;
		Connection conn = (this.nativeJdbcExtractor != null) ? this.nativeJdbcExtractor
						.getNativeConnectionFromStatement(st) : st.getConnection();

		if (conn instanceof PoolableConnection) {
			PoolableConnection poolConn = (PoolableConnection) conn;
			Connection innermostDelegate = poolConn.getInnermostDelegate();
			if (innermostDelegate instanceof PGConnection) {
				pgConn = (PGConnection) innermostDelegate;

			}
		}
		return pgConn;
	}

	protected class PostgresLobCreator implements LobCreator {

		public void setBlobAsBytes(PreparedStatement ps, int paramIndex, byte[] content) throws SQLException {

			ps.setBytes(paramIndex, content);
			if (PostgresLobHandler.this.logger.isDebugEnabled()) {
				PostgresLobHandler.this.logger.debug(content != null ? "Set bytes for BLOB with length "
								+ content.length : "Set BLOB to null");
			}
		}

		public void setBlobAsBinaryStream(PreparedStatement ps, int paramIndex, InputStream binaryStream,
						int contentLength) throws SQLException {

			try {
				// All LargeObject API calls must be within a transaction block
				PGConnection pgConn = getPostgresConnection(ps);
				if (pgConn != null) {

					// Get the Large Object Manager to perform operations with
					LargeObjectManager lobj = pgConn.getLargeObjectAPI();

					// Create a new large object
					long oid = lobj.createLO(LargeObjectManager.READ | LargeObjectManager.WRITE);

					// Open the large object for writing
					LargeObject obj = lobj.open(oid, LargeObjectManager.WRITE);

					// Copy the data from the file to the large object
					byte buf[] = new byte[2048];
					int s, tl = 0;
					while ((s = binaryStream.read(buf, 0, 2048)) > 0) {
						obj.write(buf, 0, s);
						tl += s;
					}

					// Close the large object
					obj.close();
					ps.setLong(paramIndex, oid);
				}
			} catch (ClassNotFoundException e) {
				PostgresLobHandler.this.logger.error("Error", e);
			} catch (IOException ex) {
				PostgresLobHandler.this.logger.error("Error", ex);
			}

		}

		// other methods

		public void close() {
			PostgresLobHandler.this.logger.debug("Closing DefaultLobCreator");
			// nothing to do here
		}
	}
}

 <bean id="postgresLobHandler" class="streaming.handler.PostgresLobHandler" />
 <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >
		<property name="lobHandler" ref="postgresLobHandler"/>
		<property name="dataSource" ref="dataSource" />
		<property name="mappingLocations" ref="mappingLocations"/>
		<property name="hibernateProperties">
		...
		</property>
</bean>