java.lang.Object
- org.hibernate.type.AbstractStandardBasicType<T>

所有已实现的接口:

Serializable, BasicType, ProcedureParameterExtractionAware<T>, ProcedureParameterNamedBinder, StringRepresentableType<T>, Type

直接已知子类:

AbstractSingleColumnStandardBasicType
```
public abstract class AbstractStandardBasicType<T>
extends Object
implements BasicType, StringRepresentableType<T>, ProcedureParameterExtractionAware<T>, ProcedureParameterNamedBinder
```
Convenience base class for BasicType implementations

作者:

Steve Ebersole, Brett Meyer

另请参阅:

序列化表格

构造器概要

构造器
构造器说明

AbstractStandardBasicType(SqlTypeDescriptor sqlTypeDescriptor, JavaTypeDescriptor<T> javaTypeDescriptor)

方法概要

所有方法静态方法实例方法具体方法
修饰符和类型	方法	说明
`Object`	`assemble(Serializable cached, SharedSessionContractImplementor session, Object owner)`	Reconstruct the object from its disassembled state.
`void`	`beforeAssemble(Serializable cached, SharedSessionContractImplementor session)`	Called before assembling a query result set from the query cache, to allow batch fetching of entities missing from the second-level cache.
`boolean`	`canDoExtraction()`	Can the given instance of this type actually perform the parameter value extractions?
`boolean`	`canDoSetting()`	Can the given instance of this type actually set the parameter value by name
`int`	`compare(Object x, Object y)`	Perform a `Comparator` style comparison between values
`Object`	`deepCopy(Object value, SessionFactoryImplementor factory)`	Return a deep copy of the persistent state, stopping at entities and at collections.
`protected T`	`deepCopy(T value)`
`Size[]`	`defaultSizes(Mapping mapping)`	Defines the column sizes to use according to this type if the user did not explicitly say (and if no `Type.dictatedSizes(org.hibernate.engine.spi.Mapping)` were given).
`Size[]`	`dictatedSizes(Mapping mapping)`	Return the column sizes dictated by this type.
`Serializable`	`disassemble(Object value, SharedSessionContractImplementor session, Object owner)`	Return a disassembled representation of the object.
`T`	`extract(CallableStatement statement, int startIndex, SharedSessionContractImplementor session)`	Perform the extraction
`T`	`extract(CallableStatement statement, String[] paramNames, SharedSessionContractImplementor session)`	Perform the extraction
`T`	`fromString(String string)`
`T`	`fromStringValue(String xml)`	Consume the given string representation back into this types java form.
`Object`	`get(ResultSet rs, String name, SharedSessionContractImplementor session)`
`int`	`getColumnSpan(Mapping mapping)`	How many columns are used to persist this type.
`protected static Size`	`getDefaultSize()`
`protected Size`	`getDictatedSize()`
`int`	`getHashCode(Object x)`	Get a hash code, consistent with persistence "equality".
`int`	`getHashCode(Object x, SessionFactoryImplementor factory)`	Get a hash code, consistent with persistence "equality".
`JavaTypeDescriptor<T>`	`getJavaTypeDescriptor()`
`protected MutabilityPlan<T>`	`getMutabilityPlan()`
`String[]`	`getRegistrationKeys()`	Get the names under which this type should be registered in the type registry.
`protected T`	`getReplacement(T original, T target, SharedSessionContractImplementor session)`
`Class`	`getReturnedClass()`	The class returned by `Type.nullSafeGet(java.sql.ResultSet, java.lang.String[], org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object)` methods.
`Type`	`getSemiResolvedType(SessionFactoryImplementor factory)`	As part of 2-phase loading, when we perform resolving what is the resolved type for this type?
`SqlTypeDescriptor`	`getSqlTypeDescriptor()`
`Object`	`hydrate(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner)`	Extract a value from the JDBC result set.
`boolean`	`isAnyType()`	Return true if the implementation is castable to `AnyType`.
`boolean`	`isAssociationType()`	Return true if the implementation is castable to `AssociationType`.
`boolean`	`isCollectionType()`	Return true if the implementation is castable to `CollectionType`.
`boolean`	`isComponentType()`	Return true if the implementation is castable to `CompositeType`.
`protected boolean`	`isDirty(Object old, Object current)`
`boolean`	`isDirty(Object old, Object current, boolean[] checkable, SharedSessionContractImplementor session)`	Should the parent be considered dirty, given both the old and current value?
`boolean`	`isDirty(Object old, Object current, SharedSessionContractImplementor session)`	Should the parent be considered dirty, given both the old and current value?
`boolean`	`isEntityType()`	Return true if the implementation is castable to `EntityType`.
`boolean`	`isEqual(Object one, Object another)`	Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean`	`isEqual(Object x, Object y, SessionFactoryImplementor factory)`	Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`boolean`	`isModified(Object oldHydratedState, Object currentState, boolean[] checkable, SharedSessionContractImplementor session)`	Has the value been modified compared to the current database state?
`boolean`	`isMutable()`	Are objects of this type mutable.
`boolean`	`isSame(Object x, Object y)`	Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state) taking a shortcut for entity references.
`boolean`	`isXMLElement()`
`Object`	`nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner)`	Extract a value of the `mapped class` from the JDBC result set.
`T`	`nullSafeGet(ResultSet rs, String name, SharedSessionContractImplementor session)`
`Object`	`nullSafeGet(ResultSet rs, String name, SharedSessionContractImplementor session, Object owner)`	Extract a value of the `mapped class` from the JDBC result set.
`protected T`	`nullSafeGet(ResultSet rs, String name, WrapperOptions options)`
`void`	`nullSafeSet(CallableStatement st, Object value, String name, SharedSessionContractImplementor session)`	Bind a value to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter.
`protected void`	`nullSafeSet(CallableStatement st, Object value, String name, WrapperOptions options)`
`void`	`nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session)`	Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement.
`protected void`	`nullSafeSet(PreparedStatement st, Object value, int index, WrapperOptions options)`
`protected boolean`	`registerUnderJavaType()`
`protected SqlTypeDescriptor`	`remapSqlTypeDescriptor(WrapperOptions options)`
`Object`	`replace(Object original, Object target, SharedSessionContractImplementor session, Object owner, Map copyCache)`	During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object`	`replace(Object original, Object target, SharedSessionContractImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`	During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Object`	`resolve(Object value, SharedSessionContractImplementor session, Object owner)`
`Object`	`semiResolve(Object value, SharedSessionContractImplementor session, Object owner)`	Given a hydrated, but unresolved value, return a value that may be used to reconstruct property-ref associations.
`void`	`set(PreparedStatement st, T value, int index, SharedSessionContractImplementor session)`
`void`	`setJavaTypeDescriptor(JavaTypeDescriptor<T> javaTypeDescriptor)`
`void`	`setSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor)`
`int[]`	`sqlTypes(Mapping mapping)`	Return the JDBC types codes (per `Types`) for the columns mapped by this type.
`boolean[]`	`toColumnNullness(Object value, Mapping mapping)`	Given an instance of the type, return an array of boolean, indicating which mapped columns would be null.
`String`	`toLoggableString(Object value, SessionFactoryImplementor factory)`	Generate a representation of the value for logging purposes.
`String`	`toString(T value)`	Render the value to the string representation.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.hibernate.type.Type
getName, nullSafeSet, resolve

- 构造器详细资料
  - AbstractStandardBasicType
```
public AbstractStandardBasicType(SqlTypeDescriptor sqlTypeDescriptor,
                                 JavaTypeDescriptor<T> javaTypeDescriptor)
