java.lang.Object
- org.hibernate.collection.internal.AbstractPersistentCollection

所有已实现的接口:

Serializable, PersistentCollection

直接已知子类:

PersistentArrayHolder, PersistentBag, PersistentIdentifierBag, PersistentList, PersistentMap, PersistentSet
```
public abstract class AbstractPersistentCollection
extends Object
implements Serializable, PersistentCollection
```
Base class implementing PersistentCollection

作者:

Gavin King

另请参阅:

序列化表格

嵌套类概要

嵌套类
修饰符和类型	类	说明
`protected class`	`AbstractPersistentCollection.AbstractValueDelayedOperation`
`protected static interface`	`AbstractPersistentCollection.DelayedOperation`	Contract for operations which are part of a collection's operation queue.
`protected class`	`AbstractPersistentCollection.IteratorProxy`
`static interface`	`AbstractPersistentCollection.LazyInitializationWork<T>`	TBH not sure why this is public
`protected class`	`AbstractPersistentCollection.ListIteratorProxy`
`protected class`	`AbstractPersistentCollection.ListProxy`
`protected class`	`AbstractPersistentCollection.SetProxy`
`protected static interface`	`AbstractPersistentCollection.ValueDelayedOperation`

字段概要

字段
修饰符和类型字段说明

protected boolean elementRemoved

protected static Object UNKNOWN

构造器概要

构造器
限定符	构造器	说明
	`AbstractPersistentCollection()`	Not called by Hibernate, but used by non-JDK serialization, eg.
`protected`	`AbstractPersistentCollection(SessionImplementor session)`	已过时。
`protected`	`AbstractPersistentCollection(SharedSessionContractImplementor session)`

方法概要

