Java Language
Procesamiento de argumentos de línea de comando

Sintaxis

• Public static void main (String [] args)

Parámetros

Observaciones

Procesamiento de argumentos utilizando GWT ToolBase

Si desea analizar argumentos de línea de comando más complejos, por ejemplo, con parámetros opcionales, lo mejor es utilizar el enfoque GWT de Google. Todas las clases son públicas disponibles en:

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

Un ejemplo para manejar la línea de comandos myprogram -dir "~/Documents" -port 8888 es:

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 también tiene un método isRequired() que se puede sobrescribir para decir que se requiere el argumento de la línea de comandos (el retorno predeterminado es false por lo que el argumento es opcional.

Procesando argumentos a mano

Cuando la sintaxis de la línea de comandos para una aplicación es simple, es razonable realizar el procesamiento de los argumentos del comando completamente en código personalizado.

En este ejemplo, presentaremos una serie de estudios de casos simples. En cada caso, el código generará mensajes de error si los argumentos son inaceptables, y luego llame a System.exit(1) para decirle al shell que el comando ha fallado. (Supondremos en cada caso que el código Java se invoca mediante un contenedor cuyo nombre es "myapp").

Un comando sin argumentos.

En este estudio de caso, el comando no requiere argumentos. El código ilustra que args.length nos da el número de argumentos de línea de 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 dos argumentos.

En este estudio de caso, el comando requiere precisamente dos argumentos.

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

Tenga en cuenta que si no args.length , el comando se bloquearía si el usuario lo ejecutara con muy pocos argumentos de línea de comandos.

Un comando con opciones de "bandera" y al menos un argumento

En este estudio de caso, el comando tiene un par de opciones de marca (opcionales) y requiere al menos un argumento después de las opciones.

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

Como puede ver, el procesamiento de los argumentos y las opciones se vuelve un tanto engorroso si la sintaxis del comando es complicada. Es recomendable utilizar una biblioteca de "análisis de línea de comando"; ver los otros ejemplos