Java Language
Befehlszeile Argumentverarbeitung

Syntax

• public static void main (String [] args)

Parameter

Bemerkungen

Argumentverarbeitung mit GWT ToolBase

Wenn Sie komplexere Befehlszeilenargumente analysieren möchten, z. B. mit optionalen Parametern, sollten Sie den GWT-Ansatz von Google am besten verwenden. Alle Kurse sind öffentlich verfügbar unter:

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

Ein Beispiel für die Handhabung des Befehlszeile- myprogram -dir "~/Documents" -port 8888 lautet:

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 hat auch eine Methode isRequired() die überschrieben werden kann, um zu sagen, dass das Befehlszeilenargument erforderlich ist (Standardrückgabe ist false sodass das Argument optional ist.

Argumente von Hand bearbeiten

Wenn die Befehlszeilensyntax für eine Anwendung einfach ist, ist es sinnvoll, die Befehlsargumentverarbeitung vollständig in benutzerdefiniertem Code auszuführen.

In diesem Beispiel stellen wir eine Reihe einfacher Fallstudien vor. In jedem Fall gibt der Code Fehlermeldungen aus, wenn die Argumente nicht akzeptabel sind, und ruft dann System.exit(1) auf, um der Shell mitzuteilen, dass der Befehl fehlgeschlagen ist. (Wir gehen in jedem Fall davon aus, dass der Java-Code mit einem Wrapper mit dem Namen "myapp" aufgerufen wird.)

Ein Befehl ohne Argumente

In dieser Fallstudie erfordert der Befehl keine Argumente. Der Code veranschaulicht, dass wir mit args.length die Anzahl der Befehlszeilenargumente erhalten.

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");
    }
}

Ein Befehl mit zwei Argumenten

In dieser Fallstudie erfordert der Befehl genau zwei Argumente.

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]);
    }
}

Beachten Sie, dass der Befehl abstürzen würde, wenn der Benutzer args.length überprüft args.length , wenn er mit zu wenigen Befehlszeilenargumenten ausgeführt wurde.

Ein Befehl mit "Flag" -Optionen und mindestens einem Argument

In dieser Fallstudie hat der Befehl mehrere (optionale) Flag-Optionen und erfordert nach den Optionen mindestens ein Argument.

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);
   }
}

Wie Sie sehen, wird die Verarbeitung der Argumente und Optionen ziemlich umständlich, wenn die Befehlssyntax kompliziert ist. Es ist ratsam, eine "Kommandozeilenanalyse" -Bibliothek zu verwenden. siehe die anderen Beispiele.