Comparaison de Jakarta Commons CLI et Args4j


précédentsommairesuivant

III. Args4j

Téléchargement

Args4j est une API plus récente, et nécessite d'ailleurs un JRE 1.5 au minimum. Cela est dû au fait qu'elle se base sur des annotations pour la définition des arguments.
Elle est disponible ici, sous licence MIT.

Il est aussi possible de l'utiliser via Maven, mais cela nécessite l'ajout du repository dev.java.net, pour ce faire, il suffit de suivre ces indications.

Ensuite, il suffit d'ajouter la dépendance Maven :

 
Sélectionnez
<dependencies>
    <dependency>
      <groupId>args4j</groupId>
      <artifactId>args4j</artifactId>
      <version>2.0.8</version>
    </dependency>
  </dependencies>

Définitions des options

La première étape est aussi de définir les Option, mais à la différence de CLI, on se base sur des annotations.

 
Sélectionnez
public class MesOptions {
    @Option(name = "-h", aliases = {"--help"}, usage = "Affiche l'aide")
    private boolean help;

    @Option(name = "-v", aliases = {"--version"}, usage = "Affiche la version")
    private boolean version;

    @Option(name = "-l", aliases = {"--logfile"}, metaVar = "FILE", usage = "Specifie le fichier de trace")
    private File logfile;

    @Option(name = "-p", aliases = {"--port"}, metaVar = "PORT", required = true)
    private int port;


    @Argument
    private List<String> argument;
}

Chaque argument est donc annoté par @Option, qui prend divers paramètres tels qu'un nom, divers alias, un message d'usage.

L'annotation @Argument sert à spécifier une liste dans laquelle tout argument qui ne serait pas considéré comme une option sera inséré.

Traitement de la ligne de commande

Il faut ensuite traiter la ligne de commande en elle-même :

 
Sélectionnez
public static void main(String ... args){

        MesOptions options = new MesOptions();

        CmdLineParser parser = new CmdLineParser(options);

        try {
            parser.parseArgument(args);

              // Utilisation des arguments



        } catch (CmdLineException e) {
            // Affichage de l'aide
        }
    }

Il suffit de gérer les exceptions lancées dans le cas où une exception obligatoire n'existe pas, quand un argument avec valeur n'en possède pas ou qu'une option non précisée a été passée.

Il est cependant intéressant de savoir comment les exceptions sont gérées, autrement dit, quelles sont les options qui seront traitées lorsqu'une exception aura été lancée ?
La réponse est : toutes celles qui se trouvaient avant la cause de l'exception.

Ligne de commandes

Descriptions du problème

État des options

Raisons

-p 42 -l c:\serveur.log --mauvaiseoption

Une mauvaise option est insérée à la fin

-p : Initialisée
-l Initialisée

Le traitement a été correctement effectué afin d'atteindre le problème

--mauvaiseoption -p 42 -l c:\server.log

Une mauvaise option est insérée en tout premier argument

-p : non initialisée
-l : non initialisée

L'exception a été lancée avant d'avoir pu traiter les bons arguments

-v -h -l c:\serveur.log

L'option -p obligatoire n'est pas fournie

-l : initialisée
-v : initialisée
-h : initialisée

La vérification des arguments obligatoires se fait après traitement de la ligne complète

-p TEST -l c:\serveur.log

La valeur de l'option -p n'est pas dans un format correct

-p : non initialisée
-l : non initialisée

La traitement de -p a échoué, donc le traitement s'arrête

Utilisation des arguments

Ici, il n'y a pas de traitement spécial : en effet lors du traitement par Args4j, les valeurs des arguments ont été placées dans les champs associés, il suffit donc de travailler directement sur ceux-ci.

 
Sélectionnez
public static void main(String ... args){

        MesOptions options = new MesOptions();

        CmdLineParser parser = new CmdLineParser(options);

        try {
            parser.parseArgument(args);

            if(options.isHelp()){
                // Affichage de l'aide
            }
            if(options.isVersion()){
                // Affichage de la version
            }

            MonServeur  server = new MonServeur(options.getPort(), options.getLogfile()) ;



        } catch (CmdLineException e) {
           // Affichage de l'aide
        }
    }

Affichage de l'usage

 
Sélectionnez
public static void main(String ... args){

        MesOptions options = new MesOptions();

        CmdLineParser parser = new CmdLineParser(options);


        try {
            parser.parseArgument(args);

            if(options.isHelp()){
                // Affichage de l'aide
            }
            if(options.isVersion()){
                // Affichage de la version
            }

            MonServeur  server = new MonServeur(options.getPort(), options.getLogfile()) ;



        } catch (CmdLineException e) {

            parser.setUsageWidth(80);

            parser.printUsage(System.out);

        }
    }

L'affichage de l'aide se fait via la méthode printUsage(OutputStream) de l'objet CmdLineParser.

Il est possible d'internationaliser l'aide, en passant un deuxième paramètre de type RessourceBundle à la méthode printUsage. Dès lors, s'il existe une entrée pour l'usage, celui-ci sera affiché dans la langue voulue.

Création d'un Handler

Une des valeurs ajoutées de Args4j par rapport à CLI est qu'elle permet de créer des handlers pour des types particuliers.
Il n'y a par exemple pas d'Handler pour les URL ou les Date, mais il est assez simple de les créer :

Handler d'URL
Sélectionnez
public class URLOptionHandler extends OptionHandler {

    public URLOptionHandler(CmdLineParser cmdLineParser, OptionDef optionDef, Setter setter) {
        super(cmdLineParser, optionDef, setter);
    }

    public int parseArguments(Parameters parameters) throws CmdLineException {
        try {
            
            // Récupération de la première valeur de l'option
            // Création d'une URL et ajout dans la liste des valeurs
            String value = parameters.getParameter(0);
            setter.addValue(new URL(value));
            // Renvoie le nombre de paramètres utilisés
            return 1;
        } catch (MalformedURLException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            throw new CmdLineException(e);
        }
        
    }

    public String getDefaultMetaVariable() {
        // Spécifie la valeur par défaut qui sera utilisé dans l'usage pour le paramètre de l'option
        return "URL";
    }
}
Handler de date
Sélectionnez
public class DateOptionHandler extends OptionHandler {

    public DateOptionHandler(CmdLineParser cmdLineParser, OptionDef optionDef, Setter setter) {
        super(cmdLineParser, optionDef, setter);
    }

    public int parseArguments(Parameters parameters) throws CmdLineException {

        try {
            String value = parameters.getParameter(0);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
            setter.addValue(sdf.parse(value));
            return 1;


        } catch (ParseException e) {
            throw new CmdLineException("Bad date format, use date like 20070625", e);
        }


    }

    public String getDefaultMetaVariable() {
        return "YYYYMMDD";  
    }
}

Leur utilisation est tout aussi simple :

 
Sélectionnez
@Option(name="-d",handler = DateOptionHandler.class, usage = "Speficie une date")
private Date date;

@Option(name="-u", handler = URLOptionHandler.class)
URL url;

Annexes : Handlers fourni par Args4j

Classe / type

Handler

File

FileOptionHandler

String

StringOptionHandler

int

IntOptionHandler

double

DoubleOptionHandler

Enum

EnumOptionHandler


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.