import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preDelete(InstanceLifecycleEvent event) {
    Object instance = event.getSource();
    String className = instance.getClass().getName();

    getLogger().trace("Received pre-delete for: {}", instance);

    // omit events for trash and history instances
    // get the schema version from the data service
    MotechDataService dataService = ServiceUtil.getServiceFromAppContext(getApplicationContext(), className);
    Long schemaVersion = dataService.getSchemaVersion();

    if (getService().isTrashMode()) {
        getLogger().debug("Moving to trash {}, schema version {}", new Object[]{instance, schemaVersion});
        getService().moveToTrash(instance, schemaVersion);
    }
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preDelete(final InstanceLifecycleEvent event) {
	final TempFileChunk tempFileChunk = (TempFileChunk) event.getPersistentInstance();
	final LocalRepoTransaction tx = getTransactionOrFail();
	final FileChunkPayloadDao fileChunkPayloadDao = tx.getDao(FileChunkPayloadDao.class);

	final FileChunkPayload fileChunkPayload = fileChunkPayloadDao.getFileChunkPayload(tempFileChunk);
	if (fileChunkPayload != null) {
		// check, if it's still referenced by a HistoFileChunk!
		final long histoFileChunkCount = tx.getDao(HistoFileChunkDao.class).getHistoFileChunkCount(fileChunkPayload);
		if (histoFileChunkCount == 0)
			fileChunkPayloadDao.deletePersistent(fileChunkPayload);
		else
			fileChunkPayload.setTempFileChunk(null);
	}

	tx.flush();
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preDelete(final InstanceLifecycleEvent event) {
	final FileChunk fileChunk = (FileChunk) event.getPersistentInstance();
	final LocalRepoTransaction tx = getTransactionOrFail();
	final FileChunkPayloadDao fileChunkPayloadDao = tx.getDao(FileChunkPayloadDao.class);

	final FileChunkPayload fileChunkPayload = fileChunkPayloadDao.getFileChunkPayload(fileChunk);
	if (fileChunkPayload != null) {
		// check, if it's still referenced by a HistoFileChunk!
		final long histoFileChunkCount = tx.getDao(HistoFileChunkDao.class).getHistoFileChunkCount(fileChunkPayload);
		if (histoFileChunkCount == 0)
			fileChunkPayloadDao.deletePersistent(fileChunkPayload);
		else
			fileChunkPayload.setFileChunk(null);
	}

	tx.flush();
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
	public void preDelete(final InstanceLifecycleEvent event) {
		final RepoFile repoFile = (RepoFile) event.getPersistentInstance();
		final LocalRepoTransaction tx = getTransactionOrFail();

		if (repoFile instanceof NormalFile) {
			final NormalFile normalFile = (NormalFile) repoFile;
			final TempFileChunkDao tempFileChunkDao = tx.getDao(TempFileChunkDao.class);
			final Collection<TempFileChunk> tempFileChunks = tempFileChunkDao.getTempFileChunks(normalFile);
			tempFileChunkDao.deletePersistentAll(tempFileChunks);

			tx.flush();
		}

		final CryptoRepoFileDao cryptoRepoFileDao = tx.getDao(CryptoRepoFileDao.class);
		final CryptoRepoFile cryptoRepoFile = cryptoRepoFileDao.getCryptoRepoFile(repoFile);
		if (cryptoRepoFile != null) {
//			PreliminaryDeletion preliminaryDeletion = tx.getDao(PreliminaryDeletionDao.class).getPreliminaryDeletion(cryptoRepoFile);
//			if (preliminaryDeletion == null && cryptoRepoFile.getDeleted() == null)
//				throw new IllegalStateException(String.format("%s not marked as deleted!", cryptoRepoFile));
			// The above is a legal state when switching from one type of RepoFile to another (e.g. from NormalFile to Directory).

			cryptoRepoFile.setRepoFile(null); // this must be done, now, because we cannot delete the RepoFile otherwise due to a constraint-violation
		}
	}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postStore(InstanceLifecycleEvent event) {
  xLogger.fine("Lifecycle : create for " +
      ((Persistable) event.getSource()).dnGetObjectId());
  IEvent eventEntity = (IEvent) event.getPersistentInstance();
  xLogger.fine("Entered PostPutCallbacks.notify");
  Boolean isRealTime = eventEntity.isRealTime();
  //Getting estimated time of action for scheduled tasks.
  long etaMillis = -1l;
  Object etaObject = eventEntity.getEtaMillis();
  if (etaObject != null) {
    etaMillis = (Long) etaObject;
  }
  try {
    if (isRealTime) {
      Map<String, String> params = new HashMap<String, String>();
      params.put("action", "notify");
      params.put("eventkey", String.valueOf(eventEntity.getKey()));
      params.put("frequency", String.valueOf(EventSpec.NotifyOptions.IMMEDIATE));
      params.put("method", MessageService.SMS);
      if (etaMillis == -1) {
        etaMillis = System.currentTimeMillis() + 10_000;
      }
      taskService.schedule(ITaskService.QUEUE_MESSAGE, NOTIFIER_URL, params, null,
          ITaskService.METHOD_POST, etaMillis, eventEntity.getDomainId(), null,
          "EVENT_NOTIFICATION");
    }
  } catch (Exception e) {
    xLogger.warn("{0} during PostPut notify for event key {1}: {2}", e.getClass().getName(),
        eventEntity.getKey(), e.getMessage());
  }
  xLogger.fine("Exiting PostPutCallbacks.notify");
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
public void postDirty(javax.jdo.listener.InstanceLifecycleEvent event)
{
    final String message = "Post dirty event for " + event.getSource().getClass().getName();
    //logger.error(message, new Exception(message));
    if (get() == null)
        set(new Boolean(true));
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postStore(InstanceLifecycleEvent event) {
    Object instance = event.getSource();
    getLogger().trace("Post-store event received for {}", instance);

    getLogger().debug("Recording history for {}", instance);
    getService().record(instance);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postStore(final InstanceLifecycleEvent event) {
	final Object persistable = assertNotNull(event.getPersistentInstance(), "event.persistentInstance");
	if (persistable instanceof RepoFile) {
		final RepoFile repoFile = (RepoFile) persistable;
		repoFileName2RepoFile.put(assertNotNull(repoFile.getName(), "repoFile.name"), repoFile);
	}
	else if (persistable instanceof CryptoRepoFile)
		cryptoRepoFilePersisted = true;
	else if (persistable instanceof HistoCryptoRepoFile)
		histoCryptoRepoFilePersisted = true;
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postDelete(InstanceLifecycleEvent event) {
	final Object entity = assertNotNull(event.getPersistentInstance(), "event.persistentInstance");
	final EntityId entityId = getEntityId(entity);
	if (entityId != null)
		enlist(new EntityModification(entityId, EntityModificationType.DELETE));
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postStore(InstanceLifecycleEvent event) {
	final Object entity = assertNotNull(event.getPersistentInstance(), "event.persistentInstance");
	final EntityId entityId = getEntityId(entity);
	if (entityId != null)
		enlist(new EntityModification(entityId, EntityModificationType.CHANGE));
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postCreate(InstanceLifecycleEvent event) {
	final Object entity = assertNotNull(event.getPersistentInstance(), "event.persistentInstance");
	final EntityId entityId = getEntityId(entity);
	if (entityId != null)
		enlist(new EntityModification(entityId, EntityModificationType.CREATE));
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preStore(final InstanceLifecycleEvent event) {
	// It seems, this method is always invoked whenever something is about to be written
	// into the database - no matter, if it's a new object being persisted, a detached
	// object being attached or a persistent object having been modified and being flushed.
	// Therefore, we do not need AttachLifecycleListener and DirtyLifecycleListener.
	// Marco :-)
	onWrite(event.getPersistentInstance());
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preDelete(final InstanceLifecycleEvent event) {
	// We want to ensure that the revision is incremented, even if we do not have any remote repository connected
	// (and thus no DeleteModification being created).
	getTransactionOrFail().getLocalRevision();

	final Object oid = JDOHelper.getObjectId(event.getPersistentInstance());
	oid2LastChanged.remove(oid);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preStore(InstanceLifecycleEvent event) {
  // TODO Auto-generated method stub

}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
public void preDirty(InstanceLifecycleEvent arg0)
{
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postCreate(InstanceLifecycleEvent event) {
    invokeMethods(event.getPersistentInstance(), InstanceLifecycleListenerType.POST_CREATE);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preStore(InstanceLifecycleEvent event) {
    invokeMethods(event.getPersistentInstance(), InstanceLifecycleListenerType.PRE_STORE);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postStore(InstanceLifecycleEvent event) {
    invokeMethods(event.getPersistentInstance(), InstanceLifecycleListenerType.POST_STORE);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void preDelete(InstanceLifecycleEvent event) {
    invokeMethods(event.getPersistentInstance(), InstanceLifecycleListenerType.PRE_DELETE);
}
 

import javax.jdo.listener.InstanceLifecycleEvent; //导入依赖的package包/类
@Override
public void postDelete(InstanceLifecycleEvent event) {
    invokeMethods(event.getPersistentInstance(), InstanceLifecycleListenerType.POST_DELETE);
}