cron-utils

Definimos cron y los soportamos.

cron-utils es una librería Java para definir, analizar, validar, migrar cron y obtener descripciones legibles por humanos. El proyecto sigue la Convención de Versionado Semántico, proporciona metadatos OSGi y utiliza la licencia Apache 2.0.

Descarga

cron-utils está disponible en el repositorio Maven central.

<dependency>
    <groupId>com.cronutils</groupId>
    <artifactId>cron-utils</artifactId>
    <version>9.2.1</version>
</dependency>

Para desarrolladores Android, cron-utils 7.0.0 asume Android 26+. Para versiones anteriores de Android, considere usar cron-utils 6.0.6. Si se usa ScheduleExpression de Java EE, esto debe proporcionarse como una dependencia en tiempo de ejecución.

Desarrollo actual

Actualmente estamos trabajando para actualizar la base de código hacia JDK 16, para asegurar que será totalmente compatible con JDK 17 cuando se lance.

Ahora estamos desarrollando una nueva generación de descriptores de cron usando traducción neuronal. Cualquier tipo de contribución es bienvenida: desde ayuda con la generación de conjuntos de datos hasta entrenamiento de modelos de aprendizaje automático y utilidades para cargarlos. Si está interesado, siga el issue #3.

Características

• Cree expresiones cron arbitrarias: ¡puede definir su propio formato cron! Los campos soportados son: segundo, minuto, hora, día del mes, mes, día de la semana, año.
• ¡Puede marcar el último campo como opcional!
• Soporta todos los caracteres especiales de cron: * / , -
  • ¡Los caracteres no estándar L, W, LW, '?' y # también son soportados!
• Soporta extensiones / apodos de cron: @yearly, @annually, @monthly, @weekly, @daily, @midnight, @hourly, @reboot
• Imprime en formato legible por humanos específico para un locale (Chino, Inglés, Alemán, Griego, Indonesio, Japonés, Coreano, Polaco, Rumano, Español, Suajili y Turco tienen soporte completo. Holandés, Francés, Italiano, Portugués y Ruso tienen soporte básico).
• Los procesos de análisis y descripción están desacoplados: ¡analice una vez y opere con el resultado!
• Construya expresiones cron usando CronBuilder:
  • no es necesario recordar campos y restricciones para cada proveedor de cron.
  • los cron se desacoplan del proveedor de cron: en cualquier momento puede exportar a otro formato.
• Verifique si las expresiones cron son equivalentes.
• ¡Comprima múltiples expresiones cron en una sola!
• Valide si las expresiones de cadena cron coinciden con una definición de cron.
• Convierta cron entre diferentes definiciones de cron: si necesita migrar expresiones, ¡CronMapper puede ayudarle!
• Se proporcionan definiciones predefinidas para las siguientes librerías de cron:
  • Unix
  • Cron4j
  • Quartz
  • Spring. Soporta dos definiciones: anteriores a v5.3 y a partir de v5.3.
• Obtenga el tiempo de última/próxima ejecución así como el tiempo desde la última ejecución/hasta la próxima ejecución.
• Calcule el número de ejecuciones entre dos días, y compare cron basados en sus frecuencias de ejecución.
• Obtenga el recuento de días laborables entre dos fechas, considerando diferentes políticas de fin de semana así como días festivos.
• ¿Necesita mapear constantes entre diferentes librerías de cron/tiempo? Use ConstantsMapper.

Ejemplos de uso

A continuación presentamos algunos ejemplos. Puede encontrar estos y otros en un repositorio de muestra que creamos para mostrar las librerías cron-utils.

Construir definiciones cron

// Define your own cron: arbitrary fields are allowed and last field can be optional
CronDefinition cronDefinition =
    CronDefinitionBuilder.defineCron()
        .withSeconds().and()
        .withMinutes().and()
        .withHours().and()
        .withDayOfMonth()
            .supportsHash().supportsL().supportsW().and()
        .withMonth().and()
        .withDayOfWeek()
            .withIntMapping(7, 0) //we support non-standard non-zero-based numbers!
            .supportsHash().supportsL().supportsW().and()
        .withYear().optional().and()
        .instance();

// or get a predefined instance
cronDefinition = CronDefinitionBuilder.instanceDefinitionFor(QUARTZ);

Construir una expresión cron

// Create a cron expression. CronMigrator will ensure you remain cron provider agnostic
import static com.cronutils.model.field.expression.FieldExpressionFactory.*;

Cron cron = CronBuilder.cron(CronDefinitionBuilder.instanceDefinitionFor(CronType.QUARTZ))
    .withYear(always())
    .withDoM(between(SpecialChar.L, 3))
    .withMonth(always())
    .withDoW(questionMark())
    .withHour(always())
    .withMinute(always())
    .withSecond(on(0))
    .instance();
// Obtain the string expression
String cronAsString = cron.asString(); // 0 * * L-3 * ? *

Analizar

// Create a parser based on provided definition
CronParser parser = new CronParser(cronDefinition);
Cron quartzCron = parser.parse("0 23 * ? * 1-5 *");

... ¡incluso expresiones multi-cron! ¿Qué tal comprimir múltiples cron en una sola línea? En lugar de escribir 0 0 9 * * ? *, 0 0 10 * * ? *, 0 30 11 * * ? * y 0 0 12 * * ? * podemos envolverlo en 0 0|0|30|0 9|10|11|12 * * ? *

Describir

// Create a descriptor for a specific Locale
CronDescriptor descriptor = CronDescriptor.instance(Locale.UK);

// Parse some expression and ask descriptor for description
String description = descriptor.describe(parser.parse("*/45 * * * * ?"));
// Description will be: "every 45 seconds"

description = descriptor.describe(quartzCron);
// Description will be: "every hour at minute 23 every day between Monday and Friday"
// which is the same description we get for the cron below:
descriptor.describe(parser.parse("0 23 * ? * MON-FRI *"));

Migrar

// Migration between cron libraries has never been so easy!
// Turn cron expressions into another format by using CronMapper:
CronMapper cronMapper = CronMapper.fromQuartzToCron4j();

Cron cron4jCron = cronMapper.map(quartzCron);
// and to get a String representation of it, we can use
cron4jCron.asString();//will return: 23 * * * 1-5

Validar

cron4jCron.validate()

Calcular tiempo desde/hasta la ejecución

// Get date for last execution
ZonedDateTime now = ZonedDateTime.now();
ExecutionTime executionTime = ExecutionTime.forCron(parser.parse("* * * * * ? *"));
ZonedDateTime lastExecution = executionTime.lastExecution(now);

// Get date for next execution
ZonedDateTime nextExecution = executionTime.nextExecution(now);

// Time from last execution
Duration timeFromLastExecution = executionTime.timeFromLastExecution(now);

// Time to next execution
Duration timeToNextExecution = executionTime.timeToNextExecution(now);