ジェネリックを使ったHibernate +カスタムユーザタイプ

Question

私は冬眠するのが初めてです。私はDBとしてポストグルを使用しています。

私はテーブルUserを持っています。これには、jsonbタイプのメタデータと呼ばれる列が含まれています。

この列をオブジェクト（シリアライズ可能な）メタデータにマップしたいと思います。私はいくつかのチュートリアルを読んで、これを実現するカスタムuserTypeを実装する必要があることを知りました。

私はMyMetadataTypeを実装しました。今度はもう一度jsonbタイプの設定という別の列があります。この列を対応するObjectにマップするには、別のuserType実装が必要です。

次のような汎用クラスを持つことは可能ですか？そのようなすべての列のクラスは1つだけですか？

class MyCustomType<T> implements UserType 
{ 
... 
... 
} 

エンティティ定義ではどのように使用しますか？

@Entity 
@Table(name = "user") 
@TypeDefs({ @TypeDef(name = "MyCustomType", typeClass = MyCustomType<Metadata>.class) }) 
public class User extends BaseEntity implements Serializable 
{ 

    @Id 
    @Column(name = "id") 
    private int id; 

    @Column(name = "metadata") 
    @Type(type = "MyCustomeType") 
    private Metadata metadata; 

    ......... 
    ......... 
    ......... 

} 

前のSOの質問を見ることによって、私は次のクラスを思い付いた：

public class MyCustomType<T> implements UserType 
{ 
    protected static Conversion conversion = new JsonDataConversionImpl(); 
    private static final Logger logger = LogManager.getLogger(MyCustomType.class.getCanonicalName()); 

    @SuppressWarnings("unchecked") 
    private Class<T> genericType = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), MyCustomType.class); 

    /** 
    * Reconstruct an object from the cacheable representation. At the very least this method should 
    * perform a deep copy if the type is mutable. (optional operation) 
    * 
    * @param cached 
    *   the object to be cached 
    * @param owner 
    *   the owner of the cached object 
    * @return a reconstructed object from the cachable representation 
    * @throws HibernateException 
    */ 
    @Override 
    public Object assemble(Serializable cached, Object owner) throws HibernateException 
    { 
     return this.deepCopy(cached); 
    } 

    /** 
    * Return a deep copy of the persistent state, stopping at entities and st collections. It is 
    * not necessary to copy immutable objects, or null values, in which case it is safe to simple 
    * return the argument. 
    * 
    * @param value 
    *   the object to be cloned, which may be null 
    * @return object a copy 
    * @throws HibernateException 
    */ 
    @Override 
    public Object deepCopy(Object value) throws HibernateException 
    { 
     return value; 
    } 

    /** 
    * Transform the object into its cacheable representation. At the very least this method should 
    * perform a deep copy if the type is mutable. That may not be enough for some implementations, 
    * however; for example, associations must be cached as identifier values. (optional operation) 
    * 
    * @param value 
    *   the object to be cached 
    * @return a cachable representation of the object 
    * @throws HibernateException 
    */ 
    @Override 
    public Serializable disassemble(Object value) throws HibernateException 
    { 
     return (String) this.deepCopy(value); 
    } 

    /** 
    * Compare two instances of the class mapped by this type for persistence "equality". Equality 
    * of the persistence state. 
    * 
    * @param x 
    * @param y 
    * @return boolean 
    * @throws HibernateException 
    */ 
    @Override 
    public boolean equals(Object x, Object y) throws HibernateException 
    { 

     if (x == null) 
     { 
      return y == null; 
     } 
     return x.equals(y); 
    } 

    /** 
    * Get a hashcode for the instance, consistent with persistence "equality". 
    */ 
    @Override 
    public int hashCode(Object x) throws HibernateException 
    { 
     return x.hashCode(); 
    } 

    /** 
    * Are objects of this type mutable? 
    * 
    * @return boolean 
    */ 
    @Override 
    public boolean isMutable() 
    { 
     return true; 
    } 

    /** 
    * Retrieve an instance of the mapped class from a JDBC resultset. Implementors should handle 
    * possibility of null values. 
    * 
    * @param rs 
    *   a JDBC result set 
    * @param names 
    *   the column names 
    * @param session 
    * @param owner 
    *   the containing entity 
    * @return 
    * @throws HibernateException 
    * @throws SQLException 
    */ 
    @Override 
    public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws HibernateException, SQLException 
    { 
     T t = null; 
     try 
     { 

      if (rs.getString(names[0]) != null) 
      { 
       t = conversion.getObject(rs.getString(names[0]), genericType); 
      } 
     } 
     catch (MyException e) 
     { 
      logger.error("Error while reading data type", e); 
     } 

     return t; 
    } 

    /** 
    * Write an instance of the mapped class to a prepared statement. Implementors should handle 
    * possibility of null values. A multi-column type should be written to parameters starting from 
    * <tt>index</tt> 
    * 
    * @param st 
    *   a JDBC prepared statement 
    * @param value 
    *   the object to write 
    * @param index 
    *   statement parameter index 
    * @param session 
    * @throws HibernateException 
    * @throws SQLException 
    */ 
    @Override 
    public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session) throws HibernateException, SQLException 
    { 

     if (value == null) 
     { 
      st.setNull(index, Types.OTHER); 
      return; 
     } 

     st.setObject(index, value, Types.OTHER); 
    } 

    /** 
    * During merge, replace the existing (target) values in the entity we are merging to with a new 
    * (original) value from the detched entity we are merging. For immutable objects, or null 
    * values, it is safe to return a copy of the first parameter. For the objects with component 
    * values, it might make sense to recursively replace component values 
    * 
    * @param original 
    *   the value from the detched entity being merged 
    * @param target 
    *   the value in the managed entity 
    * @param owner 
    * @return the value to be merged 
    * @throws HibernateException 
    */ 
    @Override 
    public Object replace(Object original, Object target, Object owner) throws HibernateException 
    { 
     return original; 
    } 

    /** 
    * The class returned by <tt>nullSafeGet()</tt> 
    * 
    * @return Class 
    */ 
    @Override 
    public Class returnedClass() 
    { 
     return String.class; 
    } 

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

} 

私はUserクラスにこのカスタム型を使用する方法を知っておく必要があります。誰か助けてくれますか？あなたはまた、ParameterizedTypeを使用する必要が

@Type(type = "package.MyCustomType")

：

Answer 1

は、Typeの完全修飾名を使用し

あなた UserTypeで

@Type(type = "package.MyCustomType", 
     parameters = { @Parameter(
          name = "class", value = "package.Metadata.class") }) 

、あなたは（このメソッドを追加する必要がありますParameterizedTypeインターフェイスを実装します）：

あなたは、パラメータにエントリを取得します

：クラス= package.Metadata.class

は、あなただけのフィールドでこれを格納する必要があり、それに行動ベースを変更するには、標準的なUserType方法を変更します。