```
- 方法详细资料
  - fromString
```
public T fromString(String string)
```
  - toString
```
public String toString(T value)
```
    从接口复制的说明: StringRepresentableType
    
    Render the value to the string representation.
    
    指定者:
    
    toString 在接口中 StringRepresentableType<T>
    
    参数:
    
    value - The value to render to string.
    
    返回:
    
    The string representation
  - fromStringValue
```
public T fromStringValue(String xml)
                  throws HibernateException
```
    从接口复制的说明: StringRepresentableType
    
    Consume the given string representation back into this types java form.
    
    指定者:
    
    fromStringValue 在接口中 StringRepresentableType<T>
    
    参数:
    
    xml - The string representation to be consumed.
    
    返回:
    
    The java type representation
    
    抛出:
    
    HibernateException - Problem consuming
  - getMutabilityPlan
```
protected MutabilityPlan<T> getMutabilityPlan()
```
  - getReplacement
```
protected T getReplacement(T original,
                           T target,
                           SharedSessionContractImplementor session)
```
  - toColumnNullness
```
public boolean[] toColumnNullness(Object value,
                                  Mapping mapping)
```
    从接口复制的说明: Type
    
    Given an instance of the type, return an array of boolean, indicating which mapped columns would be null.
    
    指定者:
    
    toColumnNullness 在接口中 Type
    
    参数:
    
    value - an instance of the type
    
    mapping - The mapping abstraction
    
    返回:
    
    array indicating column nullness for a value instance
  - getRegistrationKeys
```
public String[] getRegistrationKeys()
```
    从接口复制的说明: BasicType
    
    Get the names under which this type should be registered in the type registry.
    
    指定者:
    
    getRegistrationKeys 在接口中 BasicType
    
    返回:
    
    The keys under which to register this type.
  - registerUnderJavaType
```
protected boolean registerUnderJavaType()
```
  - getDefaultSize
```
protected static Size getDefaultSize()
```
  - getDictatedSize
```
protected Size getDictatedSize()
```
  - getJavaTypeDescriptor
```
public final JavaTypeDescriptor<T> getJavaTypeDescriptor()
```
  - setJavaTypeDescriptor
```
public final void setJavaTypeDescriptor(JavaTypeDescriptor<T> javaTypeDescriptor)
```
  - getSqlTypeDescriptor
```
public final SqlTypeDescriptor getSqlTypeDescriptor()
```
  - setSqlTypeDescriptor
```
public final void setSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor)
```
  - getReturnedClass
```
public final Class getReturnedClass()
```
    从接口复制的说明: Type
    
    The class returned by Type.nullSafeGet(java.sql.ResultSet, java.lang.String[], org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object) methods. This is used to establish the class of an array of this type.
    
    指定者:
    
    getReturnedClass 在接口中 Type
    
    返回:
    
    The java type class handled by this type.
  - getColumnSpan
```
public final int getColumnSpan(Mapping mapping)
                        throws MappingException