所有方法静态方法实例方法抽象方法具体方法已过时的方法
修饰符和类型	方法	说明
`boolean`	`afterInitialize()`	Called after initializing from cache
`void`	`afterRowInsert(CollectionPersister persister, Object entry, int i)`	Called after inserting a row, to fetch the natively generated id
`void`	`beginRead()`	Called just before reading any rows from the JDBC result set
`void`	`clearDirty()`	Clear the dirty flag, after flushing changes to the database.
`void`	`clearOperationQueue()`
`void`	`dirty()`	Mark the collection as dirty
`abstract boolean`	`empty()`	Is the collection empty?
`boolean`	`endRead()`	Called after reading all rows from the JDBC result set
`void`	`forceInitialization()`	To be called internally by the session, forcing immediate initialization.
`protected int`	`getCachedSize()`
`Object`	`getIdentifier(Object entry, int i)`	Get the identifier of the given collection entry.
`Serializable`	`getKey()`	Get the current collection key value
`abstract Collection`	`getOrphans(Serializable snapshot, String entityName)`	get all "orphaned" elements
`protected static Collection`	`getOrphans(Collection oldElements, Collection currentElements, String entityName, SharedSessionContractImplementor session)`	Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans
`Object`	`getOwner()`	Get the owning entity.
`Collection`	`getQueuedOrphans(String entityName)`	Get the "queued" orphans
`String`	`getRole()`	Get the current role name
`SharedSessionContractImplementor`	`getSession()`	Get the session currently associated with this collection.
`protected Serializable`	`getSnapshot()`	Get the current snapshot from the session
`Serializable`	`getStoredSnapshot()`	Get the snapshot cached by the collection instance
`Object`	`getValue()`	Return the user-visible collection (or array) instance
`boolean`	`hasQueuedOperations()`	Does this instance have any "queued" operations?
`static void`	`identityRemove(Collection list, Object entityInstance, String entityName, SessionImplementor session)`	已过时。 `identityRemove(Collection, Object, String, SharedSessionContractImplementor)` should be used instead.
`static void`	`identityRemove(Collection list, Object entityInstance, String entityName, SharedSessionContractImplementor session)`	Removes entity entries that have an equal identifier with the incoming entity instance
`protected void`	`initialize(boolean writing)`	Initialize the collection, if possible, wrapping any exceptions in a runtime exception
`protected boolean`	`isClearQueueEnabled()`	Is this collection in a state that would allow us to "queue" clear?
`protected boolean`	`isConnectedToSession()`
`boolean`	`isDirectlyAccessible()`	Could the application possibly have a direct reference to the underlying collection implementation?
`boolean`	`isDirty()`	Is the collection dirty?
`boolean`	`isElementRemoved()`
`protected boolean`	`isInitialized()`
`protected boolean`	`isInverseCollection()`	Is this the "inverse" end of a bidirectional association?
`protected boolean`	`isInverseCollectionNoOrphanDelete()`	Is this the "inverse" end of a bidirectional association with no orphan delete enabled?
`protected boolean`	`isInverseOneToManyOrNoOrphanDelete()`	Is this the "inverse" end of a bidirectional one-to-many, or of a collection with no orphan delete?
`protected boolean`	`isOperationQueueEnabled()`	Is this collection in a state that would allow us to "queue" operations?
`protected boolean`	`isPutQueueEnabled()`	Is this collection in a state that would allow us to "queue" puts?
`boolean`	`isRowUpdatePossible()`	Can each element in the collection be mapped unequivocally to a single row in the database?
`boolean`	`isUnreferenced()`	Is the collection unreferenced?
`boolean`	`needsRecreate(CollectionPersister persister)`	Do we need to completely recreate this collection when it changes?
`protected void`	`performQueuedOperations()`	After reading all existing elements from the database, add the queued elements to the underlying collection.
`void`	`postAction()`	After flushing, clear any "queued" additions, since the database state is now synchronized with the memory state.
`void`	`preInsert(CollectionPersister persister)`	Called before inserting rows, to ensure that any surrogate keys are fully generated
`protected void`	`prepareForPossibleLoadingOutsideTransaction()`
`Iterator`	`queuedAdditionIterator()`	Iterator over the "queued" additions
`protected void`	`queueOperation(AbstractPersistentCollection.DelayedOperation operation)`	Queue an addition
`protected void`	`read()`	Called by any read-only method of the collection interface
`protected Object`	`readElementByIndex(Object index)`
`protected Boolean`	`readElementExistence(Object element)`
`protected Boolean`	`readIndexExistence(Object index)`
`protected boolean`	`readSize()`	Called by the `Collection.size()` method
`void`	`replaceQueuedOperationValues(CollectionPersister persister, Map copyCache)`	Replace entity instances with copy in `copyCache`/.
`boolean`	`setCurrentSession(SharedSessionContractImplementor session)`	Associate the collection with the given session.
`protected void`	`setDirectlyAccessible(boolean directlyAccessible)`
`protected void`	`setInitialized()`
`void`	`setOwner(Object owner)`	Set the reference to the owning entity
`void`	`setSnapshot(Serializable key, String role, Serializable snapshot)`	After flushing, re-init snapshot state.
`boolean`	`unsetSession(SharedSessionContractImplementor currentSession)`	Disassociate this collection from the given session.
`boolean`	`wasInitialized()`	Is this instance initialized?
`protected void`	`write()`	Called by any writer method of the collection interface

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

从接口继承的方法 org.hibernate.collection.spi.PersistentCollection
beforeInitialize, disassemble, entries, entryExists, equalsSnapshot, getDeletes, getElement, getIndex, getSnapshot, getSnapshotElement, initializeFromCache, isDirectlyProvidedCollection, isSnapshotEmpty, isWrapper, needsInserting, needsUpdating, readFrom

- 字段详细资料
  - elementRemoved
```
protected boolean elementRemoved
```
  - UNKNOWN
```
protected static final Object UNKNOWN
```
- 构造器详细资料
  - AbstractPersistentCollection
```
public AbstractPersistentCollection()
```
    Not called by Hibernate, but used by non-JDK serialization, eg. SOAP libraries.
  - AbstractPersistentCollection
```
protected AbstractPersistentCollection(SharedSessionContractImplementor session)
```
  - AbstractPersistentCollection
