Args4j ou de l’utilisation de Java pour faire des Batchs

Parce que ça fait longtemps que je n’ai pas parlé d’informatique, je vais présenter cette petite librairie qui permet de faire les choses proprement quand on conçoit une application Java utilisable en ligne de commande.

En effet la plupart du temps quand on devait créer une telle application, on créait une méthode un peu comme cela :

public static void main(String[] args){
Class instance = new Class();

// récupération du nom de l'individu :
instance.nom = args[0];

// récupération de l'age de l'individu :
instance.age = Integer.valueOf(args[1]);

// récupération du boolean vie/mort :
instance.isMort = Boolean.valueOf(args[2]);

}

En supposant bien sûr aucune vérification, aucune robustesse, et surtout un code on ne peut plus clair…
Args4j permet de mettre un peu plus de formalisme derrière tout ça, ainsi on va pouvoir rapprocher l’utilisation d’un programme java de celui de n’importe quel script sh ou python utilisable sous unix (avec des paramètres de la forme -name “Olivier”).
La seule contrainte est de définir les paramètres que va devoir traiter args4j en tant que variables membres de la classe, ce qui reste une toute petite contrainte face à l’économie de prise de tête que représente l’outil.
Ainsi pour reprendre mon exemple avec un individu, on va reformater les élèments du programme sous cette forme :

import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;
import org.kohsuke.args4j.spi.IntOptionHandler;
import org.kohsuke.args4j.spi.BooleanOptionHandler;
import java.io.IOException;

public class Individu {

@Option(name = "-n",aliases = {"--name"},usage="Sets a name for the person", required = true)
private String nom;

@Option(name = "-y", aliases = {"--years"},handler= IntOptionHandler.class, usage ="Define the person's age" )
private Integer age;

@Option(name="--isdead", handler = BooleanOptionHandler.class, usage = "Define if the person is dead")
private boolean isMort;


public void doMain(String[] args) throws IOException {
CmdLineParser parser = new CmdLineParser(this);

try {

// parse the arguments.
parser.parseArgument(args);  

} catch( CmdLineException e ) {
System.err.println(e.getMessage());

// on va réafficher les possibilités d'arguments du programme

parser.printUsage(System.err);
return;
}
}

public static void main(String[] args) throws IOException{
Individu jean = new Individu();
jean.doMain(args);
}
}

Grâce à ce simple code et le tag des variables dont on avait besoin, ainsi que la définition de handler vérifiant que les paramètres donnés sont bel et bien du type attendu ou tout simplement qu’ils sont présent.
Ainsi le code ci-dessus une fois utilisé en ligne de commande donne le résultat suivant :

Il est encore plus intéressant de pouvoir définir ses propres handler, et de pouvoir appliquer cette notion d’Options à des méthodes qui se chargeront de remplir plusieurs paramètres à la fois. Enfin tout ça vous pourrez le découvrir si vous vous intéressez un peu plus à la librairie que l’on doit à Kohsuke Kawaguchi.