```
    从接口复制的说明: Type
    
    How many columns are used to persist this type. Always the same as sqlTypes(mapping).length
    
    指定者:
    
    getColumnSpan 在接口中 Type
    
    参数:
    
    mapping - The mapping object :/
    
    返回:
    
    The number of columns
    
    抛出:
    
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - sqlTypes
```
public final int[] sqlTypes(Mapping mapping)
                     throws MappingException
```
    从接口复制的说明: Type
    
    Return the JDBC types codes (per Types) for the columns mapped by this type.
    NOTE: The number of elements in this array matches the return from Type.getColumnSpan(org.hibernate.engine.spi.Mapping).
    
    指定者:
    
    sqlTypes 在接口中 Type
    
    参数:
    
    mapping - The mapping object :/
    
    返回:
    
    The JDBC type codes.
    
    抛出:
    
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - dictatedSizes
```
public Size[] dictatedSizes(Mapping mapping)
                     throws MappingException
```
    从接口复制的说明: Type
    
    Return the column sizes dictated by this type. For example, the mapping for a char/Character would have a dictated length limit of 1; for a string-based UUID would have a size limit of 36; etc.
    NOTE: The number of elements in this array matches the return from Type.getColumnSpan(org.hibernate.engine.spi.Mapping).
    
    指定者:
    
    dictatedSizes 在接口中 Type
    
    参数:
    
    mapping - The mapping object :/
    
    返回:
    
    The dictated sizes.
    
    抛出:
    
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - defaultSizes
```
public Size[] defaultSizes(Mapping mapping)
                    throws MappingException
