Package org.hibernate.event

Examples of org.hibernate.event.EventSource


   *
   * @throws HibernateException
   */
  public void onDelete(DeleteEvent event, Set transientEntities) throws HibernateException {

    final EventSource source = event.getSession();

    final PersistenceContext persistenceContext = source.getPersistenceContext();
    Object entity = persistenceContext.unproxyAndReassociate( event.getObject() );

    EntityEntry entityEntry = persistenceContext.getEntry( entity );
    final EntityPersister persister;
    final Serializable id;
    final Object version;

    if ( entityEntry == null ) {
      log.trace( "entity was not persistent in delete processing" );

      persister = source.getEntityPersister( event.getEntityName(), entity );

      if ( ForeignKeys.isTransient( persister.getEntityName(), entity, null, source ) ) {
        deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities );
        // EARLY EXIT!!!
        return;
      }
      else {
        performDetachedEntityDeletionCheck( event );
      }

      id = persister.getIdentifier( entity, source.getEntityMode() );

      if ( id == null ) {
        throw new TransientObjectException(
            "the detached instance passed to delete() had a null identifier"
        );
      }

      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );

      persistenceContext.checkUniqueness( key, entity );

      new OnUpdateVisitor( source, id, entity ).process( entity, persister );

      version = persister.getVersion( entity, source.getEntityMode() );

      entityEntry = persistenceContext.addEntity(
          entity,
          Status.MANAGED,
          persister.getPropertyValues( entity, source.getEntityMode() ),
          key,
          version,
          LockMode.NONE,
          true,
          persister,
          false,
          false
      );
    }
    else {
      log.trace( "deleting a persistent instance" );

      if ( entityEntry.getStatus() == Status.DELETED || entityEntry.getStatus() == Status.GONE ) {
        log.trace( "object was already deleted" );
        return;
      }
      persister = entityEntry.getPersister();
      id = entityEntry.getId();
      version = entityEntry.getVersion();
    }

    /*if ( !persister.isMutable() ) {
      throw new HibernateException(
          "attempted to delete an object of immutable class: " +
          MessageHelper.infoString(persister)
        );
    }*/

    if ( invokeDeleteLifecycle( source, entity, persister ) ) {
      return;
    }

    deleteEntity( source, entity, entityEntry, event.isCascadeDeleteEnabled(), persister, transientEntities );

    if ( source.getFactory().getSettings().isIdentifierRollbackEnabled() ) {
      persister.resetIdentifier( entity, id, version, source.getEntityMode() );
    }
  }
View Full Code Here


      final Serializable id,
      final EntityPersister persister,
      final LoadEvent event) throws HibernateException {

    final Object optionalObject = event.getInstanceToLoad();
    final EventSource session = event.getSession();
    final SessionFactoryImplementor factory = session.getFactory();

    if ( log.isTraceEnabled() ) {
      log.trace(
          "assembling entity from second-level cache: " +
          MessageHelper.infoString( persister, id, factory )
        );
    }

    EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() );
    Object result = optionalObject == null ?
        session.instantiate( subclassPersister, id ) : optionalObject;

    // make it circular-reference safe
    TwoPhaseLoad.addUninitializedCachedEntity(
        new EntityKey( id, subclassPersister, session.getEntityMode() ),
        result,
        subclassPersister,
        LockMode.NONE,
        entry.areLazyPropertiesUnfetched(),
        entry.getVersion(),
        session
      );

    Type[] types = subclassPersister.getPropertyTypes();
    Object[] values = entry.assemble( result, id, subclassPersister, session.getInterceptor(), session ); // intializes result by side-effect
    TypeFactory.deepCopy(
        values,
        types,
        subclassPersister.getPropertyUpdateability(),
        values,
        session
      );

    Object version = Versioning.getVersion( values, subclassPersister );
    if ( log.isTraceEnabled() ) log.trace( "Cached Version: " + version );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    persistenceContext.addEntry(
        result,
        Status.MANAGED,
        values,
        null,
        id,
        version,
        LockMode.NONE,
        true,
        subclassPersister,
        false,
        entry.areLazyPropertiesUnfetched()
      );
    subclassPersister.afterInitialize( result, entry.areLazyPropertiesUnfetched(), session );
    persistenceContext.initializeNonLazyCollections();
    // upgrade the lock if necessary:
    //lock(result, lockMode);

    //PostLoad is needed for EJB3
    //TODO: reuse the PostLoadEvent...
    PostLoadEvent postLoadEvent = new PostLoadEvent(session).setEntity(result)
        .setId(id).setPersister(persister);
    PostLoadEventListener[] listeners = session.getListeners().getPostLoadEventListeners();
    for ( int i = 0; i < listeners.length; i++ ) {
      listeners[i].onPostLoad(postLoadEvent);
    }

    return result;
