@SuppressWarnings("unchecked")
public void onSaveOrUpdate(SaveOrUpdateEvent event) throws HibernateException {
Object entity = event.getObject();
boolean newEntity = !event.getSession().contains(entity);
if (newEntity) {
if (beforeInsertCaller != null) {
beforeInsertCaller.call(entity);
if (event.getSession().contains(entity)) {
EntityEntry entry = event.getEntry();
if (entry != null) {
Object[] state = entry.getLoadedState();
synchronizePersisterState(entity, entry.getPersister(), state);
}
}
}
if (shouldTimestamp) {
long time = System.currentTimeMillis();
if (dateCreatedProperty != null && newEntity) {
Object now =
DefaultGroovyMethods.newInstance(dateCreatedProperty.getType(), new Object[] {time});
dateCreatedProperty.setProperty(entity, now);
}
if (lastUpdatedProperty != null) {
Object now =
DefaultGroovyMethods.newInstance(lastUpdatedProperty.getType(), new Object[] {time});
lastUpdatedProperty.setProperty(entity, now);
}
}
}
}
/**
* 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;
}
}
/**
* 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();
}
}
/**
* 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 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 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);
}
/**
* 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);
}