```
    从接口复制的说明: Type
    
    Defines the column sizes to use according to this type if the user did not explicitly say (and if no Type.dictatedSizes(org.hibernate.engine.spi.Mapping) were given).
    NOTE: The number of elements in this array matches the return from Type.getColumnSpan(org.hibernate.engine.spi.Mapping).
    
    指定者:
    
    defaultSizes 在接口中 Type
    
    参数:
    
    mapping - The mapping object :/
    
    返回:
    
    The default sizes.
    
    抛出:
    
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - isAssociationType
```
public final boolean isAssociationType()
```
    从接口复制的说明: Type
    
    Return true if the implementation is castable to AssociationType. This does not necessarily imply that the type actually represents an association. Essentially a polymorphic version of (type instanceof AssociationType.class)
    
    指定者:
    
    isAssociationType 在接口中 Type
    
    返回:
    
    True if this type is also an AssociationType implementor; false otherwise.
  - isCollectionType
```
public final boolean isCollectionType()
```
    从接口复制的说明: Type
    
    Return true if the implementation is castable to CollectionType. Essentially a polymorphic version of (type instanceof CollectionType.class)
    A CollectionType is additionally an AssociationType; so if this method returns true, Type.isAssociationType() should also return true.
    
    指定者:
    
    isCollectionType 在接口中 Type
    
    返回:
    
    True if this type is also a CollectionType implementor; false otherwise.
  - isComponentType
```
public final boolean isComponentType()
```
    从接口复制的说明: Type
    
    Return true if the implementation is castable to CompositeType. Essentially a polymorphic version of (type instanceof CompositeType.class). A component type may own collections or associations and hence must provide certain extra functionality.
    
    指定者:
    
    isComponentType 在接口中 Type
    
    返回:
    
    True if this type is also a CompositeType implementor; false otherwise.
  - isEntityType
```
public final boolean isEntityType()
```
    从接口复制的说明: Type
    
    Return true if the implementation is castable to EntityType. Essentially a polymorphic version of (type instanceof EntityType.class).
    An EntityType is additionally an AssociationType; so if this method returns true, Type.isAssociationType() should also return true.
    
    指定者:
    
    isEntityType 在接口中 Type
    
    返回:
    
    True if this type is also an EntityType implementor; false otherwise.
  - isAnyType
```
public final boolean isAnyType()
```
    从接口复制的说明: Type
    
    Return true if the implementation is castable to AnyType. Essentially a polymorphic version of (type instanceof AnyType.class).
    An AnyType is additionally an AssociationType; so if this method returns true, Type.isAssociationType() should also return true.
    
    指定者:
    
    isAnyType 在接口中 Type
    
    返回:
    
    True if this type is also an AnyType implementor; false otherwise.
  - isXMLElement
```
public final boolean isXMLElement()
```
  - isSame
```
public final boolean isSame(Object x,
                            Object y)
```
    从接口复制的说明: Type
    
    Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state) taking a shortcut for entity references.
    For most types this should equate to an equals check on the values. For associations the implication is a bit different. For most types it is conceivable to simply delegate to Type.isEqual(java.lang.Object, java.lang.Object)
    
    指定者:
    
    isSame 在接口中 Type
    
    参数:
    
    x - The first value
    
    y - The second value
    
    返回:
    
    True if there are considered the same (see discussion above).
  - isEqual
```
public final boolean isEqual(Object x,
                             Object y,
                             SessionFactoryImplementor factory)
```
    从接口复制的说明: Type
    
    Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
    This should always equate to some form of comparison of the value's internal state. As an example, for something like a date the comparison should be based on its internal "time" state based on the specific portion it is meant to represent (timestamp, date, time).
    
    指定者:
    
    isEqual 在接口中 Type
    
    参数:
    
    x - The first value
    
    y - The second value
    
    factory - The session factory
    
    返回:
    
    True if there are considered equal (see discussion above).
  - isEqual
```
public final boolean isEqual(Object one,
                             Object another)
```
    从接口复制的说明: Type
    
    Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
    This should always equate to some form of comparison of the value's internal state. As an example, for something like a date the comparison should be based on its internal "time" state based on the specific portion it is meant to represent (timestamp, date, time).
    
    指定者:
    
    isEqual 在接口中 Type
    
    参数:
    
    one - The first value
    
    another - The second value
    
    返回:
    
    True if there are considered equal (see discussion above).
  - getHashCode
```
public final int getHashCode(Object x)
```
    从接口复制的说明: Type
    
    Get a hash code, consistent with persistence "equality". Again for most types the normal usage is to delegate to the value's hashCode.
    
    指定者:
    
    getHashCode 在接口中 Type
    
    参数:
    
    x - The value for which to retrieve a hash code
    
    返回:
    
    The hash code
  - getHashCode
```
public final int getHashCode(Object x,
                             SessionFactoryImplementor factory)
