Java TransactionSynchronization.STATUS_COMMITTED属性代码示例

private void handleStatus(int status, String type, Serializable... ids) {
    Message<?> callmess;

    if (TransactionSynchronization.STATUS_COMMITTED == status) {
        // TODO make CommitSuccess handle type/ids combo
        callmess = MessageBuilder.withPayload(new CommitSuccessEvent(ids))
                                 .setHeader(Operative.DESTINATION_NAME, "server.queue").build();
    } else {
        CompensateEvent compensateEvent = new CompensateEvent(status);

        compensateEvent.setIds(ids);
        compensateEvent.setType(type);
        callmess = MessageBuilder.withPayload(compensateEvent)
                                 .setHeader(Operative.DESTINATION_NAME, "server.queue").build();
        LOG.debug("Compensating for " + type + ":" + Arrays.toString(ids));
    }

    asyncChannel.send(callmess);
}
 

@Override
public void afterCompletion(int status) {
    if (sessionActive) {
        boolean success = status == TransactionSynchronization.STATUS_COMMITTED;
        // Commit the locks/discard changes on rollback
        try {
            session.afterCompletion(success);
        } finally {
            session.releaseResources();
            StorageSessionHolder.removeSession();
        }
    }
    if (log.isDebugEnabled()) {
        log.debug("Session completed: '{}' in {}",
                sessionName, TimeUnitFormat.getTimeString(System.nanoTime() - startTime));
    }
}
 

@Override
public void afterCompletion(int status) {
    if (TransactionSynchronization.STATUS_COMMITTED == status) {
        startNewThreadDeffered(runner);
    } else if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
        removeRunning(runner.getActivityId());
    } else {
        Assert.fail("Impossible.");
    }
}
 

@Override
public void beforeCommit(boolean readOnly) {
	if (this.status != TransactionSynchronization.STATUS_COMMITTED) {
		fail("Should never be called");
	}
	assertFalse(this.beforeCommitCalled);
	this.beforeCommitCalled = true;
}
 

@Override
public void afterCommit() {
	if (this.status != TransactionSynchronization.STATUS_COMMITTED) {
		fail("Should never be called");
	}
	assertFalse(this.afterCommitCalled);
	this.afterCommitCalled = true;
}
 

@Override
public void afterCompletion(int status) {
    try {
        Collection<Entity> instances = container.getAllInstances();
        if (log.isTraceEnabled())
            log.trace("ContainerResourceSynchronization.afterCompletion: instances = " + instances);
        for (Object instance : instances) {
            if (instance instanceof BaseGenericIdEntity) {
                BaseGenericIdEntity baseGenericIdEntity = (BaseGenericIdEntity) instance;
                BaseEntityInternalAccess.setManaged(baseGenericIdEntity, false);

                if (BaseEntityInternalAccess.isNew(baseGenericIdEntity)) {
                    // new instances become not new and detached only if the transaction was committed
                    if (status == TransactionSynchronization.STATUS_COMMITTED) {
                        BaseEntityInternalAccess.setNew(baseGenericIdEntity, false);
                        BaseEntityInternalAccess.setDetached(baseGenericIdEntity, true);
                    }
                } else {
                    BaseEntityInternalAccess.setDetached(baseGenericIdEntity, true);
                }
            }
            if (instance instanceof FetchGroupTracker) {
                ((FetchGroupTracker) instance)._persistence_setSession(null);
            }
            if (instance instanceof ChangeTracker) {
                ((ChangeTracker) instance)._persistence_setPropertyChangeListener(null);
            }
        }

        for (AfterCompleteTransactionListener listener : afterCompleteTxListeners) {
            listener.afterComplete(status == TransactionSynchronization.STATUS_COMMITTED, instances);
        }
    } finally {
        super.afterCompletion(status);
    }
}
 

@Override
public void afterCompletion(int status) {
    if (TransactionSynchronization.STATUS_COMMITTED == status) {
        consumer.addCommand(command);
    }
}
 

@Override
public void afterCompletion(int status)
{
    String statusStr = "unknown";
    switch (status)
    {
        case TransactionSynchronization.STATUS_COMMITTED:
            statusStr = "committed";
            break;
        case TransactionSynchronization.STATUS_ROLLED_BACK:
            statusStr = "rolled-back";
            break;
        default:
    }
    if (logger.isDebugEnabled())
    {
        logger.debug("After completion (" + statusStr + "): " + this);
    }
    
    // Force any queries for read-write state to return TXN_READ_ONLY
    // This will be cleared with the synchronization, so we don't need to clear it out
    TransactionSupportUtil.bindResource(RESOURCE_KEY_TXN_COMPLETING, Boolean.TRUE);
    
    Set<Integer> priorities = priorityLookup.keySet();

    SortedSet<Integer> sortedPriorities = new ConcurrentSkipListSet<Integer>(REVERSE_INTEGER_ORDER);
    sortedPriorities.addAll(priorities);
 
    // Need to run these in reverse order cache,lucene,listeners
    for(Integer priority : sortedPriorities)
    {
        Set<TransactionListener> listeners = new HashSet<TransactionListener>(priorityLookup.get(priority));

        for(TransactionListener listener : listeners) 
        {
            try
            {
                if (status  == TransactionSynchronization.STATUS_COMMITTED)
                {
                    listener.afterCommit();
                }
                else
                {
                    listener.afterRollback();
                }
            }
            catch (RuntimeException e)
            {
                logger.error("After completion (" + statusStr + ") TransactionalCache exception", e);
            }
        }
    }
    if(logger.isDebugEnabled())
    {
        logger.debug("After Completion: DONE");
    }
    
    
    // clear the thread's registrations and synchronizations
    TransactionSupportUtil.clearSynchronization();
}