コード例 #1
0
 @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);
       }
     }
   }
 }
コード例 #2
0
  /**
   * 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));
    }
  }
コード例 #3
0
  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;
    }
  }
コード例 #4
0
 /**
  * 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();
   }
 }
コード例 #5
0
  /**
   * 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);
  }
コード例 #6
0
  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);
    }
  }
コード例 #7
0
  /**
   * 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;
  }
コード例 #8
0
  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);
  }
コード例 #9
0
 /**
  * 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);
 }