Java 类org.hibernate.event.SaveOrUpdateEvent 实例源码

protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) {
    // this implementation is supposed to tolerate incorrect unsaved-value
    // mappings, for the purpose of backward-compatibility
    EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() );
    if ( entry!=null ) {
        if ( entry.getStatus()==Status.DELETED ) {
            throw new ObjectDeletedException( "deleted instance passed to update()", null, event.getEntityName() );
        }
        else {
            return entityIsPersistent(event);
        }
    }
    else {
        entityIsDetached(event);
        return null;
    }
}

protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) {
    int entityState = getEntityState(
            event.getEntity(),
            event.getEntityName(),
            event.getEntry(),
            event.getSession()
    );

    switch ( entityState ) {
        case DETACHED:
            entityIsDetached( event );
            return null;
        case PERSISTENT:
            return entityIsPersistent( event );
        default: //TRANSIENT or DELETED
            return entityIsTransient( event );
    }
}

/**
 * The given save-update event named a transient entity.
 * <p/>
 * Here, we will perform the save processing.
 *
 * @param event The save event to be handled.
 *
 * @return The entity's identifier after saving.
 */
protected Serializable entityIsTransient(SaveOrUpdateEvent event) {

    log.trace( "saving transient instance" );

    final EventSource source = event.getSession();

    EntityEntry entityEntry = event.getEntry();
    if ( entityEntry != null ) {
        if ( entityEntry.getStatus() == Status.DELETED ) {
            source.forceFlush( entityEntry );
        }
        else {
            throw new AssertionFailure( "entity was persistent" );
        }
    }

    Serializable id = saveWithGeneratedOrRequestedId( event );

    source.getPersistenceContext().reassociateProxy( event.getObject(), id );

    return id;
}

protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) {
    // this implementation is supposed to tolerate incorrect unsaved-value
    // mappings, for the purpose of backward-compatibility
    EntityEntry entry = event.getSession().getPersistenceContext().getEntry( event.getEntity() );
    if ( entry!=null && entry.getStatus() != Status.DELETED ) {
        return entityIsPersistent(event);
    }
    else {
        return entityIsTransient(event);
    }
}

protected Serializable saveWithGeneratedOrRequestedId(SaveOrUpdateEvent event) {
    if ( event.getRequestedId() == null ) {
        return super.saveWithGeneratedOrRequestedId(event);
    }
    else {
        return saveWithRequestedId( 
                event.getEntity(), 
                event.getRequestedId(), 
                event.getEntityName(), 
                null, 
                event.getSession() 
            );
    }

}

/**
 * Handle the given update event.
 *
 * @param event The update event to be handled.
 */
public void onSaveOrUpdate(SaveOrUpdateEvent event) {
    final SessionImplementor source = event.getSession();
    final Object object = event.getObject();
    final Serializable requestedId = event.getRequestedId();

    if ( requestedId != null ) {
        //assign the requested id to the proxy, *before* 
        //reassociating the proxy
        if ( object instanceof HibernateProxy ) {
            ( ( HibernateProxy ) object ).getHibernateLazyInitializer().setIdentifier( requestedId );
        }
    }

    if ( reassociateIfUninitializedProxy( object, source ) ) {
        log.trace( "reassociated uninitialized proxy" );
        // an uninitialized proxy, noop, don't even need to 
        // return an id, since it is never a save()
    }
    else {
        //initialize properties of the event:
        final Object entity = source.getPersistenceContext().unproxyAndReassociate( object );
        event.setEntity( entity );
        event.setEntry( source.getPersistenceContext().getEntry( entity ) );
        //return the id in the event object
        event.setResultId( performSaveOrUpdate( event ) );
    }

}

protected Serializable entityIsPersistent(SaveOrUpdateEvent event) throws HibernateException {
    log.trace( "ignoring persistent instance" );

    EntityEntry entityEntry = event.getEntry();
    if ( entityEntry == null ) {
        throw new AssertionFailure( "entity was transient or detached" );
    }
    else {

        if ( entityEntry.getStatus() == Status.DELETED ) {
            throw new AssertionFailure( "entity was deleted" );
        }

        final SessionFactoryImplementor factory = event.getSession().getFactory();

        Serializable requestedId = event.getRequestedId();

        Serializable savedId;
        if ( requestedId == null ) {
            savedId = entityEntry.getId();
        }
        else {

            final boolean isEqual = !entityEntry.getPersister().getIdentifierType()
                    .isEqual( requestedId, entityEntry.getId(), event.getSession().getEntityMode(), factory );

            if ( isEqual ) {
                throw new PersistentObjectException(
                        "object passed to save() was already persistent: " +
                                MessageHelper.infoString( entityEntry.getPersister(), requestedId, factory )
                );
            }

            savedId = requestedId;

        }

        if ( log.isTraceEnabled() ) {
            log.trace(
                    "object already associated with session: " +
                            MessageHelper.infoString( entityEntry.getPersister(), savedId, factory )
            );
        }

        return savedId;

    }
}

/**
 * Save the transient instance, assigning the right identifier
 *
 * @param event The initiating event.
 *
 * @return The entity's identifier value after saving.
 */
protected Serializable saveWithGeneratedOrRequestedId(SaveOrUpdateEvent event) {
    return saveWithGeneratedId(
            event.getEntity(),
            event.getEntityName(),
            null,
            event.getSession(),
            true
    );
}

/**
 * Handles the calls needed to perform cascades as part of an update request
 * for the given entity.
 *
 * @param event The event currently being processed.
 * @param persister The defined persister for the entity being updated.
 * @param entity The entity being updated.
 */
