Java Language
Traitement des arguments en ligne de commande

Syntaxe

• main statique vide statique (String [] args)

Paramètres

Remarques

Traitement des arguments à l'aide de GWT ToolBase

Si vous voulez analyser des arguments de ligne de commande plus complexes, par exemple avec des paramètres facultatifs, il est préférable d'utiliser l'approche GWT de Google. Toutes les classes sont publiques à:

https://gwt.googlesource.com/gwt/+/2.8.0-beta1/dev/core/src/com/google/gwt/util/tools/ToolBase.java

Un exemple de traitement de la ligne de commande myprogram -dir "~/Documents" -port 8888 est:

public class MyProgramHandler extends ToolBase {
   protected File dir;
   protected int port;
   // getters for dir and port
   ...

   public MyProgramHandler() {
       this.registerHandler(new ArgHandlerDir() {
            @Override
            public void setDir(File dir) {
                this.dir = dir;
            }
       });
       this.registerHandler(new ArgHandlerInt() {
            @Override
            public String[] getTagArgs() {
               return new String[]{"port"};
            }
            @Override
            public void setInt(int value) {
               this.port = value;
            }
       });
   }
   public static void main(String[] args) {
      MyProgramHandler myShell = new MyProgramHandler();
      if (myShell.processArgs(args)) {
         // main program operation
         System.out.println(String.format("port: %d; dir: %s",
            myShell.getPort(), myShell.getDir()));
      }
      System.exit(1);
   }
}

ArgHandler également une méthode isRequired() qui peut être écrasée pour indiquer que l'argument de ligne de commande est requis (le retour par défaut est false pour que l'argument soit facultatif).

Traitement des arguments à la main

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.