/** This for is used during custom deserialization handling */ @SuppressWarnings({"JavaDoc"}) private EntityEntry( final SessionFactoryImplementor factory, final String entityName, final Serializable id, final EntityMode entityMode, final String tenantId, final Status status, final Status previousStatus, final Object[] loadedState, final Object[] deletedState, final Object version, final LockMode lockMode, final boolean existsInDatabase, final boolean isBeingReplicated, final boolean loadedWithLazyPropertiesUnfetched, final PersistenceContext persistenceContext) { this.entityName = entityName; this.persister = (factory == null ? null : factory.getEntityPersister(entityName)); this.id = id; this.entityMode = entityMode; this.tenantId = tenantId; this.status = status; this.previousStatus = previousStatus; this.loadedState = loadedState; this.deletedState = deletedState; this.version = version; this.lockMode = lockMode; this.existsInDatabase = existsInDatabase; this.isBeingReplicated = isBeingReplicated; this.loadedWithLazyPropertiesUnfetched = loadedWithLazyPropertiesUnfetched; this.rowId = null; // this is equivalent to the old behavior... this.persistenceContext = persistenceContext; }
public String toString() { return "CollectionKey" + MessageHelper.collectionInfoString(factory.getCollectionPersister(role), key, factory); }
/** * Perform the second step of 2-phase load. Fully initialize the entity instance. * * <p>After processing a JDBC result set, we "resolve" all the associations between the entities * which were instantiated and had their state "hydrated" into an array */ public static void initializeEntity( final Object entity, final boolean readOnly, final SessionImplementor session, final PreLoadEvent preLoadEvent, final PostLoadEvent postLoadEvent) throws HibernateException { // TODO: Should this be an InitializeEntityEventListener??? (watch out for performance!) final PersistenceContext persistenceContext = session.getPersistenceContext(); EntityEntry entityEntry = persistenceContext.getEntry(entity); if (entityEntry == null) { throw new AssertionFailure("possible non-threadsafe access to the session"); } EntityPersister persister = entityEntry.getPersister(); Serializable id = entityEntry.getId(); Object[] hydratedState = entityEntry.getLoadedState(); if (log.isDebugEnabled()) log.debug( "resolving associations for " + MessageHelper.infoString(persister, id, session.getFactory())); Type[] types = persister.getPropertyTypes(); for (int i = 0; i < hydratedState.length; i++) { final Object value = hydratedState[i]; if (value != LazyPropertyInitializer.UNFETCHED_PROPERTY && value != BackrefPropertyAccessor.UNKNOWN) { hydratedState[i] = types[i].resolve(value, session, entity); } } // Must occur after resolving identifiers! if (session.isEventSource()) { preLoadEvent.setEntity(entity).setState(hydratedState).setId(id).setPersister(persister); PreLoadEventListener[] listeners = session.getListeners().getPreLoadEventListeners(); for (int i = 0; i < listeners.length; i++) { listeners[i].onPreLoad(preLoadEvent); } } persister.setPropertyValues(entity, hydratedState, session.getEntityMode()); final SessionFactoryImplementor factory = session.getFactory(); if (persister.hasCache() && session.getCacheMode().isPutEnabled()) { if (log.isDebugEnabled()) log.debug( "adding entity to second-level cache: " + MessageHelper.infoString(persister, id, session.getFactory())); Object version = Versioning.getVersion(hydratedState, persister); CacheEntry entry = new CacheEntry( hydratedState, persister, entityEntry.isLoadedWithLazyPropertiesUnfetched(), version, session, entity); CacheKey cacheKey = new CacheKey( id, persister.getIdentifierType(), persister.getRootEntityName(), session.getEntityMode(), session.getFactory()); boolean put = persister .getCache() .put( cacheKey, persister.getCacheEntryStructure().structure(entry), session.getTimestamp(), version, persister.isVersioned() ? persister.getVersionType().getComparator() : null, useMinimalPuts( session, entityEntry)); // we could use persister.hasLazyProperties() instead of true if (put && factory.getStatistics().isStatisticsEnabled()) { factory .getStatisticsImplementor() .secondLevelCachePut(persister.getCache().getRegionName()); } } if (readOnly || !persister.isMutable()) { // no need to take a snapshot - this is a // performance optimization, but not really // important, except for entities with huge // mutable property values persistenceContext.setEntryStatus(entityEntry, Status.READ_ONLY); } else { // take a snapshot TypeFactory.deepCopy( hydratedState, persister.getPropertyTypes(), persister.getPropertyUpdateability(), hydratedState, // after setting values to object, entityMode session); persistenceContext.setEntryStatus(entityEntry, Status.MANAGED); } persister.afterInitialize(entity, entityEntry.isLoadedWithLazyPropertiesUnfetched(), session); if (session.isEventSource()) { postLoadEvent.setEntity(entity).setId(id).setPersister(persister); PostLoadEventListener[] listeners = session.getListeners().getPostLoadEventListeners(); for (int i = 0; i < listeners.length; i++) { listeners[i].onPostLoad(postLoadEvent); } } if (log.isDebugEnabled()) log.debug( "done materializing entity " + MessageHelper.infoString(persister, id, session.getFactory())); if (factory.getStatistics().isStatisticsEnabled()) { factory.getStatisticsImplementor().loadEntity(persister.getEntityName()); } }