Comment exécuter une tâche en arrière-plan dans une application Web basée sur un servlet?

J'utilise Java et je souhaite maintenir un servlet en cours d'exécution dans mon application, mais je ne sais pas comment le faire. Mon servlet a une méthode qui donne le nombre d'utilisateurs à partir d'une base de données sur une base quotidienne ainsi que le nombre total d'utilisateurs de toute la base de données. Je veux donc que le servlet continue de fonctionner pour cela.

Votre problème est que vous ne comprenez pas le but du servlet . Il est destiné à agir sur les requêtes HTTP, rien de plus. Vous voulez juste une tâche d'arrière-plan qui s'exécute une fois par jour.

EJB disponible? Utilisation@Schedule

Si votre environnement prend en charge EJB (c'est-à-dire un vrai serveur Java EE tel que WildFly, JBoss, TomEE, Payara, GlassFish, etc.), utilisez à la @Scheduleplace. Voici quelques exemples:

@Singleton
public class BackgroundJobManager {

    @Schedule(hour="0", minute="0", second="0", persistent=false)
    public void someDailyJob() {
        // Do your job here which should run every start of day.
    }

    @Schedule(hour="*/1", minute="0", second="0", persistent=false)
    public void someHourlyJob() {
        // Do your job here which should run every hour of day.
    }

    @Schedule(hour="*", minute="*/15", second="0", persistent=false)
    public void someQuarterlyJob() {
        // Do your job here which should run every 15 minute of hour.
    }

    @Schedule(hour="*", minute="*", second="*/5", persistent=false)
    public void someFiveSecondelyJob() {
        // Do your job here which should run every 5 seconds.
    }

} 

Oui, c'est vraiment tout. Le conteneur le récupérera et le gérera automatiquement.

EJB indisponible? UtilisationScheduledExecutorService

Si votre environnement ne prend pas en charge EJB (c'est-à-dire que vous n'utilisez pas un vrai serveur Java EE, mais un conteneur de servlet simple tel que Tomcat, Jetty, etc.), utilisez ScheduledExecutorService. Cela peut être initié par un ServletContextListener. Voici un exemple de lancement:

@WebListener
public class BackgroundJobManager implements ServletContextListener {

    private ScheduledExecutorService scheduler;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(new SomeDailyJob(), 0, 1, TimeUnit.DAYS);
        scheduler.scheduleAtFixedRate(new SomeHourlyJob(), 0, 1, TimeUnit.HOURS);
        scheduler.scheduleAtFixedRate(new SomeQuarterlyJob(), 0, 15, TimeUnit.MINUTES);
        scheduler.scheduleAtFixedRate(new SomeFiveSecondelyJob(), 0, 5, TimeUnit.SECONDS);
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        scheduler.shutdownNow();
    }

}

Où les classes d'emplois ressemblent à ceci:

public class SomeDailyJob implements Runnable {

    @Override
    public void run() {
        // Do your daily job here.
    }

}

public class SomeHourlyJob implements Runnable {

    @Override
    public void run() {
        // Do your hourly job here.
    }

}

public class SomeQuarterlyJob implements Runnable {

    @Override
    public void run() {
        // Do your quarterly job here.
    }

}

public class SomeFiveSecondelyJob implements Runnable {

    @Override
    public void run() {
        // Do your quarterly job here.
    }

}

Ne pensez jamais à utiliser java.util.Timer/ java.lang.Threaddans un environnement basé sur Java EE / Servlet

Last but not least, n'utilisez jamais directement java.util.Timeret / ou java.lang.Threaddans Java EE. C'est la recette des ennuis. Une explication détaillée peut être trouvée dans cette réponse relative à JSF sur la même question: Générer des threads dans un bean géré JSF pour les tâches planifiées à l'aide d'un minuteur .

Je suggérerais d'utiliser une bibliothèque comme le quartz afin d'exécuter la tâche à intervalles réguliers. Que fait vraiment la servlet? Il vous envoie un rapport?

Mettre en œuvre deux classes et appeler startTask()à main.

public void startTask()
{
    // Create a Runnable
    Runnable task = new Runnable() {
        public void run() {
            while (true) {
                runTask();
            }
        }
    };

    // Run the task in a background thread
    Thread backgroundThread = new Thread(task);
    // Terminate the running thread if the application exits
    backgroundThread.setDaemon(true);
    // Start the thread
    backgroundThread.start();
}

public void runTask()
{
    try {
        // do something...         
        Thread.sleep(1000);

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Vous pouvez utiliser cron4j. http://www.sauronsoftware.it/projects/cron4j/manual.php

Dans un système de production qui peut avoir plusieurs conteneurs non-jee en cours d'exécution. Utilisez un planificateur d'entreprise non tel que le planificateur Quartz qui peut être configuré pour utiliser une base de données pour la tâche maamgememt.