View Full Code Here

      final Serializable id,
      final EntityPersister persister,
      final LoadEvent event) throws HibernateException {

    final Object optionalObject = event.getInstanceToLoad();
    final EventSource session = event.getSession();
    final SessionFactoryImplementor factory = session.getFactory();

    if ( log.isTraceEnabled() ) {
      log.trace(
          "assembling entity from second-level cache: " +
          MessageHelper.infoString( persister, id, factory )
        );
    }

    EntityPersister subclassPersister = factory.getEntityPersister( entry.getSubclass() );
    Object result = optionalObject == null ?
        session.instantiate( subclassPersister, id ) : optionalObject;

    // make it circular-reference safe
    EntityKey entityKey = new EntityKey( id, subclassPersister, session.getEntityMode() );
    TwoPhaseLoad.addUninitializedCachedEntity(
        entityKey,
        result,
        subclassPersister,
        LockMode.NONE,
        entry.areLazyPropertiesUnfetched(),
        entry.getVersion(),
        session
      );

    Type[] types = subclassPersister.getPropertyTypes();
    Object[] values = entry.assemble( result, id, subclassPersister, session.getInterceptor(), session ); // intializes result by side-effect
    TypeFactory.deepCopy(
        values,
        types,
        subclassPersister.getPropertyUpdateability(),
        values,
        session
      );

    Object version = Versioning.getVersion( values, subclassPersister );
    if ( log.isTraceEnabled() ) log.trace( "Cached Version: " + version );

    final PersistenceContext persistenceContext = session.getPersistenceContext();
    boolean isReadOnly = session.isDefaultReadOnly();
    if ( persister.isMutable() ) {
      Object proxy = persistenceContext.getProxy( entityKey );
      if ( proxy != null ) {
        // there is already a proxy for this impl
        // only set the status to read-only if the proxy is read-only
        isReadOnly = ( ( HibernateProxy ) proxy ).getHibernateLazyInitializer().isReadOnly();
      }
    }
    else {
      isReadOnly = true;
    }
    persistenceContext.addEntry(
        result,
        ( isReadOnly ? Status.READ_ONLY : Status.MANAGED ),
        values,
        null,
        id,
        version,
        LockMode.NONE,
        true,
        subclassPersister,
        false,
        entry.areLazyPropertiesUnfetched()
      );
    subclassPersister.afterInitialize( result, entry.areLazyPropertiesUnfetched(), session );
    persistenceContext.initializeNonLazyCollections();
    // upgrade the lock if necessary:
    //lock(result, lockMode);

    //PostLoad is needed for EJB3
    //TODO: reuse the PostLoadEvent...
    PostLoadEvent postLoadEvent = new PostLoadEvent(session).setEntity(result)
        .setId(id).setPersister(persister);
    PostLoadEventListener[] listeners = session.getListeners().getPostLoadEventListeners();
    for ( int i = 0; i < listeners.length; i++ ) {
      listeners[i].onPostLoad(postLoadEvent);
    }

    return result;
View Full Code Here

  }
   
  protected void entityIsPersistent(PersistEvent event, Map createCache) {
    log.trace("ignoring persistent instance");
    final EventSource source = event.getSession();
   
    //TODO: check that entry.getIdentifier().equals(requestedId)
   
    final Object entity = source.getPersistenceContext().unproxy( event.getObject() );
    final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
   
    if ( createCache.put(entity, entity)==null ) {
      //TODO: merge into one method!
      cascadeBeforeSave(source, persister, entity, createCache);
      cascadeAfterSave(source, persister, entity, createCache);
View Full Code Here

   */
  protected void entityIsTransient(PersistEvent event, Map createCache) throws HibernateException {
   
    log.trace("saving transient instance");

    final EventSource source = event.getSession();
   
    final Object entity = source.getPersistenceContext().unproxy( event.getObject() );
   
    if ( createCache.put(entity, entity)==null ) {
      saveWithGeneratedId( entity, event.getEntityName(), createCache, source, false );
    }

View Full Code Here

   *
   * @param event The refresh event to be handled.
   */
  public void onRefresh(RefreshEvent event, Map refreshedAlready) {

    final EventSource source = event.getSession();
   
    if ( source.getPersistenceContext().reassociateIfUninitializedProxy( event.getObject() ) ) return;

    final Object object = source.getPersistenceContext().unproxyAndReassociate( event.getObject() );

    if ( refreshedAlready.containsKey(object) ) {
      log.trace("already refreshed");
      return;
    }

    final EntityEntry e = source.getPersistenceContext().getEntry( object );
    final EntityPersister persister;
    final Serializable id;
   
    if ( e == null ) {
      persister = source.getEntityPersister(null, object); //refresh() does not pass an entityName
      id = persister.getIdentifier( object, event.getSession().getEntityMode() );
      if ( log.isTraceEnabled() ) {
        log.trace(
            "refreshing transient " +
            MessageHelper.infoString( persister, id, source.getFactory() )
          );
      }
      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
      if ( source.getPersistenceContext().getEntry(key) != null ) {
        throw new PersistentObjectException(
            "attempted to refresh transient instance when persistent instance was already associated with the Session: " +
            MessageHelper.infoString(persister, id, source.getFactory() )
          );
      }
    }
    else {
      if ( log.isTraceEnabled() ) {
        log.trace(
            "refreshing " +
            MessageHelper.infoString( e.getPersister(), e.getId(), source.getFactory()  )
          );
      }
      if ( !e.isExistsInDatabase() ) {
        throw new HibernateException( "this instance does not yet exist as a row in the database" );
      }

      persister = e.getPersister();
      id = e.getId();
    }

    // cascade the refresh prior to refreshing this entity
    refreshedAlready.put(object, object);
    new Cascade(CascadingAction.REFRESH, Cascade.BEFORE_REFRESH, source)
        .cascade( persister, object, refreshedAlready );

    if ( e != null ) {
      EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
      source.getPersistenceContext().removeEntity(key);
      if ( persister.hasCollections() ) new EvictVisitor( source ).process(object, persister);
    }

    if ( persister.hasCache() ) {
      final CacheKey ck = new CacheKey(
          id,
          persister.getIdentifierType(),
          persister.getRootEntityName(),
          source.getEntityMode(),
          source.getFactory()
      );
      persister.getCacheAccessStrategy().evict( ck );
    }
   
    evictCachedCollections( persister, id, source.getFactory() );
   
    String previousFetchProfile = source.getFetchProfile();
    source.setFetchProfile("refresh");
    Object result = persister.load( id, object, event.getLockMode(), source );
    source.setFetchProfile(previousFetchProfile);
   
    UnresolvableObjectException.throwIfNull( result, id, persister.getEntityName() );

  }
View Full Code Here

     * @param event The auto-flush event to be handled.
     * @throws HibernateException
     */
  public void onAutoFlush(AutoFlushEvent event) throws HibernateException {

    final EventSource source = event.getSession();
   
    if ( flushMightBeNeeded(source) ) {

      final int oldSize = source.getActionQueue().numberOfCollectionRemovals();

      flushEverythingToExecutions(event);
     
      if ( flushIsReallyNeeded(event, source) ) {

        log.trace("Need to execute flush");

        performExecutions(source);
        postFlush(source);
        // note: performExecutions() clears all collectionXxxxtion
        // collections (the collection actions) in the session

        if ( source.getFactory().getStatistics().isStatisticsEnabled() ) {
          source.getFactory().getStatisticsImplementor().flush();
        }
       
      }
      else {

        log.trace("Dont need to execute flush");
        source.getActionQueue().clearFromFlushNeededCheck( oldSize );
      }
     
      event.setFlushRequired( flushIsReallyNeeded( event, source ) );

    }
View Full Code Here

          "reassociating transient instance: " +
              MessageHelper.infoString( persister, id, event.getSession().getFactory() )
      );
    }

    EventSource source = event.getSession();
    EntityKey key = new EntityKey( id, persister, source.getEntityMode() );

    source.getPersistenceContext().checkUniqueness( key, object );

    //get a snapshot
    Object[] values = persister.getPropertyValues( object, source.getEntityMode() );
    TypeFactory.deepCopy(
        values,
        persister.getPropertyTypes(),
        persister.getPropertyUpdateability(),
        values,
        source
    );
    Object version = Versioning.getVersion( values, persister );

    EntityEntry newEntry = source.getPersistenceContext().addEntity(
        object,
        Status.MANAGED,
        values,
        key,
        version,
View Full Code Here

   * @throws HibernateException
   */
  public void onMerge(MergeEvent event, Map copiedAlready) throws HibernateException {

    final EventCache copyCache = ( EventCache ) copiedAlready;
    final EventSource source = event.getSession();
    final Object original = event.getOriginal();

    if ( original != null ) {

      final Object entity;
      if ( original instanceof HibernateProxy ) {
        LazyInitializer li = ( (HibernateProxy) original ).getHibernateLazyInitializer();
        if ( li.isUninitialized() ) {
          log.trace("ignoring uninitialized proxy");
          event.setResult( source.load( li.getEntityName(), li.getIdentifier() ) );
          return; //EARLY EXIT!
        }
        else {
          entity = li.getImplementation();
        }
      }
      else {
        entity = original;
      }

      if ( copyCache.containsKey( entity ) &&
          ( copyCache.isOperatedOn( entity ) ) ) {
        log.trace("already in merge process");
        event.setResult( entity );       
      }
      else {
        if ( copyCache.containsKey( entity ) ) {
          log.trace("already in copyCache; setting in merge process");         
          copyCache.setOperatedOn( entity, true );
        }
        event.setEntity( entity );
        int entityState = -1;

        // Check the persistence context for an entry relating to this
        // entity to be merged...
        EntityEntry entry = source.getPersistenceContext().getEntry( entity );
        if ( entry == null ) {
          EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
          Serializable id = persister.getIdentifier( entity, source.getEntityMode() );
          if ( id != null ) {
            EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
            Object managedEntity = source.getPersistenceContext().getEntity( key );
            entry = source.getPersistenceContext().getEntry( managedEntity );
            if ( entry != null ) {
              // we have specialized case of a detached entity from the
              // perspective of the merge operation.  Specifically, we
              // have an incoming entity instance which has a corresponding
              // entry in the current persistence context, but registered
View Full Code Here

    log.trace("ignoring persistent instance");
   
    //TODO: check that entry.getIdentifier().equals(requestedId)
   
    final Object entity = event.getEntity();
    final EventSource source = event.getSession();
    final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );

    ( ( EventCache ) copyCache ).put( entity, entity, true  )//before cascade!
   
    cascadeOnMerge(source, persister, entity, copyCache);
    copyValues(persister, entity, entity, source, copyCache);
View Full Code Here

TOP

Related Classes of org.hibernate.event.EventSource

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.