Java Language
Opdrachtregel Argumentverwerking

Syntaxis

• public static void main (String [] args)

parameters

Opmerkingen

Argumentverwerking met GWT ToolBase

Als u complexere opdrachtregelargumenten wilt analyseren, bijvoorbeeld met optionele parameters, is het het beste om de GWT-benadering van Google te gebruiken. Alle lessen zijn openbaar beschikbaar op:

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

Een voorbeeld voor het verwerken van de opdrachtregel myprogram -dir "~/Documents" -port 8888 is:

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 ook een methode isRequired() die kan worden overschreven om te zeggen dat het opdrachtregelargument vereist is (standaardteruggave is false zodat het argument optioneel is.

Argumenten met de hand verwerken

Wanneer de opdrachtregel-syntaxis voor een toepassing eenvoudig is, is het redelijk om het opdrachtargument volledig in aangepaste code te verwerken.

In dit voorbeeld presenteren we een reeks eenvoudige casestudy's. In elk geval zal de code foutmeldingen produceren als de argumenten onaanvaardbaar zijn en vervolgens System.exit(1) aanroepen om de shell te vertellen dat de opdracht is mislukt. (We gaan er in elk geval van uit dat de Java-code wordt aangeroepen met een wrapper waarvan de naam "myapp" is.)

Een opdracht zonder argumenten

In deze case-study vereist het commando geen argumenten. De code illustreert dat args.length ons het aantal opdrachtregelargumenten geeft.

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

Een opdracht met twee argumenten

In deze case-study vereist het commando precies twee argumenten.

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

Merk op dat als we args.length om args.length te controleren, de opdracht zou crashen als de gebruiker deze zou uitvoeren met te weinig opdrachtregelargumenten.

Een opdracht met "vlag" -opties en ten minste één argument

In deze case-study heeft het commando een paar (optionele) vlagopties en vereist het na de opties ten minste één 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);
   }
}

Zoals u ziet, wordt het verwerken van de argumenten en opties nogal omslachtig als de syntaxis van de opdracht ingewikkeld is. Het is raadzaam om een "command line parsing" -bibliotheek te gebruiken; zie de andere voorbeelden.