@Override public void onPostLoad(PostLoadEvent event) { final Object entity = event.getEntity(); final EntityEntry entry = event.getSession().getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new AssertionFailure( "possible non-threadsafe access to the session" ); entry.getId(), entry.getVersion(), event.getSession() ); entry.forceLocked( entity, nextVersion ); event.getSession().getActionQueue().registerProcess( incrementVersion ); event.getSession().getActionQueue().registerProcess( verifyVersion ); if ( event.getPersister().implementsLifecycle() ) { ( (Lifecycle) event.getEntity() ).onLoad( event.getSession(), event.getId() );
private LoadEvent( Serializable entityId, String entityClassName, Object instanceToLoad, LockOptions lockOptions, boolean isAssociationFetch, EventSource source) { super(source); if ( entityId == null ) { throw new IllegalArgumentException("id to load is required for loading"); } if ( lockOptions.getLockMode() == LockMode.WRITE ) { throw new IllegalArgumentException("Invalid lock mode for loading"); } else if ( lockOptions.getLockMode() == null ) { lockOptions.setLockMode(DEFAULT_LOCK_MODE); } this.entityId = entityId; this.entityClassName = entityClassName; this.instanceToLoad = instanceToLoad; this.lockOptions = lockOptions; this.isAssociationFetch = isAssociationFetch; this.postLoadEvent = new PostLoadEvent( source ); }
/** * PostLoad cannot occur during initializeEntity, as that call occurs *before* * the Set collections are added to the persistence context by Loader. * Without the split, LazyInitializationExceptions can occur in the Entity's * postLoad if it acts upon the collection. * * HHH-6043 * * @param entity The entity * @param session The Session * @param postLoadEvent The (re-used) post-load event */ public static void postLoad( final Object entity, final SharedSessionContractImplementor session, final PostLoadEvent postLoadEvent) { if ( session.isEventSource() ) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final EntityEntry entityEntry = persistenceContext.getEntry( entity ); postLoadEvent.setEntity( entity ).setId( entityEntry.getId() ).setPersister( entityEntry.getPersister() ); final EventListenerGroup<PostLoadEventListener> listenerGroup = session.getFactory() .getServiceRegistry() .getService( EventListenerRegistry.class ) .getEventListenerGroup( EventType.POST_LOAD ); for ( PostLoadEventListener listener : listenerGroup.listeners() ) { listener.onPostLoad( postLoadEvent ); } } }
@Override public void onPostLoad(PostLoadEvent event) { if (Obs.class.isAssignableFrom(event.getEntity().getClass())) { Field field = null; try { field = Obs.class.getDeclaredField("dirty"); field.setAccessible(true); field.set(event.getEntity(), false); } catch (ReflectiveOperationException e) { log.error("Failed to unset an Obs as dirty after being loaded from the database", e); } finally { if (field != null) { field.setAccessible(false); } } } } }
@Override public void onPostLoad(PostLoadEvent event) { final Object entity = event.getEntity(); final EntityEntry entry = event.getSession().getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new AssertionFailure( "possible non-threadsafe access to the session" ); entry.getId(), entry.getVersion(), event.getSession() ); entry.forceLocked( entity, nextVersion ); event.getSession().getActionQueue().registerProcess( incrementVersion ); event.getSession().getActionQueue().registerProcess( verifyVersion ); if ( event.getDescriptor().implementsLifecycle() ) { ( (Lifecycle) event.getEntity() ).onLoad( event.getSession(), event.getId() );
PostLoadEvent postLoadEvent = new PostLoadEvent( session ) .setEntity( result ) .setId( id ) .setPersister( persister );
public void onPostLoad(PostLoadEvent event) { ClosureEventListener eventListener = findEventListener(event.getEntity(), event.getPersister().getFactory()); if (eventListener != null) { eventListener.onPostLoad(event); } }
private void postLoad(RowProcessingState rowProcessingState) { final PostLoadEvent postLoadEvent = rowProcessingState.getJdbcValuesSourceProcessingState().getPostLoadEvent(); postLoadEvent.reset(); postLoadEvent.setEntity( entityInstance ) .setId( entityKey.getIdentifier() ) .setDescriptor( concreteDescriptor ); final EventListenerGroup<PostLoadEventListener> listenerGroup = entityDescriptor.getFactory() .getServiceRegistry() .getService( EventListenerRegistry.class ) .getEventListenerGroup( EventType.POST_LOAD ); for ( PostLoadEventListener listener : listenerGroup.listeners() ) { listener.onPostLoad( postLoadEvent ); } }
/** * PostLoad cannot occur during initializeEntity, as that call occurs *before* * the Set collections are added to the persistence context by Loader. * Without the split, LazyInitializationExceptions can occur in the Entity's * postLoad if it acts upon the collection. * * HHH-6043 * * @param entity The entity * @param session The Session * @param postLoadEvent The (re-used) post-load event */ public static void postLoad( final Object entity, final SharedSessionContractImplementor session, final PostLoadEvent postLoadEvent) { if ( session.isEventSource() ) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final EntityEntry entityEntry = persistenceContext.getEntry( entity ); postLoadEvent.setEntity( entity ).setId( entityEntry.getId() ).setDescriptor( entityEntry.getDescriptor() ); final EventListenerGroup<PostLoadEventListener> listenerGroup = session.getFactory() .getServiceRegistry() .getService( EventListenerRegistry.class ) .getEventListenerGroup( EventType.POST_LOAD ); for ( PostLoadEventListener listener : listenerGroup.listeners() ) { listener.onPostLoad( postLoadEvent ); } } }
PostLoadEvent postLoadEvent = new PostLoadEvent( session ) .setEntity( result ) .setId( id ) .setPersister( persister );
public void onPostLoad(PostLoadEvent event) { final Object entity = event.getEntity(); final EntityEntry entry = event.getSession().getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new AssertionFailure( "possible non-threadsafe access to the session" ); final EntityPersister persister = entry.getPersister(); Object nextVersion = persister.forceVersionIncrement( entry.getId(), entry.getVersion(), event.getSession() ); entry.forceLocked( entity, nextVersion ); event.getSession().getActionQueue().registerProcess( incrementVersion ); event.getSession().getActionQueue().registerProcess( verifyVersion ); if ( event.getPersister().implementsLifecycle() ) { ( ( Lifecycle ) event.getEntity() ).onLoad( event.getSession(), event.getId() );
@Override public Object call() { postLoadEventListener.call(event.getEntity()); return null; } });
.setEntity( entity ) .setId( entityId ) .setPersister( persister );
@Override public void finishUp(ResultSetProcessingContextImpl context, List<AfterLoadAction> afterLoadActionList) { final List<HydratedEntityRegistration> hydratedEntityRegistrations = context.getHydratedEntityRegistrationList(); // for arrays, we should end the collection load before resolving the entities, since the // actual array instances are not instantiated during loading finishLoadingArrays( context ); // IMPORTANT: reuse the same event instances for performance! final PreLoadEvent preLoadEvent; final PostLoadEvent postLoadEvent; if ( context.getSession().isEventSource() ) { preLoadEvent = new PreLoadEvent( (EventSource) context.getSession() ); postLoadEvent = new PostLoadEvent( (EventSource) context.getSession() ); } else { preLoadEvent = null; postLoadEvent = null; } // now finish loading the entities (2-phase load) performTwoPhaseLoad( preLoadEvent, context, hydratedEntityRegistrations ); // now we can finalize loading collections finishLoadingCollections( context ); // and trigger the afterInitialize() hooks afterInitialize( context, hydratedEntityRegistrations ); // finally, perform post-load operations postLoad( postLoadEvent, context, hydratedEntityRegistrations, afterLoadActionList ); }
public void onPostLoad(PostLoadEvent event) { final Object entity = event.getEntity(); final EntityEntry entry = event.getSession().getPersistenceContext().getEntry( entity ); if ( entry == null ) { throw new AssertionFailure( "possible non-threadsafe access to the session" ); final EntityPersister persister = entry.getPersister(); Object nextVersion = persister.forceVersionIncrement( entry.getId(), entry.getVersion(), event.getSession() ); entry.forceLocked( entity, nextVersion ); event.getSession().getActionQueue().registerProcess( incrementVersion ); event.getSession().getActionQueue().registerProcess( verifyVersion ); if ( event.getPersister().implementsLifecycle() ) { ( ( Lifecycle ) event.getEntity() ).onLoad( event.getSession(), event.getId() );
@Override public void onPostLoad(PostLoadEvent event) { IPostLoadHandler handler = IPostLoadHandler.class.cast(event.getEntity()); handler.onPostLoad(); } }
postLoadEvent.setEntity( entity ).setId( id ).setPersister( persister );
if ( session.isEventSource() ) { pre = new PreLoadEvent( (EventSource) session ); post = new PostLoadEvent( (EventSource) session );
/** * Retrieves the entity and triggers the onLoad lifecycle hook. * <p> * {@inheritDoc} */ @Override public void onPostLoad(PostLoadEvent event) { Object entity = event.getEntity(); if (entity instanceof ILifecycleCapable) { ((ILifecycleCapable) entity).onLoad(); } }