```
    从接口复制的说明: Type
    
    Get a hash code, consistent with persistence "equality". Again for most types the normal usage is to delegate to the value's hashCode.
    
    指定者:
    
    getHashCode 在接口中 Type
    
    参数:
    
    x - The value for which to retrieve a hash code
    
    factory - The session factory
    
    返回:
    
    The hash code
  - compare
```
public final int compare(Object x,
                         Object y)
```
    从接口复制的说明: Type
    
    Perform a Comparator style comparison between values
    
    指定者:
    
    compare 在接口中 Type
    
    参数:
    
    x - The first value
    
    y - The second value
    
    返回:
    
    The comparison result. See Comparator.compare(T, T) for a discussion.
  - isDirty
```
public final boolean isDirty(Object old,
                             Object current,
                             SharedSessionContractImplementor session)
```
    从接口复制的说明: Type
    
    Should the parent be considered dirty, given both the old and current value?
    
    指定者:
    
    isDirty 在接口中 Type
    
    参数:
    
    old - the old value
    
    current - the current value
    
    session - The session from which the request originated.
    
    返回:
    
    true if the field is dirty
  - isDirty
```
public final boolean isDirty(Object old,
                             Object current,
                             boolean[] checkable,
                             SharedSessionContractImplementor session)
```
    从接口复制的说明: Type
    
    Should the parent be considered dirty, given both the old and current value?
    
    指定者:
    
    isDirty 在接口中 Type
    
    参数:
    
    old - the old value
    
    current - the current value
    
    checkable - An array of booleans indicating which columns making up the value are actually checkable
    
    session - The session from which the request originated.
    
    返回:
    
    true if the field is dirty
  - isDirty
```
protected final boolean isDirty(Object old,
                                Object current)
```
  - isModified
```
public final boolean isModified(Object oldHydratedState,
                                Object currentState,
                                boolean[] checkable,
                                SharedSessionContractImplementor session)
```
    从接口复制的说明: Type
    
    Has the value been modified compared to the current database state? The difference between this and the Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor) methods is that here we need to account for "partially" built values. This is really only an issue with association types. For most type implementations it is enough to simply delegate to Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor) here/
    
    指定者:
    
    isModified 在接口中 Type
    
    参数:
    
    oldHydratedState - the database state, in a "hydrated" form, with identifiers unresolved
    
    currentState - the current state of the object
    
    checkable - which columns are actually checkable
    
    session - The session from which the request originated.
    
    返回:
    
    true if the field has been modified
  - nullSafeGet
```
public final Object nullSafeGet(ResultSet rs,
                                String[] names,
                                SharedSessionContractImplementor session,
                                Object owner)
                         throws SQLException
```
    从接口复制的说明: Type
    
    Extract a value of the mapped class from the JDBC result set. Implementors should handle possibility of null values.
    
    指定者:
    
    nullSafeGet 在接口中 Type
    
    参数:
    
    rs - The result set from which to extract value.
    
    names - the column names making up this type value (use to read from result set)
    
    session - The originating session
    
    owner - the parent entity
    
    返回:
    
    The extracted value
    
    抛出:
    
    SQLException - An error from the JDBC driver
    
    另请参阅:
    
    alternative, 2-phase property initialization
  - nullSafeGet
```
public final Object nullSafeGet(ResultSet rs,
                                String name,
                                SharedSessionContractImplementor session,
                                Object owner)
                         throws SQLException
```
    从接口复制的说明: Type
    
    Extract a value of the mapped class from the JDBC result set. Implementors should handle possibility of null values. This form might be called if the type is known to be a single-column type.
    
    指定者:
    
    nullSafeGet 在接口中 Type
    
    参数:
    
    rs - The result set from which to extract value.
    
    name - the column name making up this type value (use to read from result set)
    
    session - The originating session
    
    owner - the parent entity
    
    返回:
    
    The extracted value
    
    抛出:
    
    SQLException - An error from the JDBC driver
  - nullSafeGet
```
public final T nullSafeGet(ResultSet rs,
                           String name,
                           SharedSessionContractImplementor session)
                    throws SQLException
