Java Language
Kommandorad Argumentbehandling

Syntax

• public static void main (String [] args)

parametrar

Anmärkningar

Argumentbehandling med GWT ToolBase

Om du vill analysera mer komplexa kommandoradsargument, t.ex. med valfria parametrar, är det bättre att använda Googles GWT-strategi. Alla klasser är offentliga tillgängliga på:

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

Ett exempel för hantering av kommandoraden myprogram -dir "~/Documents" -port 8888 är:

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 har också en metod isRequired() som kan skrivas över för att säga att kommandoradsargumentet krävs (standardretur är false så att argumentet är valfritt.

Behandla argument för hand

När kommandoradsyntaxen för en applikation är enkel är det rimligt att bearbeta kommandotargumentet helt i anpassad kod.

I det här exemplet kommer vi att presentera en serie enkla fallstudier. I båda fallen kommer koden att producera felmeddelanden om argumenten är oacceptabla och ring sedan System.exit(1) att berätta skalet att kommandot har misslyckats. (Vi antar i båda fallen att Java-koden anropas med en omslag vars namn är "myapp".)

Ett kommando utan argument

I den här fallstudien kräver kommandot inga argument. Koden illustrerar att args.length ger oss antalet kommandoradsargument.

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

Ett kommando med två argument

I denna fallstudie kräver kommandot exakt två argument.

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

Observera att om vi försummade att kontrollera args.length skulle kommandot krascha om användaren körde det med för få kommandoradsargument.

Ett kommando med "flagg" -alternativ och minst ett argument

I denna fallstudie har kommandot ett par (valfritt) flaggalternativ och kräver minst ett argument efter alternativen.

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

Som du kan se blir bearbetning av argument och alternativ ganska besvärligt om kommandosyntaxen är komplicerad. Det är tillrådligt att använda ett "kommandoradsparaing" -bibliotek; se de andra exemplen.