Analyser les options de commande en Java avec commons-cli

  • FrançaisFrançais



  • Lorsque vous entrez une commande dans votre terminal, que ce soit pour lancer une application graphique ou simplement une application de terminal, il existe souvent des options (parfois appelées commutateurs ou alors drapeaux) vous pouvez utiliser pour modifier la façon dont l’application s’exécute. Il s’agit d’un standard défini par la spécification POSIX, il est donc utile pour un programmeur Java de savoir comment détecter et analyser les options.

    Il existe plusieurs façons d’analyser les options en Java. Mon préféré est le Interface de ligne de commande Apache Commons bibliothèque, appelée communs-cli pour faire court.

    Installation de commons-cli

    Si vous utilisez un système de gestion de projet comme Maven et un IDE, vous pouvez installer la bibliothèque Apache Commons CLI dans les propriétés de votre projet (telles que pom.xml ou un écran de configuration dans Eclipse ou NetBeans).

    Si vous gérez les bibliothèques manuellement, vous pouvez télécharger la dernière version du site Web d’Apache. Plusieurs fichiers JAR sont regroupés. Le seul JAR requis est le commons-cli-X.Y.jar (où X et Y sont les derniers numéros de version.) Ajoutez ce JAR à votre projet, soit manuellement, soit dans votre IDE, puis vous pourrez l’utiliser dans votre code.

    Importer une bibliothèque dans votre code Java

    Pour utiliser le communs-cli bibliothèque dans votre code, vous devez l’importer. Pour cet exemple simple d’analyse d’options, vous pouvez remplir un fichier appelé Main.java avec le code minimal standard :

    package com.opensource.myoptparser;

    import org.apache.commons.cli.*;

    public class Main {
        public static void main(String[] args) {
        // code 
        }
    }

    Vous êtes maintenant prêt à analyser les options en Java.

    Définition des options booléennes en Java

    La première chose que vous devez faire pour analyser les options est de définir les options valides que votre application peut accepter. Utilisez le Option (singulier) pour créer des objets d’option et la Options (pluriel) pour vous aider à garder une trace de toutes les options que vous avez créées dans votre projet.

    Tout d’abord, créez un groupe pour vos options et appelez-le options selon convention :

        //code
        Options options = new Options();

    Ensuite, définissez vos options individuelles en répertoriant une option courte, une option longue, une valeur booléenne par défaut et un message d’aide. Vous définissez ensuite si l’option est requise ou non, et enfin ajoutez l’option au options objet, qui contient toutes vos options. Dans cet exemple, je crée une seule option, arbitrairement appelée alpha:

        //define options
        Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
        options.addOption(alpha);

    Définir des options avec des arguments en Java

    Parfois, vous souhaitez que les utilisateurs fournissent des informations autres que vrai ou alors faux avec une option. Vous pouvez laisser un utilisateur se référer à un fichier de configuration, un fichier d’entrée ou tout autre paramètre comme une date ou une couleur. Pour cela, vous utilisez le builder méthode, en créant des attributs pour une option en fonction de sa version courte (par exemple, -c est une option courte, --config est une option longue). Une fois défini, vous ajoutez la nouvelle option à votre options grouper:

        Option config = Option.builder("c").longOpt("config")
            .argName("config")
            .hasArg()
            .required(true)
            .desc("set config file").build();
        options.addOption(config);

    Avec le builder fonction, vous pouvez définir la version courte, la version longue, si cela est nécessaire (je l’ai défini sur vrai dans ce code, donc mon application ne peut pas s’exécuter à moins que cette option ne soit fournie par l’utilisateur au moment du lancement), le message d’aide, etc.

    Options d’analyse avec Java

    Avec toutes les options possibles définies, vous pouvez maintenant parcourir les arguments fournis par l’utilisateur, en vérifiant si un argument correspond à votre liste approuvée d’options courtes valides. Pour ce faire, vous créez une instance du Ligne de commande lui-même, qui contient tous les arguments fournis par l’utilisateur (options valides et autres.) Vous créez également un AnalyseurLigneCommande objet, que j’appelle parser dans mon code, pour faciliter l’interaction sur ces arguments. Enfin, vous pouvez créer un Formateur d’aide objet (que j’appelle helper) pour fournir automatiquement des messages utiles à l’utilisateur lorsqu’une option requise est manquante ou que le --help ou alors -h option est utilisée.

        // define parser
        CommandLine cmd;
        CommandLineParser parser = new BasicParser();
        HelpFormatter helper = new HelpFormatter();

    Enfin, ajoutez quelques conditions pour analyser les options fournies par l’utilisateur en entrée de ligne de commande (découvert et stocké dans le cmd variable). Cet exemple d’application a deux types d’options différents, mais dans les deux cas, vous pouvez vérifier si l’option existe avec le .hasOption méthode plus le nom abrégé de l’option. Lorsqu’une option est détectée, vous pouvez faire tout ce qui doit être fait avec les données.

    try {
        cmd = parser.parse(options, args);
        if(cmd.hasOption("a")) {
        System.out.println("Alpha activated");
        }

        if (cmd.hasOption("c")) {
        String opt_config = cmd.getOptionValue("config");
        System.out.println("Config set to " + opt_config);
        }
    } catch (ParseException e) {
        System.out.println(e.getMessage());
        helper.printHelp("Usage:", options);
        System.exit(0);
    }

    L’acte d’analyse génère potentiellement une erreur car parfois le -c ou alors --config l’option pourrait être manquante. Dans ce cas, un message d’aide est imprimé et l’application est immédiatement fermée. En raison de cette erreur (un exception dans la terminologie Java), vous devez modifier le début de la méthode main pour déclarer une éventuelle exception :

    public static void main(String[] args) throws ParseException {

    L’exemple d’application est maintenant terminé.

    Testez votre code

    Vous pouvez tester l’application dans votre IDE en ajustant les paramètres par défaut transmis à votre code ou simplement créer un fichier JAR et l’exécuter à partir de votre terminal. Le processus pour cela diffère en fonction de votre IDE. Référez-vous à votre documentation IDE, lisez mon article sur comment LINK-TO-ARTICLE[build a JAR], ou consultez l’article de Daniel Oh sur la façon de faire de même avec Maven.

    Tout d’abord, confirmez l’exception de l’analyseur en omettant les -c ou alors --config option:

    $ java -jar dist/myapp.jar                 
    Missing required option: c
    usage: Usage:
     -a,--alpha             Activate feature alpha
     -c,--config <config>   Set config file

    Essayez à nouveau avec les options fournies :

    java -jar dist/myantapp.jar --config foo -a
    Alpha activated
    Config set to foo

    Analyse des options

    L’inclusion d’options pour vos utilisateurs est une fonctionnalité importante pour toute application. Java et Apache Commons le rendent facile à faire.

    Voici le code de démonstration complet pour votre référence :

    package com.opensource.myapp;

    import org.apache.commons.cli.*;

    public class Main {
        
        /**
         * @param args the command line arguments
         * @throws org.apache.commons.cli.ParseException
         */
     
        public static void main(String[] args) throws ParseException {
            // define options
            Options options = new Options();
            
            Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
            options.addOption(alpha);
            
            Option config = Option.builder("c").longOpt("config")
                    .argName("config")
                    .hasArg()
                    .required(true)
                    .desc("Set config file").build();
            options.addOption(config);
         
            // define parser
            CommandLine cmd;
            CommandLineParser parser = new BasicParser();
            HelpFormatter helper = new HelpFormatter();

            try {
                cmd = parser.parse(options, args);
                if(cmd.hasOption("a")) {
                    System.out.println("Alpha activated");
                }
              
                if (cmd.hasOption("c")) {
                    String opt_config = cmd.getOptionValue("config");
                    System.out.println("Config set to " + opt_config);
                }
            } catch (ParseException e) {
                System.out.println(e.getMessage());
                helper.printHelp("Usage:", options);
                System.exit(0);
            }
        }
    }

    Utilisation de Java et des options

    Les options permettent aux utilisateurs de modifier le fonctionnement des commandes. Il existe de nombreuses façons d’analyser les options lors de l’utilisation de Java, et le commons-cli est une solution open source robuste et flexible. Essayez-le dans votre prochain projet Java.

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.