```
    抛出:
    
    SQLException
  - nullSafeGet
```
protected final T nullSafeGet(ResultSet rs,
                              String name,
                              WrapperOptions options)
                       throws SQLException
```
    抛出:
    
    SQLException
  - get
```
public Object get(ResultSet rs,
                  String name,
                  SharedSessionContractImplementor session)
           throws HibernateException,
                  SQLException
```
    抛出:
    
    HibernateException
    
    SQLException
  - nullSafeSet
```
public final void nullSafeSet(PreparedStatement st,
                              Object value,
                              int index,
                              SharedSessionContractImplementor session)
                       throws SQLException
```
    从接口复制的说明: Type
    
    Bind a value represented by an instance of the mapped class to the JDBC prepared statement. Implementors should handle possibility of null values. A multi-column type should bind parameters starting from index.
    
    指定者:
    
    nullSafeSet 在接口中 Type
    
    参数:
    
    st - The JDBC prepared statement to which to bind
    
    value - the object to write
    
    index - starting parameter bind index
    
    session - The originating session
    
    抛出:
    
    SQLException - An error from the JDBC driver
  - nullSafeSet
```
protected final void nullSafeSet(PreparedStatement st,
                                 Object value,
                                 int index,
                                 WrapperOptions options)
                          throws SQLException
```
    抛出:
    
    SQLException
  - remapSqlTypeDescriptor
```
protected SqlTypeDescriptor remapSqlTypeDescriptor(WrapperOptions options)
```
  - set
```
public void set(PreparedStatement st,
                T value,
                int index,
                SharedSessionContractImplementor session)
         throws HibernateException,
                SQLException
```
    抛出:
    
    HibernateException
    
    SQLException
  - toLoggableString
```
public final String toLoggableString(Object value,
                                     SessionFactoryImplementor factory)
```
    从接口复制的说明: Type
    
    Generate a representation of the value for logging purposes.
    
    指定者:
    
    toLoggableString 在接口中 Type
    
    参数:
    
    value - The value to be logged
    
    factory - The session factory
    
    返回:
    
    The loggable representation
  - isMutable
```
public final boolean isMutable()
```
    从接口复制的说明: Type
    
    Are objects of this type mutable. (With respect to the referencing object ... entities and collections are considered immutable because they manage their own internal state.)
    
    指定者:
    
    isMutable 在接口中 Type
    
    返回:
    
    boolean
  - deepCopy
```
public final Object deepCopy(Object value,
                             SessionFactoryImplementor factory)
```
    从接口复制的说明: Type
    
    Return a deep copy of the persistent state, stopping at entities and at collections.
    
    指定者:
    
    deepCopy 在接口中 Type
    
    参数:
    
    value - The value to be copied
    
    factory - The session factory
    
    返回:
    
    The deep copy
  - deepCopy
```
protected final T deepCopy(T value)
```
  - disassemble
```
public final Serializable disassemble(Object value,
                                      SharedSessionContractImplementor session,
                                      Object owner)
                               throws HibernateException
```
    从接口复制的说明: Type
    
    Return a disassembled representation of the object. This is the value Hibernate will use in second level caching, so care should be taken to break values down to their simplest forms; for entities especially, this means breaking them down into their constituent parts.
    
    指定者:
    
    disassemble 在接口中 Type
    
    参数:
    
    value - the value to cache
    
    session - the originating session
    
    owner - optional parent entity object (needed for collections)
    
    返回:
    
    the disassembled, deep cloned state
    
    抛出:
    
    HibernateException - An error from Hibernate
  - assemble
```
public final Object assemble(Serializable cached,
                             SharedSessionContractImplementor session,
                             Object owner)
                      throws HibernateException
```
    从接口复制的说明: Type
    
    Reconstruct the object from its disassembled state. This method is the reciprocal of Type.disassemble(java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object)
    
    指定者:
    
    assemble 在接口中 Type
    
    参数:
    
    cached - the disassembled state from the cache
    
    session - the originating session
    
    owner - the parent entity object
    
    返回:
    
    the (re)assembled object
    
    抛出:
    
    HibernateException - An error from Hibernate
  - beforeAssemble
```
public final void beforeAssemble(Serializable cached,
                                 SharedSessionContractImplementor session)
