Quartz: Cron expression that will never execute

Question

I know there is a duplicate here, which probably is exactly my case, though it would deserve some better explanation, which I will try to provide here.

I work with a Java web application using a Spring application context. In this context, I defined scheduled jobs using Quartz. These jobs are triggered by a cron defined in a .properties file.

The Spring context is embedded within the war, while the .properties file is on the application server (Tomcat in this particular case).

This is just fine and allows to define different crons according to the environment (development, integration, production, ...).

Now, when running this application locally on my own computer, I do not wish these jobs to be executed. Is there a way to write a cron expression which will never trigger?

Answer 1

TL;DR

In Quartz 1, you may use this cron: 59 59 23 31 12 ? 2099 (last valid date).
In Quartz 2, you may use this cron: 0 0 0 1 1 ? 2200

Using an expression far in the future

Made some quick tests using org.quartz.CronExpression.

String exp = "0 0 0 1 1 ? 3000"; boolean valid = CronExpression.isValidExpression(exp); System.out.println(valid); if (valid) {     CronExpression cronExpression = new CronExpression(exp);     System.out.println(cronExpression.getNextValidTimeAfter(new Date())); } 

When I do String exp = "# 0 0 0 1 1 ?";, the isValid test returns false.

With the sample given above yet, the output is the following:

true null 

Meaning:

• the expression is valid;
• there is no upcoming date which matches this expression.

For the scheduler to accept a cron trigger, though, the latter must match a date in the future.

I tried several years and figured out that once the year is above 2300, Quartz seems not to bother anymore (though I did not find a mention to a maximal value for the year in Quartz 2's documentation). There might be a cleaner way to do this, but this will satisfy my needs for now.

So, in the end, the cron I propose is 0 0 0 1 1 ? 2200.

Quartz 1 variant

Note that, in Quartz 1, 2099 is the last valid year. You can therefore adapt your cron expression to use Maciej Matys's suggestion: 59 59 23 31 12 ? 2099

Alternative: Using a date in the past

Arnaud Denoyelle suggested something more elegant, which my test above validates as a correct expression: instead of choosing a date in a far future, choose it in a far past:

0 0 0 1 1 ? 1970 (the first valid expression according to Quartz documentation).

This solution does not work though.

hippofluff highlighted that Quartz will detect an expression in past will never be executed again and therefore throw an exception.

org.quartz.SchedulerException: Based on configured schedule, the given trigger will never fire. 

This seems to have been in Quartz for a long time.

Lessons learned: the test is not foolproof as is

This highlights a weakness of my test: in case you want to test a CronExpression, remember it has to have a nextValidTime¹. Otherwise, the scheduler you will pass it to will simply reject it with the above mentioned exception.

I would advise adapting the test code as follows:

String exp = "0 0 0 1 1 ? 3000"; boolean valid = CronExpression.isValidExpression(exp); if (valid) {     CronExpression cronExpression = new CronExpression(exp);     valid = cronExpression.getNextValidTimeAfter(new Date()) != null; } System.out.println("Can I use <" + exp + ">? " + (valid ? "Go ahead!" : "This shall fail.")); 

There you go: no need to think, just read the output.

---

_{¹ This is the part I forgot when testing Arnaud's solution making me the fool and proving my test wasn't me-proof.}