Java Language
Wiersz polecenia Przetwarzanie argumentów

Składnia

• public static void main (Argumenty String [])

Parametry

Uwagi

Przetwarzanie argumentów przy użyciu GWT ToolBase

Jeśli chcesz przeanalizować bardziej złożone argumenty wiersza polecenia, np. Z opcjonalnymi parametrami, najlepszym rozwiązaniem jest użycie Google GWT. Wszystkie zajęcia są dostępne publicznie pod adresem:

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

Przykładem obsługi wiersza polecenia myprogram -dir "~/Documents" -port 8888 jest:

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 ma również metodę isRequired() którą można zastąpić, aby powiedzieć, że wymagany jest argument wiersza poleceń (domyślny powrót to false więc argument jest opcjonalny.

Ręczne przetwarzanie argumentów

Gdy składnia wiersza polecenia dla aplikacji jest prosta, uzasadnione jest wykonanie przetwarzania argumentu polecenia całkowicie w kodzie niestandardowym.

W tym przykładzie przedstawimy serię prostych studiów przypadków. W każdym przypadku kod wygeneruje komunikaty o błędach, jeśli argumenty są niedopuszczalne, a następnie System.exit(1) aby poinformować powłokę o niepowodzeniu polecenia. (W każdym przypadku założymy, że kod Java jest wywoływany za pomocą opakowania o nazwie „myapp”).

Polecenie bez argumentów

W tym studium przypadku polecenie nie wymaga argumentów. Kod ilustruje, że args.length podaje nam liczbę argumentów wiersza poleceń.

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

Polecenie z dwoma argumentami

W tym studium przypadku polecenie wymaga dokładnie dwóch argumentów.

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

Zauważ, że jeśli zaniedbamy sprawdzanie args.length , polecenie ulegnie awarii, jeśli użytkownik uruchomi go ze zbyt małą liczbą argumentów wiersza polecenia.

Polecenie z opcjami „flag” i co najmniej jednym argumentem

W tym studium przypadku polecenie ma kilka (opcjonalnych) opcji flag i wymaga co najmniej jednego argumentu po opcjach.

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

Jak widać, przetwarzanie argumentów i opcji staje się kłopotliwe, jeśli składnia polecenia jest skomplikowana. Wskazane jest użycie biblioteki „parsowanie wiersza poleceń”; zobacz inne przykłady.