```
    从接口复制的说明: Type
    
    Called before assembling a query result set from the query cache, to allow batch fetching of entities missing from the second-level cache.
    
    指定者:
    
    beforeAssemble 在接口中 Type
    
    参数:
    
    cached - The key
    
    session - The originating session
  - hydrate
```
public final Object hydrate(ResultSet rs,
                            String[] names,
                            SharedSessionContractImplementor session,
                            Object owner)
                     throws HibernateException,
                            SQLException
```
    从接口复制的说明: Type
    Extract a value from the JDBC result set. This is useful for 2-phase property initialization - the second phase is a call to Type.resolve(java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object) This hydrated value will be either:
    
    in the case of an entity or collection type, the key
    
    otherwise, the value itself
    指定者:
    
    hydrate 在接口中 Type
    
    参数:
    
    rs - The JDBC result set
    
    names - the column names making up this type value (use to read from result set)
    
    session - The originating session
    
    owner - the parent entity
    
    返回:
    
    An entity or collection key, or an actual value.
    
    抛出:
    
    HibernateException - An error from Hibernate
    
    SQLException - An error from the JDBC driver
    
    另请参阅:
    
    Type.resolve(java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object)
  - resolve
```
public final Object resolve(Object value,
                            SharedSessionContractImplementor session,
                            Object owner)
                     throws HibernateException
```
    指定者:
    
    resolve 在接口中 Type
    
    抛出:
    
    HibernateException
    
    另请参阅:
    
    Type.resolve(Object, SharedSessionContractImplementor, Object, Boolean)
  - semiResolve
```
public final Object semiResolve(Object value,
                                SharedSessionContractImplementor session,
                                Object owner)
                         throws HibernateException
```
    从接口复制的说明: Type
    
    Given a hydrated, but unresolved value, return a value that may be used to reconstruct property-ref associations.
    
    指定者:
    
    semiResolve 在接口中 Type
    
    参数:
    
    value - The unresolved, hydrated value
    
    session - THe originating session
    
    owner - The value owner
    
    返回:
    
    The semi-resolved value
    
    抛出:
    
    HibernateException - An error from Hibernate
  - getSemiResolvedType
```
public final Type getSemiResolvedType(SessionFactoryImplementor factory)
```
    从接口复制的说明: Type
    
    As part of 2-phase loading, when we perform resolving what is the resolved type for this type? Generally speaking the type and its semi-resolved type will be the same. The main deviation from this is in the case of an entity where the type would be the entity type and semi-resolved type would be its identifier type
    
    指定者:
    
    getSemiResolvedType 在接口中 Type
    
    参数:
    
    factory - The session factory
    
    返回:
    
    The semi-resolved type
  - replace
```
public final Object replace(Object original,
                            Object target,
                            SharedSessionContractImplementor session,
                            Object owner,
                            Map copyCache)
```
    从接口复制的说明: Type
    
    During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. For immutable objects, or null values, it is safe to simply return the first parameter. For mutable objects, it is safe to return a copy of the first parameter. For objects with component values, it might make sense to recursively replace component values.
    
    指定者:
    
    replace 在接口中 Type
    
    参数:
    
    original - the value from the detached entity being merged
    
    target - the value in the managed entity
    
    session - The originating session
    
    owner - The owner of the value
    
    copyCache - The cache of already copied/replaced values
    
    返回:
    
    the value to be merged
  - replace
```
public Object replace(Object original,
                      Object target,
                      SharedSessionContractImplementor session,
                      Object owner,
                      Map copyCache,
                      ForeignKeyDirection foreignKeyDirection)
