如何在Maven / Vaadin项目的服务器后台运行Java类？

Question

Problem: I need to run one java function every 24 h. It get some data from one site and it push that data to database. No i wonder how to create timer which will run successfully on Tom Cat server. I have maven/Vaadin project. So now i wonder how to start Timer function that will run on server not on site.

Whit quartz:

timer:

public class TimerData implements org.quartz.Job {


    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();


    public TimerData() throws SchedulerException, InterruptedException {
        sched.scheduleJob(job, trigger);
        sched.start();
        Thread.sleep(90L * 1000L);
        sched.shutdown(true);
    }
    // define the job and tie it to our HelloJob class
    JobDetail job = newJob(TimerData.class)
            .withIdentity("job1", "group1")
            .build();
    // compute a time that is on the next round minute
    Date runTime = evenMinuteDate(new Date());

    // Trigger the job to run on the next round minute
    Trigger trigger = newTrigger()
            .withIdentity("trigger1", "group1")
            .startAt(runTime)
            .build();

    // Tell quartz to schedule the job using our trigger


    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // Say Hello to the World and display the date/time
        System.out.println("Hello World! - " + new Date());

        try {
            FillData.povni();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

dependency:

 <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.1</version>
  </dependency>
  <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
        <version>2.2.1</version>
  </dependency>

Contlistener:

public class ContListener implements ServletContextListener,
        HttpSessionListener, HttpSessionAttributeListener {
    private ServletContext context = null;
    // Public constructor is required by servlet spec
    public ContListener() {
    }

    // -------------------------------------------------------
    // ServletContextListener implementation
    // -------------------------------------------------------
    public void contextInitialized(ServletContextEvent sce) {
      /* This method is called when the servlet context is
         initialized(when the Web application is deployed). 
         You can initialize servlet context related data here.
      */
        context = sce.getServletContext();
    }

    public void contextDestroyed(ServletContextEvent sce) {
      /* This method is invoked when the Servlet Context 
         (the Web application) is undeployed or 
         Application Server shuts down.
      */
    }

    // -------------------------------------------------------
    // HttpSessionListener implementation
    // -------------------------------------------------------
    public void sessionCreated(HttpSessionEvent se) {
      /* Session is created. */
    }

    public void sessionDestroyed(HttpSessionEvent se) {
      /* Session is destroyed. */
    }

    // -------------------------------------------------------
    // HttpSessionAttributeListener implementation
    // -------------------------------------------------------

    public void attributeAdded(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute 
         is added to a session.
      */
    }

    public void attributeRemoved(HttpSessionBindingEvent sbe) {
      /* This method is called when an attribute
         is removed from a session.
      */
    }

    public void attributeReplaced(HttpSessionBindingEvent sbe) {
      /* This method is invoked when an attibute
         is replaced in a session.
      */
    }
}

Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <context-param>
        <param-name>quartz:config-file</param-name>
        <param-value>quartz.properties</param-value>
    </context-param>

    <context-param>
        <param-name>quartz:shutdown-on-unload</param-name>
        <param-value>true</param-value>
    </context-param>

    <context-param>
        <param-name>quartz:wait-on-shutdown</param-name>
        <param-value>true</param-value>
    </context-param>

    <context-param>
        <param-name>quartz:start-on-load</param-name>
        <param-value>true</param-value>
    </context-param>

    <listener>
        <listener-class>org.quartz.ee.servlet.QuartzInitializerListener</listener-class>
    </listener>
    <listener>
        <listener-class>ContListener</listener-class>
    </listener>
</web-app>

Answer 1

Using Quartz is, indeed, one of the most straightforward ways of doing this programmatically, since you will already have a server/app running.

Having said that, employing it in any Java web application is, obviously, independent of the UI technology you might use (Vaadin included) and IMHO, it's better to reason about it separately.

For the sake of completeness, I will go through all the steps involved in adding Quartz to a Maven-managed, Java web application below.

Adding Quartz as a Maven Dependency

Adding one dependency in your pom.xml should suffice:

<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.3</version>
</dependency>

Initializing a Quartz Scheduler in a Servlet Container

A default Quartz scheduler is automatically created and initialized upon Servlet Context initialization (as illustrated at http://www.quartz-scheduler.org/documentation/quartz-2.x/cookbook/ServletInitScheduler.html ) by declaring a servlet context listener and several context parameters to the web.xml descriptor:

<context-param>
  <param-name>quartz:config-file</param-name>
  <param-value>/quartz.properties</param-value>
</context-param>
<context-param>
  <param-name>quartz:shutdown-on-unload</param-name>
  <param-value>true</param-value>
</context-param>
<context-param>
  <param-name>quartz:wait-on-shutdown</param-name>
  <param-value>false</param-value>
</context-param>
<context-param>
  <param-name>quartz:start-scheduler-on-load</param-name>
  <param-value>true</param-value>
</context-param>
<listener>
  <listener-class>
    org.quartz.ee.servlet.QuartzInitializerListener
  </listener-class>
</listener>

You should also configure the scheduler by providing a basic quartz.properties file:

org.quartz.scheduler.instanceName = LenartScheduler
org.quartz.scheduler.instanceId = LenartScheduler.ID
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

At this point, after the application has been deployed/started, a Quartz scheduler instance can be obtained from a "standard" scheduler factory available to you under a default key in the web application's ServletContext object:

StdSchedulerFactory schedFact = (StdSchedulerFactory)
  ctx.getAttribute("org.quartz.impl.StdSchedulerFactory.KEY");
try {
    Scheduler scheduler = schedFact.getScheduler("LenartScheduler");
    // schedule Jobs here...
} catch (SchedulerException e) {
    // properly handle the exception...
}

Note that we've used the scheduler name ( LenartScheduler ) specified in the quartz.properties file above. As well, note that at this point, nothing is scheduled yet – all we have is a scheduler ready to be used.

Creating the Job Class

Easily done by implementing org.quartz.Job :

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MainJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext)
      throws JobExecutionException {

        // Simulate job execution for 5 seconds...
        try {
            System.out.println("Executing job in background...");
            Thread.sleep(1000 * 5 /* secs */);
            System.out.println("Done executing job.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Scheduling the Job

Given the available Scheduler, we need to define:

1. the so-called "details" of a Job

AND

2. a trigger for those details

and use them both to finally schedule the job:

private void scheduleMainJob(Scheduler scheduler) throws SchedulerException {
    requireNonNull(scheduler);

    JobDetail jobDetail = newJob(MainJob.class).storeDurably()
                                               .withIdentity("MAIN_JOB")
                                               .withDescription("Main Job to Perform")
                                               .build();
    Trigger trigger = newTrigger().forJob(jobDetail)
                                  .withIdentity("MAIN_JOB_TRIGG")
                                  .withDescription("Trigger for Main Job")
                 .withSchedule(simpleSchedule().withIntervalInSeconds(15).repeatForever())
                 .startNow().build();

    scheduler.scheduleJob(jobDetail, trigger);
}

Note the simple way of specifying when to trigger the job (no cron expression involved for your simple case, at least not yet). For the sake of the example, I am triggering the job every 15 seconds and let it run for 5 -- if you want to trigger it every 24 hours (ie one a day) you can use simpleSchedule().withIntervalInHours(24).repeatForever() .

Automatically Scheduling the Job

Now, the astute will notice that we still haven't called the scheduling functionality just yet. We could either do it "manually" , by defining some sort of an admin servlet/UI and upon user interaction to call the scheduling method defined above or, if we are OK with using the predefined/hardcoded values, automatically , upon servlet context start up, like we did it with the scheduler.

Let's say we want to automatically schedule the main job, upon servlet context start up. We again have at least 2 options:

1. implement a ServletContextListener that does/calls the scheduling routine above and make sure it is called after the QuartzInitializerListener we've declared in order to have the scheduler created

OR

2. extend the QuartzInitializerListener class to schedule our main job just after the scheduler gets created; this way, we don't have to worry about the order in which the context listeners get called:

    public class LenartQuartzListener extends QuartzInitializerListener { @Override public void contextInitialized(ServletContextEvent evt) { super.contextInitialized(evt); // At this point, the default functionality // has been executed hence the scheduler has been created! ServletContext ctx = evt.getServletContext(); StdSchedulerFactory factory = (StdSchedulerFactory) ctx.getAttribute("org.quartz.impl.StdSchedulerFactory.KEY"); try { scheduleMainJob(factory.getScheduler("LenartScheduler")); } catch (SchedulerException e) { // properly handle the exception... } } } 

However, if we're using the (better, IMHO) second option, we do need to specified in the web.xml file our new Quartz listener, instead if the old one:

<listener>
  <listener-class>com.lenard.web.LenartQuartzListener</listener-class>
</listener>

At this point, never mind the UI technology used (Vaadin, etc.), a Quartz scheduler is automatically initialized and a job scheduled upon (web) application start up.

If using Vaadin

These days, one can initialize a Vaadin-based web application without using a web.xml descriptor. If that's your case, note that you now need to add the web.xml file that specifies the Quartz initialization we've been talking about. But this does not clash with any Vaadin-specific stuff…

I've created a small Vaadin-based project at https://github.com/octavian-nita/so/tree/master/so-42899401-quartz-maven-tomcat to illustrate how one can manually schedule / unschedule Quartz jobs using a Vaadin UI. Feel free to study it and ask ahead!

Answer 2

Created a dummy boilerplate project for this. Have a look https://github.com/dhruvpsaru/quartz-test

In place of xml I am using annotations that I think is better way

pom.xml is

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>web-app</groupId>
  <artifactId>app</artifactId>
  <packaging>war</packaging>
  <version>1.0</version>
  <name>app Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz</artifactId>
      <version>2.2.1</version>
    </dependency>

    <dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz-jobs</artifactId>
      <version>2.2.1</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.21</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.1.7</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>app</finalName>
  </build>
</project>

Create a servlet as

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;


    @WebServlet(
            name = "AnnotatedServlet",
            description = "A sample annotated servlet",
            urlPatterns = {"/test"}
    )
    public class AppServlet extends HttpServlet {

        private final Logger logger = LoggerFactory.getLogger(this.getClass());

        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            logger.info("------------------------in servlet-------------------");

            PrintWriter writer = resp.getWriter();
            writer.println("<html>Hello, I am a Java servlet!</html>");
            writer.flush();
        }
    }

Create a job class as

package quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SimpleJob implements Job {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        logger.info("This is my first quartz job!!");
    }
}

and create a listener as

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

import static org.quartz.TriggerBuilder.newTrigger;

@WebListener
public class QuartzScheduler implements ServletContextListener {

    private Scheduler scheduler = null;
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public void contextInitialized(ServletContextEvent servletContextEvent) {
        logger.info("Context Initialized");

        try {
            // Setup the Job class and the Job group
            JobDetail job = JobBuilder.newJob(SimpleJob.class).withIdentity(
                    "CronQuartzJob", "Group").build();

            // Create a Trigger that fires every 5 minutes.
            Trigger trigger = newTrigger()
                    .withIdentity("TriggerName", "Group")
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                    .build();

            // Setup the Job and Trigger with Scheduler & schedule jobs
            scheduler = new StdSchedulerFactory().getScheduler();
            scheduler.start();
            scheduler.scheduleJob(job, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        logger.info("Context Destroyed");
        try
        {
            scheduler.shutdown();
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
        }
    }
}

and now go and do mvn clean package and deploy target/app.war