Libreria Java per l'analisi dei parametri della riga di comando?

Question

Scrivo una piccola applicazione da riga di comando in Java. Questa applicazione dovrebbe funzionare con un mix di parametri e comandi, simile a svn.

Esempi

app url command1 
app url command2 --parameter2 -x 
app url command1 --param-with-argument argument 
app --parameter url command1 
app --no-url command2 
app --help 

Cercasi

• esiste una libreria facile da usare per Ja va
• supporta l'analisi di tali righe di comando
• (Bonus) crea automaticamente un aiuto appropriato

Answer 1

io sono un fan di Commons CLI.

È possibile impostarlo per comprendere comandi, contrassegni (con nomi brevi e lunghi), se sono richiesti o meno determinati comandi/interruttori o se hanno valori predefiniti. Ha anche funzionalità per stampare un utile messaggio di tipo --help.

La pagina Usage Scenarios ha alcuni buoni esempi di come può essere utilizzata.

Answer 2

C'è anche un java getopt http://www.urbanophile.com/arenn/hacking/download.html

Answer 3

Prova args4j:http://args4j.kohsuke.org

preferisco args4j a Commons CLI. (E ho usato entrambi.)

Con args4j, non è necessario chiamare alcuna funzione. Tutto è fatto per te! (I parametri sono impostati su campi oggetto tramite riflessione.)

Answer 4

JewelCLI è un Java library for command-line parsing that yields clean code. Utilizza le interfacce Proxied configurate con annotazioni per creare dinamicamente un'API sicura dal tipo per i parametri della riga di comando.

Un'interfaccia esempio parametro Person.java:

import uk.co.flamingpenguin.jewel.cli.Option; 

public interface Person { 
    @Option String getName(); 
    @Option int getTimes(); 
} 

Un esempio d'uso dell'interfaccia di parametri Hello.java:

import static uk.co.flamingpenguin.jewel.cli.CliFactory.parseArguments; 
import uk.co.flamingpenguin.jewel.cli.ArgumentValidationException; 

public class Hello { 
    public static void main(String [] args) { 
     try { 
      Person person = parseArguments(Person.class, args); 
      for (int i = 0; i < person.getTimes(); i++) 
       System.out.println("Hello " + person.getName()); 
     } catch(ArgumentValidationException e) { 
      System.err.println(e.getMessage()); 
     } 
    } 
} 

salvare copie dei file di cui sopra a una singola directory e scaricare il JewelCLI 0.7.6 JAR a quella directory anche.

Compilare ed eseguire l'esempio in Bash su Linux/Mac OS X/etc.:

javac -cp jewelcli-0.7.6.jar:. Person.java Hello.java 
java -cp jewelcli-0.7.6.jar:. Hello --name="John Doe" --times=3 

Compilare ed eseguire l'esempio nel prompt dei comandi di Windows:

javac -cp jewelcli-0.7.6.jar;. Person.java Hello.java 
java -cp jewelcli-0.7.6.jar;. Hello --name="John Doe" --times=3 

eseguire l'esempio dovrebbe produrre il seguente output:

Hello John Doe 
Hello John Doe 
Hello John Doe 

Answer 5

JSAP sembra piuttosto buono per me.

http://sourceforge.net/projects/jsap/

Answer 6

E 'anche la pena di guardare --jopt-simple.

E 'il tentativo di rispettare le sintassi delle opzioni della riga di comando di POSIX getopt() e GNU getopt_long().' Sembra avere una certa trazione della community, in particolare la riga di comando che analizza la lib di scelta per lo OpenJDK (e Minecraft!).

Answer 7

Per completezza aggiungiamo JCommander https://github.com/cbeust/jcommander

public class JCommanderTest { 
    @Parameter 
    public List<String> parameters = Lists.newArrayList(); 

    @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity") 
    public Integer verbose = 1; 

    @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") 
    public String groups; 

    @Parameter(names = "-debug", description = "Debug mode") 
    public boolean debug = false; 
} 

ed un esempio di utilizzo

CommanderTest jct = new JCommanderTest(); 
String[] argv = { "-log", "2", "-groups", "unit", "a", "b", "c" }; 
new JCommander(jct, argv); 

Assert.assertEquals(jct.verbose.intValue(), 2); 

Answer 8

sto usando ponte aereo per un progetto su cui sto lavorando, sembra funzionare abbastanza bene:

https://github.com/airlift/airline

semplice Maven Depen denza che è necessario aggiungere:

<dependency> 
    <groupId>io.airlift</groupId> 
    <artifactId>airline</artifactId> 
    <version>0.6</version> 
</dependency> 

E dopo che è annotazioni basata e ha un modo abbastanza pulito di visualizzare il testo della guida pure.

possibile vedere un esempio qui, se è utile:

https://github.com/mneedham/neo4j-web-importer/blob/master/src/main/java/org/neo4j/dataimport/Neo4jImporter.java

Answer 9

Ecco un relativamente aggiornati (come di agosto 2017) elenco delle librerie che rispondere alla tua domanda.

• picocli (2017) ha di aiuto l'utilizzo con i colori ANSI, e completamento automatico
• JArgs
• Jakarta Commons CLI
• TE-Code (che ha una linea di comando parsing biblioteca.)
• argparser
• Java port of GNU getopt
• Args4J
• JSAP
• JOpt Simple
• CLAJR
• CmdLn
• JewelCli
• JCommando
• parse-cmd
• JCommander

Se siete alla ricerca di una raccomandazione, vi consiglio JOpt Semplice o JewelCli.

Answer 10

Commandline basato su annotazioni, consente regole complesse per la combinazione di argomenti (sequenze, annidamento, argomenti, tipi, ...) ed è ragionevolmente ben documentato.

Per usarlo, aggiungere

<dependency> 
    <groupId>com.github.jankroken</groupId> 
    <artifactId>commandline</artifactId> 
    <version>1.7.0</version> 
</dependency> 

al vostro pom, e dichiarare le opzioni disponibili come segue:

public class CommandOptions { 
    private List<String> commands = null; 
    private boolean parameter = false; 
    private boolean url = true; 
    private boolean help = false; 

    @LooseArguments 
    public void setCommands(List<String> commands) { 
    this.commands = commands; 
    } 

    @LongSwitch("parameter") 
    @Toggle(true) 
    public void setParameter(boolean parameter) { 
    this.parameter=parameter; 
    } 

    @LongSwitch("noURL") 
    @Toggle(false) 
    public void setUrl(boolean url) { 
    this.url = url; 
    } 

    @longSwitch("help") 
    @Toggle(true) 
    public void setHelp(boolean help) { 
    this.help = help; 
    } 

    // getters 
} 

e quindi di analizzare in realtà la linea di comando, fare

public final static void main(String[] args) { 
    try { 
    CommandOptions options = CommandLineParser.parse(CommandOptions.class, args, OptionStyle.SIMPLE); 

    // and then you can pass options to your application logic... 

    } catch 
    ... 
    } 
} 

nota che non contiene (ancora) un testo di guida generato automaticamente. Questo è stato prototipato, ma abortito. È facile generare un testo di aiuto di base per casi semplici, ma per configurazioni più complesse (come le opzioni disponibili per un'applicazione come "trova" o "gcc"), il risultato non sarà carino e probabilmente preferirai controlla tu stesso il layout.