```
@Deprecated
protected AbstractPersistentCollection(SessionImplementor session)
```
    已过时。
    
    * @deprecated AbstractPersistentCollection(SharedSessionContractImplementor) should be used instead.
- 方法详细资料
  - getRole
```
public final String getRole()
```
    从接口复制的说明: PersistentCollection
    
    Get the current role name
    
    指定者:
    
    getRole 在接口中 PersistentCollection
    
    返回:
    
    the collection role name
  - getKey
```
public final Serializable getKey()
```
    从接口复制的说明: PersistentCollection
    
    Get the current collection key value
    
    指定者:
    
    getKey 在接口中 PersistentCollection
    
    返回:
    
    the current collection key value
  - isUnreferenced
```
public final boolean isUnreferenced()
```
    从接口复制的说明: PersistentCollection
    
    Is the collection unreferenced?
    
    指定者:
    
    isUnreferenced 在接口中 PersistentCollection
    
    返回:
    
    true if the collection is no longer referenced by an owner
  - isDirty
```
public final boolean isDirty()
```
    从接口复制的说明: PersistentCollection
    
    Is the collection dirty? Note that this is only reliable during the flush cycle, after the collection elements are dirty checked against the snapshot.
    
    指定者:
    
    isDirty 在接口中 PersistentCollection
    
    返回:
    
    true if the collection is dirty
  - isElementRemoved
```
public boolean isElementRemoved()
```
    指定者:
    
    isElementRemoved 在接口中 PersistentCollection
  - clearDirty
```
public final void clearDirty()
```
    从接口复制的说明: PersistentCollection
    
    Clear the dirty flag, after flushing changes to the database.
    
    指定者:
    
    clearDirty 在接口中 PersistentCollection
  - dirty
```
public final void dirty()
```
    从接口复制的说明: PersistentCollection
    
    Mark the collection as dirty
    
    指定者:
    
    dirty 在接口中 PersistentCollection
  - getStoredSnapshot
```
public final Serializable getStoredSnapshot()
```
    从接口复制的说明: PersistentCollection
    
    Get the snapshot cached by the collection instance
    
    指定者:
    
    getStoredSnapshot 在接口中 PersistentCollection
    
    返回:
    
    The internally stored snapshot state
  - empty