```
    从接口复制的说明: Type
    
    During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. For immutable objects, or null values, it is safe to simply return the first parameter. For mutable objects, it is safe to return a copy of the first parameter. For objects with component values, it might make sense to recursively replace component values.
    
    指定者:
    
    replace 在接口中 Type
    
    参数:
    
    original - the value from the detached entity being merged
    
    target - the value in the managed entity
    
    session - The originating session
    
    owner - The owner of the value
    
    copyCache - The cache of already copied/replaced values
    
    foreignKeyDirection - For associations, which direction does the foreign key point?
    
    返回:
    
    the value to be merged
  - canDoExtraction
```
public boolean canDoExtraction()
```
    从接口复制的说明: ProcedureParameterExtractionAware
    
    Can the given instance of this type actually perform the parameter value extractions?
    
    指定者:
    
    canDoExtraction 在接口中 ProcedureParameterExtractionAware<T>
    
    返回:
    
    true indicates that @{link #extract} calls will not fail due to IllegalStateException.
  - extract
```
public T extract(CallableStatement statement,
                 int startIndex,
                 SharedSessionContractImplementor session)
          throws SQLException
```
    从接口复制的说明: ProcedureParameterExtractionAware
    
    Perform the extraction
    
    指定者:
    
    extract 在接口中 ProcedureParameterExtractionAware<T>
    
    参数:
    
    statement - The CallableStatement from which to extract the parameter value(s).
    
    startIndex - The parameter index from which to start extracting; assumes the values (if multiple) are contiguous
    
    session - The originating session
    
    返回:
    
    The extracted value.
    
    抛出:
    
    SQLException - Indicates an issue calling into the CallableStatement
  - extract
```
public T extract(CallableStatement statement,
                 String[] paramNames,
                 SharedSessionContractImplementor session)
          throws SQLException
```
    从接口复制的说明: ProcedureParameterExtractionAware
    
    Perform the extraction
    
    指定者:
    
    extract 在接口中 ProcedureParameterExtractionAware<T>
    
    参数:
    
    statement - The CallableStatement from which to extract the parameter value(s).
    
    paramNames - The parameter names.
    
    session - The originating session
    
    返回:
    
    The extracted value.
    
    抛出:
    
    SQLException - Indicates an issue calling into the CallableStatement
  - nullSafeSet
```
public void nullSafeSet(CallableStatement st,
                        Object value,
                        String name,
                        SharedSessionContractImplementor session)
                 throws SQLException
```
    从接口复制的说明: ProcedureParameterNamedBinder
    
    Bind a value to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter. Implementors should handle the possibility of null values. Does not support multi-column type
    
    指定者:
    
    nullSafeSet 在接口中 ProcedureParameterNamedBinder
    
    参数:
    
    st - The CallableStatement to which to bind
    
    value - the object to write
    
    name - parameter bind name
    
    session - The originating session
    
    抛出:
    
    SQLException - An error from the JDBC driver
  - nullSafeSet
```
protected final void nullSafeSet(CallableStatement st,
                                 Object value,
                                 String name,
                                 WrapperOptions options)
                          throws SQLException
```
    抛出:
    
    SQLException
  - canDoSetting
```
public boolean canDoSetting()
```
    从接口复制的说明: ProcedureParameterNamedBinder
    
    Can the given instance of this type actually set the parameter value by name
    
    指定者:
    
    canDoSetting 在接口中 ProcedureParameterNamedBinder
    
    返回:
    
    true indicates that @{link #nullSafeSet} calls will not fail

类 AbstractStandardBasicType<T>

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 org.hibernate.type.Type

构造器详细资料

AbstractStandardBasicType

方法详细资料

fromString

toString

fromStringValue

getMutabilityPlan

getReplacement

toColumnNullness

getRegistrationKeys

registerUnderJavaType

getDefaultSize

getDictatedSize

getJavaTypeDescriptor

setJavaTypeDescriptor

getSqlTypeDescriptor

setSqlTypeDescriptor

getReturnedClass

getColumnSpan

sqlTypes

dictatedSizes

defaultSizes

isAssociationType

isCollectionType

isComponentType

isEntityType

isAnyType

isXMLElement

isSame

isEqual

isEqual

getHashCode

getHashCode

compare

isDirty

isDirty

isDirty

isModified

nullSafeGet

nullSafeGet

nullSafeGet

nullSafeGet

get

nullSafeSet

nullSafeSet

remapSqlTypeDescriptor

set

toLoggableString

isMutable

deepCopy

deepCopy

disassemble

assemble

beforeAssemble

hydrate

resolve

semiResolve

getSemiResolvedType

replace

replace

canDoExtraction

extract

extract

nullSafeSet

nullSafeSet

canDoSetting