Comment définir dynamiquement un taux fixe pour les tâches planifiées au printemps ?

Planification de tâches avec Spring par programmation : comment définir un taux fixe dynamique

Le framework Spring fournit un moyen pratique de planifier des tâches à l'aide de son @Scheduled annotation. Cependant, lorsque le taux d'exécution souhaité doit être ajusté sans redéployer l'application, une approche plus dynamique est requise.

Pour pallier à cela, Spring permet d'utiliser un Trigger plutôt que des annotations. Un Trigger permet de calculer dynamiquement le prochain temps d'exécution.

La mise en œuvre de cette planification dynamique implique quelques étapes clés :

1. Création d'un Trigger : Implémenter une classe qui étend l'interface Trigger et fournit une implémentation pour la méthode nextExecutionTime(). Cette méthode calcule l'heure d'exécution suivante en fonction de la logique requise, comme la récupération d'une valeur par programme.
2. Configuration du planificateur : Utilisez l'interface SchedulingConfigurer dans une classe de configuration Spring pour configurer le planificateur . Cela implique de créer un bean Executor et d'enregistrer une tâche de déclenchement avec votre implémentation de déclencheur personnalisée.
3. Planification de la tâche : Planifiez la tâche à l'aide d'un Runnable qui exécute la tâche souhaitée. La tâche de déclenchement gérera la planification d'exécution en fonction de votre déclencheur personnalisé.

Voici un exemple de la façon dont cette approche peut être implémentée dans le code :

@Configuration
@EnableScheduling
public class MyAppConfig implements SchedulingConfigurer {

    @Autowired
    Environment env;

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }

    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(100);
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(
                new Runnable() {
                    @Override public void run() {
                        myBean().getSchedule();
                    }
                },
                new Trigger() {
                    @Override public Date nextExecutionTime(TriggerContext triggerContext) {
                        Calendar nextExecutionTime =  new GregorianCalendar();
                        Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
                        nextExecutionTime.setTime(lastActualExecutionTime != null ? lastActualExecutionTime : new Date());
                        nextExecutionTime.add(Calendar.MILLISECOND, env.getProperty("myRate", Integer.class)); //you can get the value from wherever you want
                        return nextExecutionTime.getTime();
                    }
                }
        );
    }
}

Avec cette approche, vous bénéficiez de la flexibilité nécessaire pour ajuster le taux de planification de manière dynamique sans avoir à redéployer votre application Spring. Le taux d'exécution déterminé par programme permet des scénarios de planification et des intégrations plus avancés avec des systèmes externes.

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!