Package org.springframework.scheduling.support

# Class CronTrigger

java.lang.Object
org.springframework.scheduling.support.CronTrigger

All Implemented Interfaces:
  `Trigger`

public class CronTrigger extends Object implements Trigger
`Trigger` implementation for cron expressions. Wraps a `CronExpression` which parses according to common crontab conventions.

Supports a Quartz day-of-month/week field with an L/# expression. Follows common cron conventions in every other respect, including 0-6 for SUN-SAT (plus 7 for SUN as well). Note that Quartz deviates from the day-of-week convention in cron through 1-7 for SUN-SAT whereas Spring strictly follows cron even in combination with the optional Quartz-specific L/# expressions.

Since:
  3.0
Author:
  Juergen Hoeller, Arjen Poutsma
See Also:
  - `CronExpression`

## Constructor Summary

Constructors
Constructor
Description
`CronTrigger(String expression)`
Build a `CronTrigger` from the pattern provided in the default time zone.
`CronTrigger(String expression, ZoneId zoneId)`
Build a `CronTrigger` from the pattern provided in the given time zone, with the same lenient execution as `CronTrigger(String)`.
`CronTrigger(String expression, TimeZone timeZone)`
Build a `CronTrigger` from the pattern provided in the given time zone, with the same lenient execution as `CronTrigger(String)`.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`equals(Object other)`
`static CronTrigger`
`forFixedExecution(String expression)`
Create a `CronTrigger` for fixed execution, to be rescheduled after every task based on the last scheduled time.
`static CronTrigger`
`forLenientExecution(String expression)`
Create a `CronTrigger` for lenient execution, to be rescheduled after every task based on the completion time.
`String`
`getExpression()`
Return the cron pattern that this trigger has been built with.
`int`
`hashCode()`
`Instant`
`nextExecution(TriggerContext triggerContext)`
Determine the next execution time according to the given trigger context.
`static CronTrigger`
`resumeFixedExecution(String expression, Instant resumptionTimestamp)`
Create a `CronTrigger` for fixed execution, to be rescheduled after every task based on the last scheduled time.
`static CronTrigger`
`resumeLenientExecution(String expression, Instant resumptionTimestamp)`
Create a `CronTrigger` for lenient execution, to be rescheduled after every task based on the completion time.
`String`
`toString()`

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface org.springframework.scheduling.Trigger

`nextExecutionTime`

## Constructor Details

### CronTrigger

public CronTrigger(String expression)
Build a `CronTrigger` from the pattern provided in the default time zone.

This is equivalent to the `forLenientExecution(java.lang.String)` factory method. Original trigger firings may be skipped if the previous task is still running; if this is not desirable, consider `forFixedExecution(java.lang.String)`.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
See Also:
  - `forLenientExecution(java.lang.String)`
  - `forFixedExecution(java.lang.String)`

### CronTrigger

public CronTrigger(String expression, TimeZone timeZone)
Build a `CronTrigger` from the pattern provided in the given time zone, with the same lenient execution as `CronTrigger(String)`.

Note that such explicit time zone customization is usually not necessary, using `TaskScheduler.getClock()` instead.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
  `timeZone` - a time zone in which the trigger times will be generated

### CronTrigger

public CronTrigger(String expression, ZoneId zoneId)
Build a `CronTrigger` from the pattern provided in the given time zone, with the same lenient execution as `CronTrigger(String)`.

Note that such explicit time zone customization is usually not necessary, using `TaskScheduler.getClock()` instead.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
  `zoneId` - a time zone in which the trigger times will be generated
Since:
  5.3
See Also:
  - `CronExpression.parse(String)`

## Method Details

### getExpression

public String getExpression()
Return the cron pattern that this trigger has been built with.

### nextExecution

@Nullable public Instant nextExecution(TriggerContext triggerContext)
Determine the next execution time according to the given trigger context.

Next execution times are calculated based on the completion time of the previous execution; therefore, overlapping executions won't occur.

Specified by:
  `nextExecution` in interface `Trigger`
Parameters:
  `triggerContext` - context object encapsulating last execution times and last completion time
Returns:
  the next execution time as defined by the trigger, or `null` if the trigger won't fire anymore

### equals

public boolean equals(@Nullable Object other)

Overrides:
  `equals` in class `Object`

### hashCode

public int hashCode()

Overrides:
  `hashCode` in class `Object`

### toString

public String toString()

Overrides:
  `toString` in class `Object`

### forLenientExecution

public static CronTrigger forLenientExecution(String expression)
Create a `CronTrigger` for lenient execution, to be rescheduled after every task based on the completion time.

This variant does not make up for missed trigger firings if the associated task has taken too long. As a consequence, original trigger firings may be skipped if the previous task is still running.

This is equivalent to the regular `CronTrigger` constructor. Note that lenient execution is scheduler-dependent: it may skip trigger firings with long-running tasks on a thread pool while executing at `forFixedExecution(java.lang.String)`-like precision with new threads per task.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
Since:
  6.1.3
See Also:
  - `resumeLenientExecution(java.lang.String, java.time.Instant)`

### resumeLenientExecution

public static CronTrigger resumeLenientExecution(String expression, Instant resumptionTimestamp)
Create a `CronTrigger` for lenient execution, to be rescheduled after every task based on the completion time.

This variant does not make up for missed trigger firings if the associated task has taken too long. As a consequence, original trigger firings may be skipped if the previous task is still running.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
  `resumptionTimestamp` - the timestamp to resume from (the last-known completion timestamp), with the new trigger calculated from there and possibly immediately firing (but only once, every subsequent calculation will start from the completion time of that first resumed trigger)
Since:
  6.1.3
See Also:
  - `forLenientExecution(java.lang.String)`

### forFixedExecution

public static CronTrigger forFixedExecution(String expression)
Create a `CronTrigger` for fixed execution, to be rescheduled after every task based on the last scheduled time.

This variant makes up for missed trigger firings if the associated task has taken too long, scheduling a task for every original trigger firing. Such follow-up tasks may execute late but will never be skipped.

Immediate versus late execution in case of long-running tasks may be scheduler-dependent but the guarantee to never skip a task is portable.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
Since:
  6.1.3
See Also:
  - `resumeFixedExecution(java.lang.String, java.time.Instant)`

### resumeFixedExecution

public static CronTrigger resumeFixedExecution(String expression, Instant resumptionTimestamp)
Create a `CronTrigger` for fixed execution, to be rescheduled after every task based on the last scheduled time.

This variant makes up for missed trigger firings if the associated task has taken too long, scheduling a task for every original trigger firing. Such follow-up tasks may execute late but will never be skipped.

Parameters:
  `expression` - a space-separated list of time fields, following cron expression conventions
  `resumptionTimestamp` - the timestamp to resume from (the last-known scheduled timestamp), with every trigger in-between immediately firing to make up for every execution that would have happened in the meantime
Since:
  6.1.3
See Also:
  - `forFixedExecution(java.lang.String)`