Qual é uma boa maneira de analisar argumentos de linha de comando em Java?

Verifique estes:

• http://commons.apache.org/cli/
• http://www.martiansoftware.com/jsap/
• http://picocli.info/

Ou faça o seu:

• http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

Por exemplo, é assim que você usa commons-clipara analisar 2 argumentos de sequência:

import org.apache.commons.cli.*;

public class Main {


    public static void main(String[] args) throws Exception {

        Options options = new Options();

        Option input = new Option("i", "input", true, "input file path");
        input.setRequired(true);
        options.addOption(input);

        Option output = new Option("o", "output", true, "output file");
        output.setRequired(true);
        options.addOption(output);

        CommandLineParser parser = new DefaultParser();
        HelpFormatter formatter = new HelpFormatter();
        CommandLine cmd;

        try {
            cmd = parser.parse(options, args);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
            formatter.printHelp("utility-name", options);

            System.exit(1);
        }

        String inputFilePath = cmd.getOptionValue("input");
        String outputFilePath = cmd.getOptionValue("output");

        System.out.println(inputFilePath);
        System.out.println(outputFilePath);

    }

}

uso da linha de comando:

$> java -jar target/my-utility.jar -i asd                                                                                       
Missing required option: o

usage: utility-name
 -i,--input <arg>    input file path
 -o,--output <arg>   output file

Dê uma olhada no JCommander mais recente .

Eu criei. É um prazer receber perguntas ou solicitações de recursos.

Eu tenho tentado manter uma lista de analisadores Java CLI .

• CIA aérea
  • Forquilha ativa: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• analisador de cli
• CmdLn
• Linha de comando
• DocOpt.java
• golfinho getopt
• CLI DPML (forquilha CLI2 do Jakarta Commons)
• Dr. Matthias Laux
• Jakarta Commons CLI
• jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (escrito por mim)
• JOpt simples
• jsap
• naturalcli
• Artigo sobre a CLI do Object Mentor (mais sobre refatoração e TDD)
• parse-cmd
• ritopt
• Rop
• Comando do Código TE
• O picocli possui ajuda de uso colorido ANSI e preenchimento automático

É 2020, hora de fazer melhor que o Commons CLI ... :-)

Você deve criar seu próprio analisador de linha de comando Java ou usar uma biblioteca?

Muitos aplicativos pequenos do tipo utilitário provavelmente rolam sua própria análise de linha de comando para evitar a dependência externa adicional. picocli pode ser uma alternativa interessante.

Picocli é uma biblioteca e estrutura modernas para criar aplicativos de linha de comando poderosos, fáceis de usar e habilitados para GraalVM com facilidade. Ele vive em um arquivo de origem e, portanto, os aplicativos podem incluí-lo como fonte para evitar adicionar uma dependência.

Ele suporta cores, preenchimento automático, subcomandos e muito mais. Escrito em Java, utilizável a partir de Groovy, Kotlin, Scala, etc.

Recursos:

• Baseado em anotação: declarativo , evita duplicação e expressa a intenção do programador
• Conveniente: analise a entrada do usuário e execute sua lógica de negócios com uma linha de código
• Tudo fortemente digitado - opções de linha de comando e parâmetros posicionais
• Opções curtas em cluster do POSIX ( <command> -xvfInputFileassim como <command> -x -v -f InputFile)
• Controle refinado : um modelo de aridade que permite um número mínimo, máximo e variável de parâmetros, por exemplo "1..*","3..5"
• Subcomandos (podem ser aninhados em profundidade arbitrária)
• Rico em recursos : grupos de argumentos composíveis, argumentos entre aspas divididos, subcomandos repetíveis e muito mais
• Fácil de usar : a mensagem de ajuda do uso usa cores para contrastar elementos importantes, como nomes de opções do restante do uso, para reduzir a carga cognitiva no usuário
• Distribua seu aplicativo como uma imagem nativa do GraalVM
• Funciona com Java 5 e superior
• Documentação extensa e meticulosa

A mensagem de ajuda de uso é fácil de personalizar com anotações (sem programação). Por exemplo:

( fonte )

Não resisti em adicionar mais uma captura de tela para mostrar que mensagens de ajuda de uso são possíveis. A ajuda de uso é o rosto do seu aplicativo, portanto, seja criativo e divirta-se!

Disclaimer: Eu criei picocli. Comentários ou perguntas muito bem-vindos.

