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 );
}

The given save-update event named a detached entity.

Here, we will perform the update processing.

 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;
		}
}

 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;
}

The given save-update event named a transient entity.

Here, we will perform the save processing.

 protected CascadingAction getCascadeAction() 
{
		return CascadingAction.SAVE_UPDATE;
}

 protected Serializable getUpdateId(Object entity,
    EntityPersister persister,
    Serializable requestedId,
    EntityMode entityMode) 
{
		// use the id assigned to the instance
		Serializable id = persister.getIdentifier( entity, entityMode );
		if ( id == null ) {
			// assume this is a newly instantiated transient object
			// which should be saved rather than updated
			throw new TransientObjectException(
					"The given object has a null identifier: " +
							persister.getEntityName()
			);
		}
		else {
			return id;
		}
}

Determine the id to use for updating.

 protected boolean invokeUpdateLifecycle(Object entity,
    EntityPersister persister,
    EventSource source) 
{
		if ( persister.implementsLifecycle( source.getEntityMode() ) ) {
			log.debug( "calling onUpdate()" );
			if ( ( ( Lifecycle ) entity ).onUpdate( source ) ) {
				log.debug( "update vetoed by onUpdate()" );
				return true;
			}
		}
		return false;
}

 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 ) );
		}
}

Handle the given update event.

 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 );
		}
}

 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 );
		}
}

 protected boolean reassociateIfUninitializedProxy(Object object,
    SessionImplementor source) 
{
		return source.getPersistenceContext().reassociateIfUninitializedProxy( object );
}

 protected Serializable saveWithGeneratedOrRequestedId(SaveOrUpdateEvent event) 
{
		return saveWithGeneratedId(
				event.getEntity(),
				event.getEntityName(),
				null,
				event.getSession(),
				true
		);
}

Save the transient instance, assigning the right identifier