Movatterモバイル変換

A custom type isnot an actual persistent attribute type, rather it is a class responsible for serializing instances of some other class to and from JDBC. This other class should have "value" semantics, since its identity is lost as part of this serialization process.

A custom type may be applied to an attribute of an entity either:

• explicitly, using@Type, or
• implicitly, using@TypeRegistration.

For example, thisUserType persistsPeriod to columns of typevarchar:

 public class PeriodType implements UserType<Period> {     @Override     public int getSqlType() {         return VARCHAR;     }     @Override     public Class<Period> returnedClass() {         return Period.class;     }     @Override     public boolean equals(Period x, Period y) {         return Objects.equals(x, y);     }     @Override     public int hashCode(Period x) {         return x.hashCode();     }     @Override     public Period nullSafeGet(ResultSet rs, int position,                               SharedSessionContractImplementor session, Object owner)                 throws SQLException {         String string = rs.getString( position );         return rs.wasNull() ? null : Period.parse(string);     }     @Override     public void nullSafeSet(PreparedStatement st, Period value, int index,                             SharedSessionContractImplementor session)                 throws SQLException {         if ( value == null ) {             st.setNull(index, VARCHAR);         }         else {             st.setString(index, value.toString());         }     }     @Override     public boolean isMutable() {         return false;     }     @Override     public Period deepCopy(Period value) {         return value; //Period is immutable     }     @Override     public Serializable disassemble(Period period) {         return period; //Period is immutable     }     @Override     public Period assemble(Serializable cached, Object owner) {         return (Period) cached; //Period is immutable     } }

And it may be used like this:

@Type(PeriodType.class) Period period;

We could even use@Type as a meta-annotation:

 @Type(PeriodType.class) @Target({METHOD, FIELD}) @Retention(RUNTIME) public @interface TimePeriod {}

And then use the@TimePeriod annotation to apply ourUserType:

@TimePeriod Period period;

Finally, we could ask for our custom type to be used by default:

@TypeRegistration(basicClass = Period.class, userType = PeriodType.class)

Which completely relieves us of the need to annotate the field explicitly:

Period period;

But on the other hand, ourUserType is overkill. Like most immutable classes,Period is much easier to handle using a JPA attribute converter:

 @Converter public class PeriodToStringConverter implements AttributeConverter<Period,String> {     @Override     public String convertToDatabaseColumn(Period period) {         return period.toString();     }    @Override    public Period convertToEntityAttribute(String string) {         return Period.parse(string);    } }

AUserType is much more useful when the persistent attribute type is mutable. For example:

 public class BitSetUserType implements UserType<BitSet> {     @Override     public int getSqlType() {         return Types.VARCHAR;     }     @Override     public Class<BitSet> returnedClass() {         return BitSet.class;     }     @Override     public boolean equals(BitSet x, BitSet y) {         return Objects.equals(x, y);     }     @Override     public int hashCode(BitSet x) {         return x.hashCode();     }     @Override     public BitSet nullSafeGet(ResultSet rs, int position,                               SharedSessionContractImplementor session, Object owner)                 throws SQLException {         String string = rs.getString(position);         return rs.wasNull()? null : parseBitSet(columnValue);     }     @Override     public void nullSafeSet(PreparedStatement st, BitSet bitSet, int index,                             SharedSessionContractImplementor session)                 throws SQLException {         if (bitSet == null) {             st.setNull(index, VARCHAR);         }         else {             st.setString(index, formatBitSet(bitSet));         }     }     @Override     public BitSet deepCopy(BitSet value) {         return bitSet == null ? null : (BitSet) bitSet.clone();     }     @Override     public boolean isMutable() {         return true;     }     @Override     public Serializable disassemble(BitSet value) {         return deepCopy(value);     }     @Override     public BitSet assemble(Serializable cached, Object owner)             throws HibernateException {         return deepCopy((BitSet) cached);     } }

Every implementor ofUserType must be immutable and must declare a public default constructor.

A custom type implemented as aUserType is treated as a non-composite value, and does not have persistent attributes which may be used in queries. If a custom type does have attributes, and can be thought of as something more like an embeddable object, it might be better to implementCompositeUserType.