Eu usei o JOpt e achei bastante útil: http://jopt-simple.sourceforge.net/

A primeira página também fornece uma lista de cerca de 8 bibliotecas alternativas, verifique-as e escolha a que melhor se adapta às suas necessidades.

Alguém me indicou args4j recentemente, que é baseado em anotação. Eu realmente gosto!

Esta é a biblioteca de análise de linha de comando do Google de código aberto, como parte do projeto Bazel. Pessoalmente, acho que é o melhor por aí e muito mais fácil que o Apache CLI.

https://github.com/pcj/google-options

Instalação

Bazel

maven_jar(
    name = "com_github_pcj_google_options",
    artifact = "com.github.pcj:google-options:jar:1.0.0",
    sha1 = "85d54fe6771e5ff0d54827b0a3315c3e12fdd0c7",
)

Gradle

dependencies {
  compile 'com.github.pcj:google-options:1.0.0'
}

Maven

<dependency>
  <groupId>com.github.pcj</groupId>
  <artifactId>google-options</artifactId>
  <version>1.0.0</version>
</dependency>

Uso

Crie uma classe que estenda OptionsBasee defina seu @Option(s).

package example;

import com.google.devtools.common.options.Option;
import com.google.devtools.common.options.OptionsBase;

import java.util.List;

/**
 * Command-line options definition for example server.
 */
public class ServerOptions extends OptionsBase {

  @Option(
      name = "help",
      abbrev = 'h',
      help = "Prints usage info.",
      defaultValue = "true"
    )
  public boolean help;

  @Option(
      name = "host",
      abbrev = 'o',
      help = "The server host.",
      category = "startup",
      defaultValue = ""
  )
  public String host;

  @Option(
    name = "port",
    abbrev = 'p',
    help = "The server port.",
    category = "startup",
    defaultValue = "8080"
    )
    public int port;

  @Option(
    name = "dir",
    abbrev = 'd',
    help = "Name of directory to serve static files.",
    category = "startup",
    allowMultiple = true,
    defaultValue = ""
    )
    public List<String> dirs;

}

Analise os argumentos e use-os.

package example;

import com.google.devtools.common.options.OptionsParser;
import java.util.Collections;

public class Server {

  public static void main(String[] args) {
    OptionsParser parser = OptionsParser.newOptionsParser(ServerOptions.class);
    parser.parseAndExitUponError(args);
    ServerOptions options = parser.getOptions(ServerOptions.class);
    if (options.host.isEmpty() || options.port < 0 || options.dirs.isEmpty()) {
      printUsage(parser);
      return;
    }

    System.out.format("Starting server at %s:%d...\n", options.host, options.port);
    for (String dirname : options.dirs) {
      System.out.format("\\--> Serving static files at <%s>\n", dirname);
    }
  }

  private static void printUsage(OptionsParser parser) {
    System.out.println("Usage: java -jar server.jar OPTIONS");
    System.out.println(parser.describeOptions(Collections.<String, String>emptyMap(),
                                              OptionsParser.HelpVerbosity.LONG));
  }

}

https://github.com/pcj/google-options

Dê uma olhada no projeto CLI do Commons , muitas coisas boas por aí.

Yeap.

Eu acho que você está procurando algo parecido com isto: http://commons.apache.org/cli

A biblioteca CLI do Apache Commons fornece uma API para processar interfaces de linha de comando.

Eu sei que a maioria das pessoas aqui encontrará 10 milhões de razões pelas quais elas não gostam do meu jeito, mas deixa pra lá. Eu gosto de manter as coisas simples, então apenas separo a chave do valor usando um '=' e as armazeno em um HashMap como este:

Map<String, String> argsMap = new HashMap<>();
for (String arg: args) {
    String[] parts = arg.split("=");
    argsMap.put(parts[0], parts[1]);
} 

Você sempre pode manter uma lista com os argumentos que espera, para ajudar o usuário caso ele se esqueça de um argumento ou use um errado ... No entanto, se você deseja muitos recursos, esta solução não é para você.

Talvez estes

• Conjunto de análise de opções de linha de comando JArgs para Java - este pequeno projeto fornece um conjunto conveniente, compacto, pré-empacotado e abrangente de documentos de analisadores de opções de linha de comando para o uso de programadores Java. Inicialmente, é fornecida a análise compatível com o 'getopt' no estilo GNU.

