/** {@inheritDoc} */
  @Override
  public void beforeProcess() throws Throwable {
    // prepare execution context
    AuthenticationUtil.pushAuthentication();
    AuthenticationUtil.setFullyAuthenticatedUser(this.fullyAuthenticatedUser);
    if (this.runAsUser != null && !this.runAsUser.equals(this.fullyAuthenticatedUser)) {
      AuthenticationUtil.setRunAsUser(this.runAsUser);
    }

    I18NUtil.setLocale(this.locale);
    if (this.contentLocale != null) {
      I18NUtil.setContentLocale(this.contentLocale);
    }

    try {
      try {
        super.doBeforeProcess();
      } catch (final WrappedException ex) {
        // super should already handle unwrap runtime exceptions
        final Throwable wrappedException = ex.getWrappedException();
        if (wrappedException instanceof RuntimeException) {
          // super should have handled this
          throw (RuntimeException) wrappedException;
        }
        throw new AlfrescoRuntimeException(wrappedException.getMessage(), wrappedException);
      } catch (final Throwable ex) {
        throw new AlfrescoRuntimeException(ex.getMessage(), ex);
      }
    } catch (final Throwable ex) {
      /*
       * The TxnCallback does not propagate non-retryable exceptions to the retrying transaction handler. Some exceptions may be
       * caused by execution of the provided script callback without passing through a service with its transaction interceptor which
       * would mark the transaction for rollback. We have to mark the transaction for rollback manually otherwise we end up with
       * commits of partial changes from the batch. (rollback on any exception is the default behaviour of Alfresco
       * SpringAwareUserTransaction)
       */

      final RuleBasedTransactionAttribute transactionAttribute =
          new RuleBasedTransactionAttribute();
      transactionAttribute.setReadOnly(true);
      transactionAttribute.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);

      // this never creates a new "real" transaction due to our propagation behavior
      final TransactionStatus transaction = this.txnManager.getTransaction(transactionAttribute);
      try {
        if (!transaction.isRollbackOnly()) {
          LOGGER.debug(
              "Marking transaction as rollback-only due to exception during batch processing", ex);
          transaction.setRollbackOnly();
        }
      } finally {
        // this never actually commits a "real" transaction - it just clears transaction
        // synchronizations
        this.txnManager.commit(transaction);
      }

      throw ex;
    }
  }
  /** Borrowed from Seam */
  public int getStatus() {
    if (ptm == null) {
      return TransactionManager.STATUS_NO_TRANSACTION;
    }

    // logger.debug( "Current TX name (According to TransactionSynchronizationManager) : " +
    // TransactionSynchronizationManager.getCurrentTransactionName() );
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
      TransactionStatus transaction = null;
      boolean commitNewTransaction = false;
      try {
        if (currentTransaction.size() == 0) {
          transaction = ptm.getTransaction(td);
          currentTransaction.push(transaction);
          commitNewTransaction = true;
          if (transaction.isNewTransaction()) {
            return TransactionManager.STATUS_COMMITTED;
          }
        } else {
          transaction = currentTransaction.peek();
        }
        logger.debug("Current TX: " + transaction);
        // If SynchronizationManager thinks it has an active transaction but
        // our transaction is a new one
        // then we must be in the middle of committing
        if (transaction.isCompleted()) {
          if (transaction.isRollbackOnly()) {
            return TransactionManager.STATUS_ROLLEDBACK;
          }
          return TransactionManager.STATUS_COMMITTED;
        } else {
          if (transaction.isRollbackOnly()) {
            return 5;
          }
          return TransactionManager.STATUS_ACTIVE;
        }
      } finally {
        if (commitNewTransaction) {
          ptm.commit(transaction);
        }
      }
    }
    return TransactionManager.STATUS_NO_TRANSACTION;
  }
コード例 #3
0
  private void stubTransactionStatus() {
    given(txStatus.isRollbackOnly()).willReturn(false);

    PlatformTransactionManager txManager = mock(PlatformTransactionManager.class);
    given(txManager.getTransaction((TransactionDefinition) Mockito.anyObject()))
        .willReturn(txStatus);

    AnnotationTransactionAspect txAspect = AnnotationTransactionAspect.aspectOf();
    txAspect.setTransactionManager(txManager);
  }
