Comment puis-je conserver la portée des requêtes dans les tâches asynchrones ?

Maintenir la portée de la requête dans les tâches asynchrones

Dans les applications Web, il est courant d'exécuter des tâches asynchrones après avoir reçu une requête. Cependant, garantir que ces tâches ont accès à des objets spécifiques à la requête, tels que ceux annotés avec @Scope(value = WebApplicationContext.SCOPE_REQUEST), peut s'avérer difficile.

Lors du traitement des requêtes de manière non bloquante, le par défaut, SimpleAsyncTaskExecutor n'a pas accès à la portée du thread de requête, ce qui entraîne des exceptions telles que « La portée de la « requête » n'est pas active pour le thread actuel. »

Pour résoudre ce problème, un ContextAwarePoolExecutor personnalisé peut être créé. Cet exécuteur stocke les informations de contexte de demande avec les tâches et exploite un ContextAwareCallable pour définir et effacer le contexte nécessaire pour le fil d'arrière-plan.

Implémentation de l'exécuteur personnalisé :

<code class="java">public class ContextAwarePoolExecutor extends ThreadPoolTaskExecutor {
    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return super.submit(new ContextAwareCallable(task, RequestContextHolder.currentRequestAttributes()));
    }
}</code>

Appelable contextuel :

<code class="java">public class ContextAwareCallable<T> implements Callable<T> {
    private Callable<T> task;
    private RequestAttributes context;

    public ContextAwareCallable(Callable<T> task, RequestAttributes context) {
        this.task = task;
        this.context = context;
    }

    @Override
    public T call() throws Exception {
        if (context != null) {
            RequestContextHolder.setRequestAttributes(context);
        }
        try {
            return task.call();
        } finally {
            RequestContextHolder.resetRequestAttributes();
        }
    }
}</code>

Remplacement de la configuration :

<code class="java">@Configuration
public class ExecutorConfig extends AsyncConfigurerSupport {
    @Override
    @Bean
    public Executor getAsyncExecutor() {
        return new ContextAwarePoolExecutor();
    }
}</code>

En utilisant cet exécuteur personnalisé, les tâches asynchrones peuvent accéder de manière transparente aux requêtes. objets de portée, surmontant les limitations du SimpleAsyncTaskExecutor par défaut.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!