import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
@Test
public void saveAuditLogEntries_hasObserverMethodAfterSuccessAnnotation() {
    // given
    AuditLogEntries auditLogEntries = new AuditLogEntries(
            new ArrayList<AuditLogEntry>());
    List<ObserverMethod> observerMethods = contextManager
            .findObserverMethods(auditLogEntries);
    Method method = observerMethods.get(0).getMethod();

    // when
    Observes observes = (Observes) contextManager.searchAnnotation(method,
            Observes.class);

    // then
    assertEquals(TransactionPhase.AFTER_SUCCESS, observes.during());
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
/**
 * Executes a pipeline, executing each stage in turn until the pipeline completes, fails or halts while waiting for an asynchronous process to complete.
 * <p>
 * Only pipelines that are in their initial state can be executed, if the pipeline is not in it's initial state it is marked as failed.
 * </p>
 *
 * @param pipeline
 *         the pipeline
 */
@Asynchronous
public void executePipeline(@Observes(during = TransactionPhase.AFTER_SUCCESS) Pipeline pipeline) {
    Throwables.voidInstance(() -> OmakaseSecurity.doAsSystem(() -> {
        if (!pipeline.isFirstPipelineStage() && !PipelineStageStatus.QUEUED.equals(pipeline.getStatusOfCurrentStage())) {
            LOGGER.error("Pipeline " + pipeline.getId() + " is not in it's initial state");
            updatePipeline(PipelineStageResult.builder(pipeline.getId(), PipelineStageStatus.FAILED).addMessages(ImmutableSet.of("The pipeline is not in it's initial state")).build());
        }

        // the first stage is executed outside of recursion as, the recursion relies on the the previous stage
        // being complete before executing the next one which is not the case for the first stage.
        PipelineContext pipelineContext = createPipelineContext(pipeline);
        PipelineStageResult pipelineStageResult = pipelineStageExecutor.execute(pipelineContext, pipeline.getCurrentPipelineStage());

        executePipelineFailureStage(pipelineStageResult);

        Pipeline updatedPipeline = updatePipeline(pipelineStageResult);
        // execute subsequent stages until the pipeline is halted or completed.
        executePipelineStages(updatedPipeline);
        return true;
    }));

}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
@Override
public void registerTransactionSynchronization(final TransactionPhase phase, final ObserverMethod<? super Object> observer, final Object event) throws Exception {
    Set<Annotation> qualifiers = observer.getObservedQualifiers();
    if (qualifiers == null) {
        qualifiers = Collections.emptySet();
    }

    TransactionalEventNotifier.registerTransactionSynchronization(phase, observer, event,
        new EventMetadataImpl(observer.getObservedType(), null, null,
            qualifiers.toArray(new Annotation[qualifiers.size()]), webBeansContext));
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
/**
 * Accepts the TalkModificationEvent and sends it to the JMS queue.
 *
 * @param event
 * 		the modification event received after successful transaction phase
 */
@Asynchronous
public void accept(@Observes(during = TransactionPhase.AFTER_SUCCESS) TalkModificationEvent event) {

	try {
		String message = this.createMessage(event);
		this.sendMessage(message);
	} catch (JMSException e) {
		logger.error("Error sending Message to JMS Queue.", e);
	}
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void observeBeforeTransactionCompletion(@Observes(during = TransactionPhase.BEFORE_COMPLETION) @Transaction String message) {
    System.out.println("Message from within transaction received before completion: " + message);
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void observeAfterTransactionCompletion(@Observes(during = TransactionPhase.AFTER_SUCCESS) @Transaction String message) {
    System.out.println("Message from within transaction received after success: " + message);
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void saveAuditLogEntries(
        @Observes(during = TransactionPhase.AFTER_SUCCESS) AuditLogEntries logData) {
    dao.saveAuditLog(logData.getAuditLogEntries());
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void carCreated(@Observes(during = TransactionPhase.AFTER_SUCCESS) Specification spec) {
    createdCars.labels(spec.getColor().name(), spec.getEngine().name()).inc();
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
@Override
public TransactionPhase getTransactionPhase() {
    return TransactionPhase.IN_PROGRESS;
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void onBucketObjectDeleted(@Observes(during = TransactionPhase.AFTER_COMPLETION) BucketDeletedEvent event) {
	addBucket(event.getBucketId());
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void onBucketObjectDeleted(@Observes(during = TransactionPhase.AFTER_COMPLETION) BucketObjectDeletedEvent event) {
	addBucketObject(event.getBucketObjectId());
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void onSuccessfulOrder(@Observes(during = TransactionPhase.AFTER_SUCCESS) Order order) {
	System.out.println("Successful order: " + order);
}
 

import javax.enterprise.event.TransactionPhase; //导入依赖的package包/类
public void onFailedfulOrder(@Observes(during = TransactionPhase.AFTER_FAILURE) Order order) {
	System.out.println("Failed order: " + order);
}