Java Language
Elaborazione degli argomenti della riga di comando

Sintassi

• public static void main (String [] args)

Parametri

Osservazioni

Elaborazione degli argomenti mediante GWT ToolBase

Se si desidera analizzare argomenti di riga di comando più complessi, ad esempio con parametri facoltativi, il migliore è utilizzare l'approccio GWT di Google. Tutte le classi sono disponibili al pubblico presso:

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

Un esempio per la gestione della riga di comando myprogram -dir "~/Documents" -port 8888 è:

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 ha anche un metodo isRequired() che può essere sovrascritto per dire che l'argomento della riga di comando è richiesto (il valore predefinito restituito è false modo che l'argomento sia facoltativo.

Elaborazione di argomenti a mano

Quando la sintassi della riga di comando per un'applicazione è semplice, è ragionevole eseguire l'argomento del comando elaborando interamente nel codice personalizzato.

In questo esempio, presenteremo una serie di semplici case study. In ogni caso, il codice genererà messaggi di errore se gli argomenti non sono accettabili e quindi chiamerà System.exit(1) per indicare alla shell che il comando non è riuscito. (Assumeremo in ogni caso che il codice Java è invocato usando un wrapper il cui nome è "myapp".)

Un comando senza argomenti

In questo caso di studio, il comando non richiede argomenti. Il codice illustra che args.length ci fornisce il numero di argomenti della riga di comando.

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

Un comando con due argomenti

In questo caso di studio, il comando richiede esattamente due argomenti.

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

Notare che se si trascurasse di controllare args.length , il comando si args.length anomalo se l'utente lo eseguiva con troppi pochi argomenti da riga di comando.

Un comando con opzioni "flag" e almeno un argomento

In questo caso di studio, il comando ha un paio di opzioni (opzionali) di flag e richiede almeno un argomento dopo le opzioni.

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

Come potete vedere, l'elaborazione degli argomenti e delle opzioni diventa piuttosto ingombrante se la sintassi del comando è complicata. Si consiglia di utilizzare una libreria "parsing della riga di comando"; vedi gli altri esempi.