private void cascadeOnUpdate(SaveOrUpdateEvent event, EntityPersister persister, Object entity) {
    EventSource source = event.getSession();
    source.getPersistenceContext().incrementCascadeLevel();
    try {
        new Cascade( CascadingAction.SAVE_UPDATE, Cascade.AFTER_UPDATE, source )
                .cascade( persister, entity );
    }
    finally {
        source.getPersistenceContext().decrementCascadeLevel();
    }
}

private void fireSaveOrUpdate(SaveOrUpdateEvent event) {
    errorIfClosed();
    checkTransactionSynchStatus();
    SaveOrUpdateEventListener[] saveOrUpdateEventListener = listeners.getSaveOrUpdateEventListeners();
    for ( int i = 0; i < saveOrUpdateEventListener.length; i++ ) {
        saveOrUpdateEventListener[i].onSaveOrUpdate(event);
    }
}

private Serializable fireSave(SaveOrUpdateEvent event) {
    errorIfClosed();
    checkTransactionSynchStatus();
    SaveOrUpdateEventListener[] saveEventListener = listeners.getSaveEventListeners();
    for ( int i = 0; i < saveEventListener.length; i++ ) {
        saveEventListener[i].onSaveOrUpdate(event);
    }
    return event.getResultId();
}

private void fireUpdate(SaveOrUpdateEvent event) {
    errorIfClosed();
    checkTransactionSynchStatus();
    SaveOrUpdateEventListener[] updateEventListener = listeners.getUpdateEventListeners();
    for ( int i = 0; i < updateEventListener.length; i++ ) {
        updateEventListener[i].onSaveOrUpdate(event);
    }
}

public void onSaveOrUpdate(SaveOrUpdateEvent arg0) throws HibernateException {
    Object obj = arg0.getObject();
    if (obj instanceof Notifierprofiles) {
        postSaveOrUpdateNotifierProfile((Notifierprofiles) obj);
    } else if (obj instanceof Properties) {
        postSaveOrUpdateproperties((Properties) obj);
    }
}

/**
 * The given save-update event named a detached entity.
 * <p/>
 * Here, we will perform the update processing.
 *
 * @param event The update event to be handled.
 */
protected void entityIsDetached(SaveOrUpdateEvent event) {

    log.trace( "updating detached instance" );


    if ( event.getSession().getPersistenceContext().isEntryFor( event.getEntity() ) ) {
        //TODO: assertion only, could be optimized away
        throw new AssertionFailure( "entity was persistent" );
    }

    Object entity = event.getEntity();

    EntityPersister persister = event.getSession().getEntityPersister( event.getEntityName(), entity );

    event.setRequestedId(
            getUpdateId(
                    entity, persister, event.getRequestedId(), event.getSession().getEntityMode()
            )
    );

    performUpdate( event, entity, persister );

}

protected void performUpdate(
        SaveOrUpdateEvent event,
        Object entity,
        EntityPersister persister) throws HibernateException {

    if ( !persister.isMutable() ) {
        log.trace( "immutable instance passed to doUpdate(), locking" );
        reassociate( event, entity, event.getRequestedId(), persister );
    }
    else {

        if ( log.isTraceEnabled() ) {
            log.trace(
                    "updating " +
                            MessageHelper.infoString(
                                    persister, event.getRequestedId(), event.getSession().getFactory()
                            )
            );
        }

        final EventSource source = event.getSession();

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

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

        if ( invokeUpdateLifecycle( entity, persister, source ) ) {
            reassociate( event, event.getObject(), event.getRequestedId(), persister );
            return;
        }

        // this is a transient object with existing persistent state not loaded by the session

        new OnUpdateVisitor( source, event.getRequestedId(), entity ).process( entity, persister );

        //TODO: put this stuff back in to read snapshot from
        //      the second-level cache (needs some extra work)
        /*Object[] cachedState = null;

        if ( persister.hasCache() ) {
            CacheEntry entry = (CacheEntry) persister.getCache()
                    .get( event.getRequestedId(), source.getTimestamp() );
            cachedState = entry==null ? 
                    null : 
                    entry.getState(); //TODO: half-assemble this stuff
        }*/

        source.getPersistenceContext().addEntity(
                entity,
                Status.MANAGED,
                null, //cachedState,
                key,
                persister.getVersion( entity, source.getEntityMode() ),
                LockMode.NONE,
                true,
                persister,
                false,
                true //assume true, since we don't really know, and it doesn't matter
        );

        persister.afterReassociate( entity, source );

        if ( log.isTraceEnabled() ) {
            log.trace(
                    "updating " +
                            MessageHelper.infoString( persister, event.getRequestedId(), source.getFactory() )
            );
        }

        cascadeOnUpdate( event, persister, entity );

    }
}

public void saveOrUpdate(String entityName, Object obj) throws HibernateException {
    fireSaveOrUpdate( new SaveOrUpdateEvent(entityName, obj, this) );
}

public Serializable save(String entityName, Object object) throws HibernateException {
    return fireSave( new SaveOrUpdateEvent(entityName, object, this) );
}

public void save(String entityName, Object object, Serializable id) throws HibernateException {
    fireSave( new SaveOrUpdateEvent(entityName, object, id, this) );
}

public void update(String entityName, Object object) throws HibernateException {
    fireUpdate( new SaveOrUpdateEvent(entityName, object, this) );
}

public void update(String entityName, Object object, Serializable id) throws HibernateException {
    fireUpdate(new SaveOrUpdateEvent(entityName, object, id, this));
}

public void onSaveOrUpdate(SaveOrUpdateEvent event)  throws HibernateException
{
  setVersion(event.getObject());
  super.onSaveOrUpdate(event);
}

@Override
public void onSaveOrUpdate(SaveOrUpdateEvent event) throws HibernateException
{
  apply(event.getEntity());
}