public TransactionSynchronizationFactoryBean afterCommit(String expression) { return afterCommit(expression, this.afterCommitChannel); }
DefaultTransactionalResourceSynchronization(Object resourceKey) { super(new IntegrationResourceHolder(), resourceKey); }
@Override public void processAfterCommit(IntegrationResourceHolder holder) { doProcess(holder, this.afterCommitExpression, this.afterCommitChannel, "afterCommit"); }
@Bean public TransactionInterceptor interceptor1(PlatformTransactionManager transactionManager) { return new TransactionInterceptorBuilder() .propagation(Propagation.REQUIRES_NEW) .isolation(Isolation.SERIALIZABLE) .timeout(42) .readOnly(true) .transactionManager(transactionManager) .build(); }
/** * Specify a {@link TransactionInterceptor} {@link Advice} with the * provided {@code PlatformTransactionManager} and default * {@link org.springframework.transaction.interceptor.DefaultTransactionAttribute} * for the {@code pollingTask}. * @param transactionManager the {@link PlatformTransactionManager} to use. * @return the spec. */ public PollerSpec transactional(PlatformTransactionManager transactionManager) { return transactional(new TransactionInterceptorBuilder() .transactionManager(transactionManager) .build()); }
@Bean public TransactionInterceptor transactionInterceptor() { return new TransactionInterceptorBuilder(true) .build(); }
@Override public TransactionSynchronization create(Object key) { Assert.notNull(key, "'key' must not be null"); return new IntegrationResourceHolderSynchronization(new IntegrationResourceHolder(), key); }
@Override public void afterCompletion(int status) { if (status != TransactionSynchronization.STATUS_COMMITTED) { if (DefaultTransactionSynchronizationFactory.this.logger.isTraceEnabled()) { DefaultTransactionSynchronizationFactory.this.logger.trace("'Rolling back' transactional resource"); } DefaultTransactionSynchronizationFactory.this.processor.processAfterRollback(resourceHolder); } super.afterCompletion(status); }
public TransactionInterceptorBuilder(boolean handleMessageAdvice) { if (handleMessageAdvice) { this.transactionInterceptor = new TransactionHandleMessageAdvice(); } else { this.transactionInterceptor = new TransactionInterceptor(); } transactionAttribute(this.transactionAttribute); }
public TransactionSynchronizationFactoryBean beforeCommit(String expression) { return beforeCommit(expression, this.beforeCommitChannel); }
public TransactionSynchronizationFactoryBean afterRollback(MessageChannel messageChannel) { return afterRollback(this.afterRollbackExpression, messageChannel); }
@Override public TransactionSynchronization create(Object key) { Assert.notNull(key, "'key' must not be null"); return new DefaultTransactionalResourceSynchronization(key); }
@Override public void beforeCommit(boolean readOnly) { if (DefaultTransactionSynchronizationFactory.this.logger.isTraceEnabled()) { DefaultTransactionSynchronizationFactory.this.logger.trace("'pre-Committing' transactional resource"); } DefaultTransactionSynchronizationFactory.this.processor.processBeforeCommit(resourceHolder); }
@Override protected void processResourceAfterCommit(IntegrationResourceHolder resourceHolder) { if (DefaultTransactionSynchronizationFactory.this.logger.isTraceEnabled()) { DefaultTransactionSynchronizationFactory.this.logger.trace("'Committing' transactional resource"); } DefaultTransactionSynchronizationFactory.this.processor.processAfterCommit(resourceHolder); }
@Override protected void onInit() { super.onInit(); if (this.evaluationContext == null) { this.evaluationContext = createEvaluationContext(); } }
public TransactionSynchronizationFactoryBean afterCommit(MessageChannel messageChannel) { return afterCommit(this.afterCommitExpression, messageChannel); }
public TransactionSynchronizationFactoryBean beforeCommit(MessageChannel messageChannel) { return beforeCommit(this.beforeCommitExpression, messageChannel); }
@Override public void processBeforeCommit(IntegrationResourceHolder holder) { doProcess(holder, this.beforeCommitExpression, this.beforeCommitChannel, "beforeCommit"); }
public TransactionSynchronizationFactoryBean afterRollback(String expression) { return afterRollback(expression, this.afterRollbackChannel); }
@Override public void processAfterRollback(IntegrationResourceHolder holder) { doProcess(holder, this.afterRollbackExpression, this.afterRollbackChannel, "afterRollback"); }