org.springframework.transaction.event.TransactionalEventListener Java Examples

@TransactionalEventListener(fallbackExecution = true)
@Transactional
public void beforeLayerConfigurationChanged(LayerConfigurationChangedEvent aEvent)
{
    log.trace("Starting beforeLayerConfigurationChanged");

    Project project = aEvent.getProject();

    Index index = indexByProject.get(project.getId());

    // If the index is null, then indexing is not supported.
    if (index == null) {
        return;
    }

    synchronized (index) {
        index.setInvalid(true);
        entityManager.merge(index);
    }

    // Schedule re-indexing of the physical index
    indexScheduler.enqueueReindexTask(aEvent.getProject());
}
 

@TransactionalEventListener
@Async
public void deleteFile( FileDeletedEvent deleteFileEvent )
{
    if ( !fileResourceContentStore.fileResourceContentExists( deleteFileEvent.getStorageKey() ) )
    {
        log.error( String.format( "No file exist for key: %s", deleteFileEvent.getStorageKey() ) );
        return;
    }

    if ( FileResource.IMAGE_CONTENT_TYPES.contains( deleteFileEvent.getContentType() ) && FileResourceDomain.getDomainForMultipleImages().contains( deleteFileEvent.getDomain() ) )
    {
        String storageKey = deleteFileEvent.getStorageKey();

        Stream.of( ImageFileDimension.values() ).forEach(d -> fileResourceContentStore.deleteFileResourceContent( StringUtils.join( storageKey, d.getDimension() ) ) );
    }
    else
    {
        fileResourceContentStore.deleteFileResourceContent( deleteFileEvent.getStorageKey() );
    }
}
 

@TransactionalEventListener(fallbackExecution = true)
@Transactional
public void afterAnnotationUpdate(AfterCasWrittenEvent aEvent)
{
    log.trace("Starting afterAnnotationUpdate");

    // Schedule new document index process
    indexScheduler.enqueueIndexDocument(aEvent.getDocument(), aEvent.getCas());
}
 

@TransactionalEventListener
public void after(final AnyDeletedEvent event) throws IOException {
    LOG.debug("About to delete index for {}[{}]", event.getAnyTypeKind(), event.getAnyKey());

    DeleteRequest request = new DeleteRequest(
            ElasticsearchUtils.getContextDomainName(AuthContextUtils.getDomain(), event.getAnyTypeKind()),
            event.getAnyKey());
    DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
    LOG.debug("Index successfully deleted for {}[{}]: {}",
            event.getAnyTypeKind(), event.getAnyKey(), response);
}
 

@TransactionalEventListener(fallbackExecution = true)
@Transactional
public void beforeLayerConfigurationChanged(LayerConfigurationChangedEvent aEvent)
{
    // Tell the known CAS holders for the given project that their type system is outdated
    // so they can be refreshed when next returned or borrowed
    exclusiveAccessHolders.stream()
            .filter(h -> Objects.equals(h.getKey().getProjectId(), aEvent.getProject().getId()))
            .forEach(h -> h.setTypeSystemOutdated(true));
    
    // Drop all cached CASes from the updated project from the cache so the CASes get loaded
    // with an updated type system on next access
    sharedAccessCache.asMap().keySet()
            .removeIf(key -> Objects.equals(key.getProjectId(), aEvent.getProject().getId()));
}
 

@TransactionalEventListener(phase=TransactionPhase.BEFORE_COMMIT)
public void beforeCommit(SendMessageEvent event) {
	if (event.isBatchMode()) {
		this.getSendMessageRepository().batchSave(event.getSendMessageContexts());
		CURRENT_MESSAGES.remove();
	}
}
 