コード例 #4
0
 /**
  * Discription:[获取待办请款任务]
  *
  * @return
  * @author 大牙-小白
  * @update 2012-9-8 大牙-小白 [变更描述]
  */
 public String todoTask() {
   Map<String, Object> resultMap = new HashMap<String, Object>();
   // 定义TransactionDefinition并设置好事务的隔离级别和传播方式。
   DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
   // 代价最大、可靠性最高的隔离级别,所有的事务都是按顺序一个接一个地执行
   definition.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
   // 开始事务
   TransactionStatus status = transactionManager.getTransaction(definition);
   PrintWriter out = null;
   try {
     out = super.getPrintWriter();
     if (cashAdvanceInfo == null
         || cashAdvanceInfo.getCashUserId() == null
         || cashAdvanceInfo.getCashUserName() == null
         || "".equals(cashAdvanceInfo.getCashUserId())
         || "".equals(cashAdvanceInfo.getCashUserName())) {
       resultMap.put("success", false);
       resultMap.put("msg", "当前用户信息为空,请检查!");
     } else {
       resultMap =
           this.cashAdvanceService.getTodoRequestCash(
               this.springJTM.getUserTransaction(),
               roleService,
               jbpmService,
               cashAdvanceInfo,
               start,
               limit);
       resultMap.put("success", true);
     }
   } catch (Exception e) {
     LOG.error(e.getMessage());
     status.setRollbackOnly();
     resultMap.put("success", false);
     resultMap.put("msg", "系统错误,错误代码:" + e.getMessage());
   } finally {
     if (status.isRollbackOnly()) {
       this.transactionManager.rollback(status);
     } else {
       this.transactionManager.commit(status);
     }
     //            try {
     //                jbpmService.disconnectJbpmServer();
     //            } catch (Exception e) {
     //                e.printStackTrace();
     //            }
     if (out != null) {
       out.print(getJsonString(resultMap));
       out.flush();
       out.close();
     }
   }
   return null;
 }
コード例 #5
0
 /**
  * Discription:[通过或者驳回请款请求]
  *
  * @return
  * @author 大牙-小白
  * @update 2012-9-15 大牙-小白 [变更描述]
  */
 public String doRequestTask() {
   Map<String, Object> resultMap = new HashMap<String, Object>();
   // 定义TransactionDefinition并设置好事务的隔离级别和传播方式。
   DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
   // 代价最大、可靠性最高的隔离级别,所有的事务都是按顺序一个接一个地执行
   definition.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
   // 开始事务
   TransactionStatus status = transactionManager.getTransaction(definition);
   PrintWriter out = null;
   try {
     out = super.getPrintWriter();
     if (this.taskIds == null
         || "".equals(taskIds)
         || this.loanIds == null
         || "".equals(loanIds)) {
       resultMap.put("success", false);
       resultMap.put("msg", "请选择需要处理的请款请求!");
     } else {
       this.cashAdvanceService.doRequest(
           this.springJTM.getUserTransaction(),
           roleService,
           jbpmService,
           taskIds,
           loanIds,
           currentUserId,
           currentUserName,
           doType,
           checkResult,
           approveResult,
           reason);
     }
   } catch (Exception e) {
     LOG.error(e.getMessage(), e);
     status.setRollbackOnly();
     resultMap.put("success", false);
     resultMap.put("msg", e.getMessage());
   } finally {
     if (status.isRollbackOnly()) {
       this.transactionManager.rollback(status);
     } else {
       this.transactionManager.commit(status);
     }
     if (out != null) {
       out.print(getJsonString(resultMap));
       out.flush();
       out.close();
     }
   }
   return null;
 }
コード例 #6
0
 protected void finalizeTransaction(TransactionStatus status, boolean isError) {
   boolean isActive = false;
   try {
     if (!status.isRollbackOnly()) {
       isActive = true;
     }
   } catch (Exception e) {
     // do nothing
   }
   if (isActive) {
     if (isError) {
       transactionManager.rollback(status);
     } else {
       transactionManager.commit(status);
     }
   }
 }
  /** {@inheritDoc} */
  @Override
  public void process(final Object entry) throws Throwable {
    try {
      try {
        super.doProcess(entry);
      } catch (final WrappedException ex) {
        // super should already handle unwrap runtime exceptions
        final Throwable wrappedException = ex.getWrappedException();
        if (wrappedException instanceof RuntimeException) {
          // super should have handled this
          throw (RuntimeException) wrappedException;
        }
        throw new AlfrescoRuntimeException(wrappedException.getMessage(), wrappedException);
      } catch (final Throwable ex) {
        throw new AlfrescoRuntimeException(ex.getMessage(), ex);
      }
    } catch (final Throwable ex) {
      /*
       * The TxnCallback does not propagate non-retryable exceptions to the retrying transaction handler. Some exceptions may be
       * caused by execution of the provided script callback without passing through a service with its transaction interceptor which
       * would mark the transaction for rollback. We have to mark the transaction for rollback manually otherwise we end up with
       * commits of partial changes from the batch. (rollback on any exception is the default behaviour of Alfresco
       * SpringAwareUserTransaction)
       */

      final RuleBasedTransactionAttribute transactionAttribute =
          new RuleBasedTransactionAttribute();
      transactionAttribute.setReadOnly(true);
      transactionAttribute.setPropagationBehavior(TransactionDefinition.PROPAGATION_MANDATORY);

      final TransactionStatus transaction = this.txnManager.getTransaction(transactionAttribute);
      if (!transaction.isRollbackOnly()) {
        LOGGER.debug(
            "Marking transaction as rollback-only due to exception during batch processing", ex);
        transaction.setRollbackOnly();
      }

      throw ex;
    }
  }