Java DbEntityOperation类代码示例

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
protected void insertEntity(DbEntityOperation operation) {

  final DbEntity dbEntity = operation.getEntity();

  // get statement
  String insertStatement = dbSqlSessionFactory.getInsertStatement(dbEntity);
  insertStatement = dbSqlSessionFactory.mapStatement(insertStatement);
  ensureNotNull("no insert statement for " + dbEntity.getClass() + " in the ibatis mapping files", "insertStatement", insertStatement);

  // execute the insert
  executeInsertEntity(insertStatement, dbEntity);

  // perform post insert actions on entity
  entityInserted(dbEntity);
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
protected void deleteEntity(DbEntityOperation operation) {

  final DbEntity dbEntity = operation.getEntity();

  // get statement
  String deleteStatement = dbSqlSessionFactory.getDeleteStatement(dbEntity.getClass());
  ensureNotNull("no delete statement for " + dbEntity.getClass() + " in the ibatis mapping files", "deleteStatement", deleteStatement);

  LOG.executeDatabaseOperation("DELETE", dbEntity);

  // execute the delete
  int nrOfRowsDeleted = executeDelete(deleteStatement, dbEntity);

  // It only makes sense to check for optimistic locking exceptions for objects that actually have a revision
  if (dbEntity instanceof HasDbRevision && nrOfRowsDeleted == 0) {
    operation.setFailed(true);
    return;
  }

  // perform post delete action
  entityDeleted(dbEntity);
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
public void executeDbOperation(DbOperation operation) {
  switch(operation.getOperationType()) {

    case INSERT:
      insertEntity((DbEntityOperation) operation);
      break;

    case DELETE:
      deleteEntity((DbEntityOperation) operation);
      break;
    case DELETE_BULK:
      deleteBulk((DbBulkOperation) operation);
      break;

    case UPDATE:
      updateEntity((DbEntityOperation) operation);
      break;
    case UPDATE_BULK:
      updateBulk((DbBulkOperation) operation);
      break;

  }
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
public void execute(DelegateExecution execution) throws Exception {
  String existingId = execution.getId();

  // insert an execution referencing the current execution

  ExecutionEntity newExecution = new ExecutionEntity();
  newExecution.setId("someId");
  newExecution.setParentId(existingId);

  DbEntityOperation insertOperation = new DbEntityOperation();
  insertOperation.setOperationType(DbOperationType.INSERT);
  insertOperation.setEntity(newExecution);

  Context.getCommandContext()
    .getDbSqlSession()
    .executeDbOperation(insertOperation);

}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void insertEntity(DbEntityOperation operation) {
  LOG.log(Level.FINE, "insertEntity, operation: "+operation.toString());
  EntityOperationHandler entityOperations = operations.get(operation.getEntityType());
  if(entityOperations == null) {
    LOG.log(Level.WARNING, "unhandled INSERT '"+operation+"'");
  }
  else {
    entityOperations.insert(this, operation.getEntity());
  }

}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void deleteEntity(DbEntityOperation operation) {
  LOG.log(Level.FINE, "deleteEntity, operation: "+operation.toString());
  EntityOperationHandler entityOperations = operations.get(operation.getEntityType());
  if(entityOperations == null) {
    LOG.log(Level.WARNING, "unhandled DELETE '"+operation+"'");
  }
  else {
    entityOperations.delete(this, operation.getEntity());
  }
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void updateEntity(DbEntityOperation operation) {
  LOG.log(Level.FINE, "updateEntity, operation: "+operation.toString());
  EntityOperationHandler entityOperations = operations.get(operation.getEntityType());
  if(entityOperations == null) {
    LOG.log(Level.WARNING, "unhandled UPDATE '"+operation+"'");
  }
  else {
    entityOperations.update(this, operation.getEntity());
  }
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
public int compare(DbEntityOperation firstOperation, DbEntityOperation secondOperation) {

    if(firstOperation.equals(secondOperation)) {
      return 0;
    }

    DbEntity firstEntity = firstOperation.getEntity();
    DbEntity secondEntity = secondOperation.getEntity();

    return firstEntity.getId().compareTo(secondEntity.getId());
  }
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
protected void checkFlushResults(List<DbOperation> operationsToFlush, List<BatchResult> flushResult) {
  int flushResultSize = 0;

  if (flushResult != null && flushResult.size() > 0) {
    LOG.printBatchResults(flushResult);
    //process the batch results to handle Optimistic Lock Exceptions
    Iterator<DbOperation> operationIt = operationsToFlush.iterator();
    for (BatchResult batchResult : flushResult) {
      for (int statementResult : batchResult.getUpdateCounts()) {
        flushResultSize++;
        DbOperation thisOperation = operationIt.next();
        if (thisOperation instanceof DbEntityOperation && ((DbEntityOperation) thisOperation).getEntity() instanceof HasDbRevision
          && !thisOperation.getOperationType().equals(DbOperationType.INSERT)) {
          final DbEntity dbEntity = ((DbEntityOperation) thisOperation).getEntity();
          if (statementResult != 1) {
            ((DbEntityOperation) thisOperation).setFailed(true);
            handleOptimisticLockingException(thisOperation);
          } else {
            //update revision number in cache
            if (thisOperation.getOperationType().equals(DbOperationType.UPDATE)) {
              HasDbRevision versionedObject = (HasDbRevision) dbEntity;
              versionedObject.setRevision(versionedObject.getRevisionNext());
            }
          }
        }
      }
    }
    //this must not happen, but worth checking
    if (operationsToFlush.size() != flushResultSize) {
      LOG.wrongBatchResultsSizeException(operationsToFlush);
    }
  }
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
protected void performEntityOperation(CachedDbEntity cachedDbEntity, DbOperationType type) {
  DbEntityOperation dbOperation = new DbEntityOperation();
  dbOperation.setEntity(cachedDbEntity.getEntity());
  dbOperation.setFlushRelevantEntityReferences(cachedDbEntity.getFlushRelevantEntityReferences());
  dbOperation.setOperationType(type);
  dbOperationManager.addOperation(dbOperation);
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
@Override
protected void updateEntity(DbEntityOperation operation) {

  final DbEntity dbEntity = operation.getEntity();

  String updateStatement = dbSqlSessionFactory.getUpdateStatement(dbEntity);
  ensureNotNull("no update statement for " + dbEntity.getClass() + " in the ibatis mapping files", "updateStatement", updateStatement);

  LOG.executeDatabaseOperation("UPDATE", dbEntity);

  if (Context.getProcessEngineConfiguration().isJdbcBatchProcessing()) {
    // execute update
    executeUpdate(updateStatement, dbEntity);
  } else {
    // execute update
    int numOfRowsUpdated = executeUpdate(updateStatement, dbEntity);

    if (dbEntity instanceof HasDbRevision) {
      if (numOfRowsUpdated != 1) {
        // failed with optimistic locking
        operation.setFailed(true);
        return;
      } else {
        // increment revision of our copy
        HasDbRevision versionedObject = (HasDbRevision) dbEntity;
        versionedObject.setRevision(versionedObject.getRevisionNext());
      }
    }
  }

  // perform post update action
  entityUpdated(dbEntity);
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
protected void filterOnOptimisticLockingFailure(CommandContext commandContext, final List<LockedExternalTask> tasks) {
  commandContext.getDbEntityManager().registerOptimisticLockingListener(new OptimisticLockingListener() {

    public Class<? extends DbEntity> getEntityType() {
      return ExternalTaskEntity.class;
    }

    public void failedOperation(DbOperation operation) {
      if (operation instanceof DbEntityOperation) {
        DbEntityOperation dbEntityOperation = (DbEntityOperation) operation;
        DbEntity dbEntity = dbEntityOperation.getEntity();

        boolean failedOperationEntityInList = false;

        Iterator<LockedExternalTask> it = tasks.iterator();
        while (it.hasNext()) {
          LockedExternalTask resultTask = it.next();
          if (resultTask.getId().equals(dbEntity.getId())) {
            it.remove();
            failedOperationEntityInList = true;
            break;
          }
        }

        if (!failedOperationEntityInList) {
          throw LOG.concurrentUpdateDbEntityException(operation);
        }
      }
    }
  });
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
public void failedOperation(DbOperation operation) {
  if (operation instanceof DbEntityOperation) {

    DbEntityOperation entityOperation = (DbEntityOperation) operation;
    if(JobEntity.class.isAssignableFrom(entityOperation.getEntityType())) {
      // could not lock the job -> remove it from list of acquired jobs
      acquiredJobs.removeJobId(entityOperation.getEntity().getId());
    }

  }
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
protected int indexOfEntity(DbEntity entity, List<DbOperation> operations) {
  for (int i = 0; i < operations.size(); i++) {
    if(entity == ((DbEntityOperation) operations.get(i)).getEntity()) {
      return i;
    }
  }
  return -1;
}
 

import org.camunda.bpm.engine.impl.db.entitymanager.operation.DbEntityOperation; //导入依赖的package包/类
protected abstract void insertEntity(DbEntityOperation operation);