The base for BLOB of Json in Hibernate/JPA2.1

MyClobType.java

import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.usertype.UserType;

import java.io.Reader;
import java.io.Serializable;
import java.io.StringReader;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Scanner;

public abstract class MyClobType<T> implements UserType {

    public abstract String toString(T value);

    public abstract T fromString(String clob);

    public abstract T copy(T value);

    public abstract Class<T> supportedClass();

    protected final T cast(Object value) {
        return supportedClass().cast(value);
    }

    protected final boolean isSupported(Object value) {
        return value != null && (supportedClass().isInstance(value) || supportedClass().isAssignableFrom(value.getClass()));
    }

    @Override
    public final int[] sqlTypes() {
        return new int[] {Types.CLOB};
    }

    @Override
    public final Class returnedClass() {
        return supportedClass();
    }


    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return ObjectUtils.equals(x, y);
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        return ObjectUtils.hashCode(x);
    }

    @Override
    public final Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session,
        Object owner) throws HibernateException, SQLException {
        Reader reader = rs.getCharacterStream(names[0]);
        if (reader != null) {
            String next = new Scanner(reader).useDelimiter("\\A").next();
            if (StringUtils.isNotBlank(next)) {
                return fromString(next);
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

    @Override
    public final void nullSafeSet(PreparedStatement st, Object value, int index,
        SessionImplementor session) throws HibernateException, SQLException {
        if (isSupported(value)) {
            String string = toString(cast(value));
            st.setCharacterStream(index, new StringReader(string), string.length());
        } else {
            st.setNull(index, sqlTypes()[0]);
        }
    }



    @Override
    public final Object deepCopy(Object value) throws HibernateException {
        if (isSupported(value)) {
            return copy(cast(value));
        } else {
            return null;
        }
    }

    @Override
    public final boolean isMutable() {
        return true;
    }

    @Override
    public final Serializable disassemble(Object value) throws HibernateException {
        return toString(cast(value));
    }



    @Override
    public final Object assemble(Serializable cached, Object owner) throws HibernateException {
        return fromString((String) cached);
    }

    @Override
    public final Object replace(Object original, Object target, Object owner) throws HibernateException {
        return deepCopy(original);
    }


}