Java Language Traitement des arguments à la main


Exemple

Lorsque la syntaxe de ligne de commande d'une application est simple, il est raisonnable de traiter l'argument de commande entièrement en code personnalisé.

Dans cet exemple, nous présenterons une série d’études de cas simples. Dans chaque cas, le code produira des messages d'erreur si les arguments sont inacceptables, puis appelez System.exit(1) pour indiquer au shell que la commande a échoué. (Nous supposerons dans chaque cas que le code Java est appelé à l'aide d'un wrapper dont le nom est "myapp".)

Une commande sans arguments

Dans cette étude de cas, la commande ne nécessite aucun argument. Le code montre que args.length nous donne le nombre d’arguments de la ligne de commande.

public class Main {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.err.println("usage: myapp");
            System.exit(1);
        }
        // Run the application
        System.out.println("It worked");
    }
}

Une commande avec deux arguments

Dans cette étude de cas, la commande nécessite précisément deux arguments.

public class Main {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.err.println("usage: myapp <arg1> <arg2>");
            System.exit(1);
        }
        // Run the application
        System.out.println("It worked: " + args[0] + ", " + args[1]);
    }
}

Notez que si nous args.length vérifier args.length , la commande planterait si l'utilisateur l' args.length avec trop peu d'arguments en ligne de commande.

Une commande avec les options "flag" et au moins un argument

Dans cette étude de cas, la commande dispose de deux options d'indicateur (facultatif) et nécessite au moins un argument après les options.

package tommy;
public class Main {
    public static void main(String[] args) {
        boolean feelMe = false;
        boolean seeMe = false;
        int index;
        loop: for (index = 0; index < args.length; index++) {
            String opt = args[index];
            switch (opt) {
            case "-c":
               seeMe = true;
               break;
            case "-f":
               feelMe = true;
               break;
            default:
               if (!opts.isEmpty() && opts.charAt(0) == '-') {
                   error("Unknown option: '" + opt + "');
               }
               break loop;
            }
        }
        if (index >= args.length) {
            error("Missing argument(s)");
        }      
        
        // Run the application
        // ...
    }

    private static void error(String message) {
        if (message != null) {
            System.err.println(message);
        }
        System.err.println("usage: myapp [-f] [-c] [ <arg> ...]");
        System.exit(1);
   }
}

Comme vous pouvez le constater, le traitement des arguments et des options devient assez compliqué si la syntaxe de commande est compliquée. Il est conseillé d'utiliser une bibliothèque "d'analyse de ligne de commande"; voir les autres exemples.