@TransactionalEventListener
@Async
public void saveImageFile( ImageFileSavedEvent imageFileSavedEvent )
{
    DateTime startTime = DateTime.now();

    Map<ImageFileDimension, File> imageFiles = imageFileSavedEvent.getImageFiles();

    FileResource fileResource = fileResourceService.getFileResource( imageFileSavedEvent.getFileResource() );

    String storageId = fileResourceContentStore.saveFileResourceContent( fileResource, imageFiles );

    if ( storageId != null )
    {
        fileResource.setHasMultipleStorageFiles( true );

        fileResourceService.updateFileResource( fileResource );
    }

    Period timeDiff = new Period( startTime, DateTime.now() );

    logMessage( storageId, fileResource, timeDiff );
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
void beforeCommit(EntityChangedEvent<EceTestProduct, UUID> event) {
    if (event.getType() == EntityChangedEvent.Type.DELETED)
        return;

    EceTestProduct product = tdm.load(event.getEntityId()).one();
    if (product.getName() == null) {
        product.setName("default name");
    }
    tdm.save(product);

    if (doLog) {
        EceTestLogEntry logEntry = dm.create(EceTestLogEntry.class);
        logEntry.setMessage("Saving product: " + product);
        dm.commit(logEntry);
    }

    EceTestStock stock;
    Optional<EceTestStock> optStock = tdm.load(EceTestStock.class)
            .query("select e from test_EceTestStock e where e.product = :product")
            .parameter("product", product)
            .optional();
    if (!optStock.isPresent()) {
        stock = tdm.create(EceTestStock.class);
        stock.setProduct(product);
    } else {
        stock = optStock.get();
    }
    stock.setQuantity(stock.getQuantity() + 1);
    tdm.save(stock);
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void onOrderChanged(EntityChangedEvent<Order, UUID> event) {
    if (!enabled)
        return;

    switch (event.getType()) {
        case DELETED: return;
        case CREATED:
        case UPDATED: {
            Order order = tdm.load(event.getEntityId())
                    .view(View.LOCAL)
                    .one();
            order.setNumber(order.getNumber() + "changed");
            tdm.save(order);
        }
    }

}
 

@TransactionalEventListener(condition = "!#event.all")
@Caching(
        evict = {
                @CacheEvict(value = CacheConstants.USER_AUTH_CACHE_NAME, key = "#event.getUserId()"),
                @CacheEvict(value = CacheConstants.USER_MENU_CACHE_NAME, key = "'user-menu-list:'+#event.getUserId()"),
                @CacheEvict(value = CacheConstants.USER_MENU_CACHE_NAME, key = "'menu-tree:'+#event.getUserId()")
        }
)
public void clearUserCache(ClearUserAuthorizationCacheEvent event) {
    logger.debug("clear user:{} authorization cache", event.getUserId());
}
 

@TransactionalEventListener(condition = "#event.all")
@Caching(evict = {
        @CacheEvict(cacheNames = USER_MENU_CACHE_NAME, allEntries = true),
        @CacheEvict(cacheNames = USER_AUTH_CACHE_NAME, allEntries = true)
})
public void clearAllUserCache(ClearUserAuthorizationCacheEvent event) {
    logger.debug("clear all user authorization cache");
}
 

@TransactionalEventListener(fallbackExecution = true)
@Transactional
public void afterDocumentCreate(AfterDocumentCreatedEvent aEvent)
{
    log.trace("Starting afterDocumentCreate");

    // Schedule new document index process
    indexScheduler.enqueueIndexDocument(aEvent.getDocument(), aEvent.getCas());

}
 

@Async
@TransactionalEventListener
void on(OrderCompleted event) {

	log.info("Sending email for order {}.", event.getOrder());

	try {
		Thread.sleep(1000);
	} catch (InterruptedException o_O) {}

	log.info("Successfully sent email for order {}.", event.getOrder());
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void onDocumentStateChangeEvent(DocumentStateChangedEvent aEvent)
{
    projectService.recalculateProjectState(aEvent.getDocument().getProject());
}
 

@TransactionalEventListener
public void on(DomainEvent event) {
	throw new IllegalStateException();
}
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(HistoryEvent event) {
  transactionHistoryEvents.push(event);
}
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(DelegateExecution event) {
  transactionExecutionEvents.push(new ExecutionEvent(event));
}
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(DelegateTask event) {
  transactionTaskEvents.push(new TaskEvent(event));
}
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(ExecutionEvent event) {
  transactionImmutableExecutionEvents.push(event);
}
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(TaskEvent event) {
  transactionImmutableTaskEvents.push(event);
}
 

@TransactionalEventListener(condition = "#event.name eq 'reflectoring'", phase = TransactionPhase.AFTER_COMPLETION)
void handleAfterUserRemoved(UserRemovedEvent event) {
	System.out.println(String.format("User removed (@TransactionalEventListener): %s", event.getName()));
}
 

@TransactionalEventListener(phase=TransactionPhase.AFTER_COMMIT)
void afterCommit(SendMessageEvent event);
 

@TransactionalEventListener(phase=TransactionPhase.AFTER_ROLLBACK)
void afterRollback(SendMessageEvent event);
 

@TransactionalEventListener(fallbackExecution = true)
@Async
public void onApplicationEvent(ApplicationEvent aEvent)
{
    String topic = EVENT_TOPICS.get(aEvent.getClass());
    if (topic == null) {
        return;
    }
    
    Object message;
    switch (topic) {
    case PROJECT_STATE:
        message = new ProjectStateChangeMessage((ProjectStateChangedEvent) aEvent);
        break;
    case DOCUMENT_STATE:
        message = new DocumentStateChangeMessage((DocumentStateChangedEvent) aEvent);
        break;
    case ANNOTATION_STATE:
        message = new AnnotationStateChangeMessage((AnnotationStateChangeEvent) aEvent);
        break;
    default:
        return;
    }
    
    for (Webhook hook : configuration.getGlobalHooks()) {
        if (!hook.isEnabled() || !hook.getTopics().contains(topic)) {
            continue;
        }

        try {
            // Configure rest template without SSL certification check if that is disabled.
            RestTemplate restTemplate;
            if (hook.isVerifyCertificates()) {
                restTemplate = restTemplateBuilder.build();
            }
            else {
                restTemplate = restTemplateBuilder
                        .requestFactory(this::getNonValidatingRequestFactory).build();
            }
            
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
            requestHeaders.set(X_AERO_NOTIFICATION, topic);
            
            // If a secret is set, then add a digest header that allows the client to verify
            // the message integrity
            String json = JSONUtil.toJsonString(message);
            if (isNotBlank(hook.getSecret())) {
                String digest = DigestUtils.shaHex(hook.getSecret() + json);
                requestHeaders.set(X_AERO_SIGNATURE, digest);
            }

            HttpEntity<?> httpEntity = new HttpEntity<Object>(json, requestHeaders);
            restTemplate.postForEntity(hook.getUrl(), httpEntity, Void.class);
        }
        catch (Exception e) {
            log.error("Unable to invoke webhook [{}]", hook, e);
        }
    }
}
 

@TransactionalEventListener
public void onScheduledEvent( StageScheduledEvaluationEvent event )
{
    programRuleEngineService.evaluateEventAndRunEffects( event.getProgramStageInstance() );
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void onAfterDocumentCreatedEvent(AfterDocumentCreatedEvent aEvent)
{
    projectService.recalculateProjectState(aEvent.getDocument().getProject());
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void onBeforeDocumentRemovedEvent(BeforeDocumentRemovedEvent aEvent)
{
    projectService.recalculateProjectState(aEvent.getDocument().getProject());
}
 

@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void handleCustom(final CustomSpringEvent event) {
    System.out.println("Handling event inside a transaction BEFORE COMMIT.");
    hitCustomEventHandler = true;
}
 

@TransactionalEventListener
void handleEvent(DomainEvent event);
 

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT, fallbackExecution = true)
public void onTransactionalEvent(HistoryEvent event) {
  transactionHistoryEvents.push(event);
}