```
public abstract boolean empty()
```
    从接口复制的说明: PersistentCollection
    
    Is the collection empty? (don't try to initialize the collection)
    
    指定者:
    
    empty 在接口中 PersistentCollection
    
    返回:
    
    false if the collection is non-empty; true otherwise.
  - read
```
protected final void read()
```
    Called by any read-only method of the collection interface
  - readSize
```
protected boolean readSize()
```
    Called by the Collection.size() method
  - readIndexExistence
```
protected Boolean readIndexExistence(Object index)
```
  - readElementExistence
```
protected Boolean readElementExistence(Object element)
```
  - readElementByIndex
```
protected Object readElementByIndex(Object index)
```
  - getCachedSize
```
protected int getCachedSize()
```
  - isConnectedToSession
```
protected boolean isConnectedToSession()
```
  - isInitialized
```
protected boolean isInitialized()
```
  - write
```
protected final void write()
```
    Called by any writer method of the collection interface
  - isOperationQueueEnabled
```
protected boolean isOperationQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" operations?
  - isPutQueueEnabled
```
protected boolean isPutQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" puts? This is a special case, because of orphan delete.
  - isClearQueueEnabled
```
protected boolean isClearQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" clear? This is a special case, because of orphan delete.
  - isInverseCollection
```
protected boolean isInverseCollection()
```
    Is this the "inverse" end of a bidirectional association?
  - isInverseCollectionNoOrphanDelete
```
protected boolean isInverseCollectionNoOrphanDelete()
```
    Is this the "inverse" end of a bidirectional association with no orphan delete enabled?
  - isInverseOneToManyOrNoOrphanDelete
```
protected boolean isInverseOneToManyOrNoOrphanDelete()
```
    Is this the "inverse" end of a bidirectional one-to-many, or of a collection with no orphan delete?
  - queueOperation
```
protected final void queueOperation(AbstractPersistentCollection.DelayedOperation operation)
```
    Queue an addition
  - replaceQueuedOperationValues
```
public final void replaceQueuedOperationValues(CollectionPersister persister,
                                               Map copyCache)
```
    Replace entity instances with copy in copyCache/.
    
    参数:
    
    copyCache - - mapping from entity in the process of being merged to managed copy.
  - performQueuedOperations
```
protected final void performQueuedOperations()
```
    After reading all existing elements from the database, add the queued elements to the underlying collection.
  - setSnapshot
```
public void setSnapshot(Serializable key,
                        String role,
                        Serializable snapshot)
```
    从接口复制的说明: PersistentCollection
    
    After flushing, re-init snapshot state.
    
    指定者:
    
    setSnapshot 在接口中 PersistentCollection
    
    参数:
    
    key - The collection instance key (fk value).
    
    role - The collection role
    
    snapshot - The snapshot state
  - postAction
```
public void postAction()
```
    从接口复制的说明: PersistentCollection
    
    After flushing, clear any "queued" additions, since the database state is now synchronized with the memory state.
    
    指定者:
    
    postAction 在接口中 PersistentCollection
  - clearOperationQueue
```
public final void clearOperationQueue()
```
  - getValue
```
public Object getValue()
```
    从接口复制的说明: PersistentCollection
    
    Return the user-visible collection (or array) instance
    
    指定者:
    
    getValue 在接口中 PersistentCollection
    
    返回:
    
    The underlying collection/array
  - beginRead
```
public void beginRead()
```
    从接口复制的说明: PersistentCollection
    
    Called just before reading any rows from the JDBC result set
    
    指定者:
    
    beginRead 在接口中 PersistentCollection
  - endRead
```
public boolean endRead()
```
    从接口复制的说明: PersistentCollection
    
    Called after reading all rows from the JDBC result set
    
    指定者:
    
    endRead 在接口中 PersistentCollection
    
    返回:
    
    Whether to end the read.
  - afterInitialize
```
public boolean afterInitialize()
```
    从接口复制的说明: PersistentCollection
    
    Called after initializing from cache
    
    指定者:
    
    afterInitialize 在接口中 PersistentCollection
    
    返回:
    
    ??
  - initialize
```
protected final void initialize(boolean writing)
```
    Initialize the collection, if possible, wrapping any exceptions in a runtime exception
    
    参数:
    
    writing - currently obsolete
    
    抛出:
    
    LazyInitializationException - if we cannot initialize
  - setInitialized
```
protected final void setInitialized()
```
  - setDirectlyAccessible
```
protected final void setDirectlyAccessible(boolean directlyAccessible)
```
  - isDirectlyAccessible
```
public boolean isDirectlyAccessible()
```
    从接口复制的说明: PersistentCollection
    
    Could the application possibly have a direct reference to the underlying collection implementation?
    
    指定者:
    
    isDirectlyAccessible 在接口中 PersistentCollection
    
    返回:
    
    true indicates that the application might have access to the underlying collection/array.
  - unsetSession
```
public final boolean unsetSession(SharedSessionContractImplementor currentSession)
```
    从接口复制的说明: PersistentCollection
    
    Disassociate this collection from the given session.
    
    指定者:
    
    unsetSession 在接口中 PersistentCollection
    
    参数:
    
    currentSession - The session we are disassociating from. Used for validations.
    
    返回:
    
    true if this was currently associated with the given session
  - prepareForPossibleLoadingOutsideTransaction
```
protected void prepareForPossibleLoadingOutsideTransaction()
```
  - setCurrentSession
```
public final boolean setCurrentSession(SharedSessionContractImplementor session)
                                throws HibernateException
```
    从接口复制的说明: PersistentCollection
    
    Associate the collection with the given session.
    
    指定者:
    
    setCurrentSession 在接口中 PersistentCollection
    
    参数:
    
    session - The session to associate with
    
    返回:
    
    false if the collection was already associated with the session
    
    抛出:
    
    HibernateException - if the collection was already associated with another open session
  - needsRecreate
```
public boolean needsRecreate(CollectionPersister persister)
```
    从接口复制的说明: PersistentCollection
    
    Do we need to completely recreate this collection when it changes?
    
    指定者:
    
    needsRecreate 在接口中 PersistentCollection
    
    参数:
    
    persister - The collection persister
    
    返回:
    
    true if a change requires a recreate.
  - forceInitialization
```
public final void forceInitialization()
                               throws HibernateException
```
    从接口复制的说明: PersistentCollection
    
    To be called internally by the session, forcing immediate initialization.
    
    指定者:
    
    forceInitialization 在接口中 PersistentCollection
    
    抛出:
    
    HibernateException
  - getSnapshot
```
protected final Serializable getSnapshot()
```
    Get the current snapshot from the session
  - wasInitialized
```
public final boolean wasInitialized()
```
    从接口复制的说明: PersistentCollection
    
    Is this instance initialized?
    
    指定者:
    
    wasInitialized 在接口中 PersistentCollection
    
    返回:
    
    Was this collection initialized? Or is its data still not (fully) loaded?
  - isRowUpdatePossible
```
public boolean isRowUpdatePossible()
```
    从接口复制的说明: PersistentCollection
    
    Can each element in the collection be mapped unequivocally to a single row in the database? Generally bags and sets are the only collections that cannot be.
    
    指定者:
    
    isRowUpdatePossible 在接口中 PersistentCollection
    
    返回:
    
    true if the row for each element is known
  - hasQueuedOperations
```
public final boolean hasQueuedOperations()
```
    从接口复制的说明: PersistentCollection
    
    Does this instance have any "queued" operations?
    
    指定者:
    
    hasQueuedOperations 在接口中 PersistentCollection
    
    返回:
    
    true indicates there are pending, queued, delayed operations
  - queuedAdditionIterator
```
public final Iterator queuedAdditionIterator()
```
    从接口复制的说明: PersistentCollection
    
    Iterator over the "queued" additions
    
    指定者:
    
    queuedAdditionIterator 在接口中 PersistentCollection
    
    返回:
    
    The iterator
  - getQueuedOrphans
```
public final Collection getQueuedOrphans(String entityName)
```
    从接口复制的说明: PersistentCollection
    
    Get the "queued" orphans
    
    指定者:
    
    getQueuedOrphans 在接口中 PersistentCollection
    
    参数:
    
    entityName - The name of the entity that makes up the elements
    
    返回:
    
    The orphaned elements
  - preInsert
```
public void preInsert(CollectionPersister persister)
               throws HibernateException
```
    从接口复制的说明: PersistentCollection
    
    Called before inserting rows, to ensure that any surrogate keys are fully generated
    
    指定者:
    
    preInsert 在接口中 PersistentCollection
    
    参数:
    
    persister - The collection persister
    
    抛出:
    
    HibernateException
  - afterRowInsert
```
public void afterRowInsert(CollectionPersister persister,
                           Object entry,
                           int i)
                    throws HibernateException
```
    从接口复制的说明: PersistentCollection
    
    Called after inserting a row, to fetch the natively generated id
    
    指定者:
    
    afterRowInsert 在接口中 PersistentCollection
    
    参数:
    
    persister - The collection persister
    
    entry - The collection element just inserted
    
    i - The element position/index
    
    抛出:
    
    HibernateException
  - getOrphans
```
public abstract Collection getOrphans(Serializable snapshot,
                                      String entityName)
                               throws HibernateException
```
    从接口复制的说明: PersistentCollection
    
    get all "orphaned" elements
    
    指定者:
    
    getOrphans 在接口中 PersistentCollection
    
    参数:
    
    snapshot - The snapshot state
    
    entityName - The name of the entity that are the elements of the collection
    
    返回:
    
    The orphans
    
    抛出:
    
    HibernateException
  - getSession
```
public final SharedSessionContractImplementor getSession()
```
    Get the session currently associated with this collection.
    
    返回:
    
    The session
  - getOrphans
```
protected static Collection getOrphans(Collection oldElements,
                                       Collection currentElements,
                                       String entityName,
                                       SharedSessionContractImplementor session)
                                throws HibernateException
```
    Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans
    
    抛出:
    
    HibernateException
  - identityRemove
```
public static void identityRemove(Collection list,
                                  Object entityInstance,
                                  String entityName,
                                  SharedSessionContractImplementor session)
```
    Removes entity entries that have an equal identifier with the incoming entity instance
    
    参数:
    
    list - The list containing the entity instances
    
    entityInstance - The entity instance to match elements.
    
    entityName - The entity name
    
    session - The session
  - identityRemove
```
@Deprecated
public static void identityRemove(Collection list,
                                  Object entityInstance,
                                  String entityName,
                                  SessionImplementor session)
```
    已过时。
    identityRemove(Collection, Object, String, SharedSessionContractImplementor) should be used instead.
    
    Removes entity entries that have an equal identifier with the incoming entity instance
    
    参数:
    
    list - The list containing the entity instances
    
    entityInstance - The entity instance to match elements.
    
    entityName - The entity name
    
    session - The session
  - getIdentifier
```
public Object getIdentifier(Object entry,
                            int i)
```
    从接口复制的说明: PersistentCollection
    
    Get the identifier of the given collection entry. This refers to the collection identifier, not the identifier of the (possibly) entity elements. This is only valid for invocation on the idbag collection.
    
    指定者:
    
    getIdentifier 在接口中 PersistentCollection
    
    参数:
    
    entry - The collection entry/element
    
    i - The assumed identifier (?)
    
    返回:
    
    The identifier value
  - getOwner
```
public Object getOwner()
```
    从接口复制的说明: PersistentCollection
    
    Get the owning entity. Note that the owner is only set during the flush cycle, and when a new collection wrapper is created while loading an entity.
    
    指定者:
    
    getOwner 在接口中 PersistentCollection
    
    返回:
    
    The owner
  - setOwner
```
public void setOwner(Object owner)
```
    从接口复制的说明: PersistentCollection
    
    Set the reference to the owning entity
    
    指定者:
    
    setOwner 在接口中 PersistentCollection
    
    参数:
    
    owner - The owner

修饰符和类型	字段	说明
`protected boolean`	`elementRemoved`
`protected static Object`	`UNKNOWN`

类 AbstractPersistentCollection

嵌套类概要

字段概要

构造器概要

方法概要

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

从接口继承的方法 org.hibernate.collection.spi.PersistentCollection

字段详细资料

elementRemoved

UNKNOWN

构造器详细资料

AbstractPersistentCollection

AbstractPersistentCollection

AbstractPersistentCollection

方法详细资料

getRole

getKey

isUnreferenced

isDirty

isElementRemoved

clearDirty

dirty

getStoredSnapshot

empty

read

readSize

readIndexExistence

readElementExistence

readElementByIndex

getCachedSize

isConnectedToSession

isInitialized

write

isOperationQueueEnabled

isPutQueueEnabled

isClearQueueEnabled

isInverseCollection

isInverseCollectionNoOrphanDelete

isInverseOneToManyOrNoOrphanDelete

queueOperation

replaceQueuedOperationValues

performQueuedOperations

setSnapshot

postAction

clearOperationQueue

getValue

beginRead

endRead

afterInitialize

initialize

setInitialized

setDirectlyAccessible

isDirectlyAccessible

unsetSession

prepareForPossibleLoadingOutsideTransaction

setCurrentSession

needsRecreate

forceInitialization

getSnapshot

wasInitialized

isRowUpdatePossible

hasQueuedOperations

queuedAdditionIterator

getQueuedOrphans

preInsert

afterRowInsert

getOrphans

getSession

getOrphans

identityRemove

identityRemove

getIdentifier

getOwner

setOwner