• ritopt, O Analisador de Opções Definitivas para Java - Embora vários padrões de opção de linha de comando tenham sido estabelecidos, o ritopt segue as convenções prescritas no pacote opt.

Você pode achar interessante este meta-artigo de infelicidade como ponto de partida:

http://furiouspurpose.blogspot.com/2008/07/command-line-parsing-libraries-for-java.html

Eu escrevi outro: http://argparse4j.sourceforge.net/

Argparse4j é uma biblioteca de analisador de argumentos de linha de comando para Java, baseada no argparse do Python.

Se você está familiarizado com o gnu getopt, há uma porta Java em: http://www.urbanophile.com/arenn/hacking/download.htm .

Parece haver algumas classes que fazem isso:

• http://docs.sun.com/source/816-5618-10/netscape/ldap/util/GetOpt.html
• http://xml.apache.org/xalan-j/apidocs/org/apache/xalan/xsltc/cmdline/getopt/GetOpt.html

companhia aérea @ Github parece ser bom. Ele é baseado em anotações e está tentando emular estruturas de linha de comando do Git.

Se você já estiver usando o Spring Boot, a análise de argumentos sairá da caixa.

Se você deseja executar algo após a inicialização, implemente a ApplicationRunnerinterface:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(ApplicationArguments args) {
    args.containsOption("my-flag-option"); // test if --my-flag-option was set
    args.getOptionValues("my-option");     // returns values of --my-option=value1 --my-option=value2 
    args.getOptionNames();                 // returns a list of all available options
    // do something with your args
  }
}

Seu runmétodo será chamado depois que o contexto for iniciado com êxito.

Se você precisar acessar os argumentos antes de iniciar o contexto do aplicativo, basta analisar os argumentos do aplicativo manualmente:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    ApplicationArguments arguments = new DefaultApplicationArguments(args);
    // do whatever you like with your arguments
    // see above ...
    SpringApplication.run(Application.class, args);
  }

}

E, finalmente, se você precisar acessar seus argumentos em um bean, basta injetar o ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

Argparse4j é o melhor que eu encontrei. Ele imita a biblioteca argparse do Python, que é muito conveniente e poderosa.

Se você quiser algo leve (tamanho do frasco ~ 20 kb) e simples de usar, tente o analisador de argumentos . Ele pode ser usado na maioria dos casos de uso, suporta a especificação de matrizes no argumento e não depende de nenhuma outra biblioteca. Funciona para Java 1.5 ou superior. O trecho abaixo mostra um exemplo de como usá-lo:

public static void main(String[] args) {
    String usage = "--day|-d day --mon|-m month [--year|-y year][--dir|-ds directoriesToSearch]";
    ArgumentParser argParser = new ArgumentParser(usage, InputData.class);
    InputData inputData = (InputData) argParser.parse(args);
    showData(inputData);

    new StatsGenerator().generateStats(inputData);
}

Mais exemplos podem ser encontrados aqui

Eu não recomendaria o uso da Apache Common CLIbiblioteca, pois não é segura para threads.

Ele usa classes stateful com variáveis ​​estáticas e métodos para realizar trabalhos internos (por exemplo OptionBuilder) e deve ser usado apenas em situações fortemente controladas de thread único.

Como um dos comentários mencionados anteriormente ( https://github.com/pcj/google-options ) seria uma boa opção para começar.

Uma coisa que eu quero adicionar é:

1) Se você encontrar algum erro de reflexão do analisador, tente usar uma versão mais recente da goiaba. No meu caso:

maven_jar(
    name = "com_google_guava_guava",
    artifact = "com.google.guava:guava:19.0",
    server = "maven2_server",
)

maven_jar(
    name = "com_github_pcj_google_options",
    artifact = "com.github.pcj:google-options:jar:1.0.0",
    server = "maven2_server",
)

maven_server(
    name = "maven2_server",
    url = "http://central.maven.org/maven2/",
)

2) Ao executar a linha de comando:

bazel run path/to/your:project -- --var1 something --var2 something -v something

3) Quando precisar da ajuda de uso, digite:

bazel run path/to/your:project -- --help

Para usuários do Spring, devemos mencionar também https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html e seu irmão gêmeo https: //docs.spring .io / spring / docs / current / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (implementação JOpt da mesma funcionalidade). A vantagem no Spring é que você pode vincular diretamente os argumentos da linha de comando aos atributos; existe um exemplo aqui https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/ CommandLinePropertySource.html