cron-utils

Nous définissons les crons. Et nous les supportons.

cron-utils est une bibliothèque Java pour définir, analyser, valider, migrer des crons ainsi que pour en obtenir des descriptions lisibles par les humains. Le projet suit la Convention de Versionnement Sémantique, fournit des métadonnées OSGi et utilise la licence Apache 2.0.

Téléchargement

cron-utils est disponible sur le dépôt Maven central.

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

Pour les développeurs Android, cron-utils 7.0.0 suppose Android 26+. Pour les versions antérieures d'Android, envisagez d'utiliser cron-utils 6.0.6. Si vous utilisez ScheduleExpression de Java EE, cela doit être fourni comme une dépendance d'exécution.

Développement actuel

Nous travaillons actuellement à mettre à jour la base de code vers JDK 16, pour garantir une pleine compatibilité avec JDK 17 lors de sa sortie.

Nous développons actuellement une nouvelle génération de descripteurs de cron utilisant la traduction neuronale ! Toute contribution est la bienvenue : de l'aide à la génération de jeux de données à l'entraînement de modèles d'apprentissage automatique et aux utilitaires pour les charger ! Si vous êtes intéressé, veuillez suivre le problème #3

Fonctionnalités

• Créez des expressions cron arbitraires : vous pouvez définir votre propre format cron ! Les champs pris en charge sont : seconde, minute, heure, jour du mois, mois, jour de la semaine, année.
• Vous pouvez marquer le dernier champ comme optionnel !
• Prend en charge tous les caractères spéciaux cron : * / , -
  • Les caractères non standard L, W, LW, '?' et # sont également pris en charge !
• Prend en charge les extensions / surnoms cron : @yearly, @annually, @monthly, @weekly, @daily, @midnight, @hourly, @reboot
• Imprimez dans un format lisible par les humains spécifique à la locale (le chinois, l'anglais, l'allemand, le grec, l'indonésien, le japonais, le coréen, le polonais, le roumain, l'espagnol, le swahili et le turc sont entièrement pris en charge. Le néerlandais, le français, l'italien, le portugais et le russe ont un support de base).
• Les processus d'analyse et de description sont découplés : analysez une fois et opérez avec le résultat !
• Construisez des expressions cron avec CronBuilder :
  • plus besoin de se souvenir des champs et contraintes pour chaque fournisseur cron.
  • les crons deviennent découplés du fournisseur cron : vous pouvez à tout moment exporter vers un autre format.
• Vérifiez si des expressions cron sont équivalentes.
• Réduisez plusieurs expressions cron en une seule !
• Validez si des expressions cron sous forme de chaîne correspondent à une définition cron.
• Convertissez des crons entre différentes définitions cron : si vous avez besoin de migrer des expressions, CronMapper peut vous aider !
• Des définitions prédéfinies pour les bibliothèques cron suivantes sont fournies :
  • Unix
  • Cron4j
  • Quartz
  • Spring. Nous supportons deux définitions : avant v5.3 et à partir de v5.3.
• Obtenez la dernière/prochaine heure d'exécution ainsi que le temps depuis la dernière exécution/le temps jusqu'à la prochaine exécution.
• Calculez le nombre d'exécutions entre deux jours, et comparez des crons en fonction de leurs fréquences d'exécution.
• Obtenez le nombre de jours ouvrés entre deux dates, en tenant compte de différentes politiques de week-end ainsi que des jours fériés.
• Besoin de mapper des constantes entre différentes bibliothèques de cron/temps ? Utilisez ConstantsMapper.

Exemples d'utilisation

Ci-dessous nous présentons quelques exemples. Vous pouvez les trouver ainsi que d'autres dans un dépôt d'exemples que nous avons créé pour présenter les bibliothèques cron-utils !

Construire des définitions 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);

Construire une expression 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 * ? *

Analyser

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

... même des expressions multi-cron ! Que diriez-vous de réduire plusieurs crons en une seule ligne ? Au lieu d'écrire 0 0 9 * * ? *, 0 0 10 * * ? *, 0 30 11 * * ? * et 0 0 12 * * ? * nous pouvons les encapsuler dans 0 0|0|30|0 9|10|11|12 * * ? *

Décrire

// 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 *"));

La description sera : « toutes les heures à la minute 23 chaque jour entre lundi et vendredi » qui est la même description que nous obtenons pour le cron ci-dessous :

descriptor.describe(parser.parse("0 23 * ? * MON-FRI *"));

Migrer

// 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

Valider

cron4jCron.validate()