/** * 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); } } // For an uninitialized proxy, noop, don't even need to return an id, since it is never a save() if (reassociateIfUninitializedProxy(object, source)) LOG.trace("Reassociated uninitialized proxy"); 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; } }
/** * 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())); performUpdate(event, entity, persister); }
protected void performUpdate(SaveOrUpdateEvent event, Object entity, EntityPersister persister) throws HibernateException { if (!persister.isMutable()) LOG.trace("Immutable instance passed to performUpdate()"); if (LOG.isTraceEnabled()) LOG.trace( "Updating " + MessageHelper.infoString( persister, event.getRequestedId(), event.getSession().getFactory())); final EventSource source = event.getSession(); final EntityKey key = source.generateEntityKey(event.getRequestedId(), persister); 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, (persister.isMutable() ? Status.MANAGED : Status.READ_ONLY), 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); }