Ricerca nel sito web

Analizza le opzioni dei comandi in Java con commons-cli


Consenti ai tuoi utenti di modificare il modo in cui viene eseguita la tua applicazione Java con le opzioni della riga di comando.

Quando inserisci un comando nel tuo terminale, che si tratti di avviare un'app GUI o semplicemente un'app terminale, ci sono spesso opzioni (a volte chiamate interruttori o flag) che puoi utilizzare per modificare la modalità di esecuzione dell'applicazione. Questo è uno standard impostato dalle specifiche POSIX, quindi è utile per un programmatore Java sapere come rilevare e analizzare le opzioni.

Esistono diversi modi per analizzare le opzioni in Java. La mia preferita è la libreria CLI di Apache Commons, chiamata in breve commons-cli.

Installazione di commons-cli

Se utilizzi un sistema di gestione dei progetti come Maven e un IDE, puoi installare la libreria CLI Apache Commons nelle proprietà del progetto (come pom.xml o una schermata di configurazione in Eclipse o NetBeans).

Se gestisci le librerie manualmente, puoi scaricare la versione più recente dal sito Web di Apache. Diversi file JAR vengono raggruppati insieme. L'unico JAR richiesto è commons-cli-X.Y.jar (dove X e Y sono gli ultimi numeri di versione.) Aggiungi quel JAR al tuo progetto, manualmente o nel tuo IDE, quindi puoi utilizzare nel tuo codice.

Importazione di una libreria nel codice Java

Per utilizzare la libreria commons-cli nel tuo codice, devi importarla. Per questo semplice esempio di analisi delle opzioni, puoi popolare un file chiamato Main.java con il codice minimo standard:

package com.opensource.myoptparser;

import org.apache.commons.cli.*;

public class Main {
    public static void main(String[] args) {
    // code 
    }
}

Ora sei pronto per analizzare le opzioni in Java.

Definizione delle opzioni booleane in Java

La prima cosa che devi fare per analizzare le opzioni è definire le opzioni valide che la tua applicazione può accettare. Utilizza la classe Option (singolare) per creare oggetti opzione e la classe Options (plurale) per tenere traccia di tutte le opzioni che hai creato nel tuo progetto.

Innanzitutto, crea un gruppo per le tue opzioni e chiamalo opzioni secondo la convenzione:

    //code
    Options options = new Options();

Successivamente, definisci le tue opzioni individuali elencando un'opzione breve, un'opzione lunga, un valore booleano predefinito e un messaggio di aiuto. Quindi imposti se l'opzione è richiesta o meno e infine aggiungi l'opzione all'oggetto options, che contiene tutte le tue opzioni. In questo esempio, creo solo un'opzione, chiamata arbitrariamente alpha:

    //define options
    Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
    options.addOption(alpha);

Definizione di opzioni con argomenti in Java

A volte desideri che gli utenti forniscano informazioni diverse da vero o falso insieme a un'opzione. Potresti voler consentire a un utente di fare riferimento a un file di configurazione, a un file di input o a qualsiasi impostazione come una data o un colore. Per questo, utilizzi il metodo builder, creando attributi per un'opzione in base alla sua versione breve (ad esempio, -c è un'opzione breve, --config è un'opzione lunga). Una volta definita, aggiungi la nuova opzione al tuo gruppo opzioni:

    Option config = Option.builder("c").longOpt("config")
        .argName("config")
        .hasArg()
        .required(true)
        .desc("set config file").build();
    options.addOption(config);

Con la funzione builder, puoi impostare la versione breve, la versione lunga, se è richiesta (l'ho impostato su true in questo codice, quindi la mia applicazione non può essere eseguita a meno che questa opzione viene fornita dall'utente al momento dell'avvio), il messaggio di aiuto e così via.

Opzioni di analisi con Java

Con tutte le opzioni possibili definite, ora puoi scorrere gli argomenti forniti dall'utente, controllando se qualche argomento corrisponde all'elenco approvato di opzioni brevi valide. Per fare ciò, crei un'istanza della CommandLine stessa, che contiene tutti gli argomenti forniti dall'utente (opzioni valide e altro). Crei anche un oggetto CommandLineParser, che Chiamo parser nel mio codice, per facilitare l'interazione su questi argomenti. Infine, puoi creare un oggetto HelpFormatter (che io chiamo helper) per fornire automaticamente messaggi utili all'utente quando manca un'opzione richiesta o il - Viene utilizzata l'opzione -help o -h.

    // define parser
    CommandLine cmd;
    CommandLineParser parser = new BasicParser();
    HelpFormatter helper = new HelpFormatter();

Infine, aggiungi alcuni condizionali per analizzare le opzioni fornite dall'utente come input della riga di comando (scoperte e archiviate nella variabile cmd). Questa applicazione di esempio ha due diversi tipi di opzioni, ma in entrambi i casi puoi verificare se l'opzione esiste con il metodo .hasOption più il nome breve dell'opzione. Quando viene rilevata un'opzione, puoi fare tutto ciò che è necessario fare con i dati.

try {
    cmd = parser.parse(options, args);
    if(cmd.hasOption("a")) {
    System.out.println("Alpha activated");
    }

    if (cmd.hasOption("c")) {
    String opt_config = cmd.getOptionValue("config");
    System.out.println("Config set to " + opt_config);
    }
} catch (ParseException e) {
    System.out.println(e.getMessage());
    helper.printHelp("Usage:", options);
    System.exit(0);
}

L'atto dell'analisi genera potenzialmente un errore perché a volte l'opzione -c o --config richiesta potrebbe mancare. In tal caso, viene stampato un messaggio di aiuto e l'applicazione viene immediatamente chiusa. A causa di questo errore (un'eccezione nella terminologia Java), è necessario modificare l'inizio del metodo main per dichiarare una possibile eccezione:

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

L'applicazione di esempio è ora completa.

Metti alla prova il tuo codice

Puoi testare l'applicazione nel tuo IDE modificando i parametri predefiniti passati al tuo codice o semplicemente creare un file JAR ed eseguirlo dal tuo terminale. Il processo per questo varia a seconda del tuo IDE. Fai riferimento alla documentazione dell'IDE, leggi il mio articolo su come creare un JAR o consulta l'articolo di Daniel Oh su come fare lo stesso con Maven.

Innanzitutto, conferma l'eccezione del parser omettendo l'opzione -c o --config richiesta:

$ java -jar dist/myapp.jar                 
Missing required option: c
usage: Usage:
 -a,--alpha             Activate feature alpha
 -c,--config <config>   Set config file

Riprova con le opzioni fornite:

java -jar dist/myantapp.jar --config foo -a
Alpha activated
Config set to foo

Analisi delle opzioni

Includere opzioni per i tuoi utenti è una funzionalità importante per qualsiasi applicazione. Java e Apache Commons semplificano l'operazione.

Ecco il codice dimostrativo completo come riferimento:

package com.opensource.myapp;

import org.apache.commons.cli.*;

public class Main {
    
    /**
     * @param args the command line arguments
     * @throws org.apache.commons.cli.ParseException
     */ 
    public static void main(String[] args) throws ParseException {
        // define options
        Options options = new Options();
        
        Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
        options.addOption(alpha);
        
        Option config = Option.builder("c").longOpt("config")
                .argName("config")
                .hasArg()
                .required(true)
                .desc("Set config file").build();
        options.addOption(config);
     
        // define parser
        CommandLine cmd;
        CommandLineParser parser = new BasicParser();
        HelpFormatter helper = new HelpFormatter();

        try {
            cmd = parser.parse(options, args);
            if(cmd.hasOption("a")) {
                System.out.println("Alpha activated");
            }
          
            if (cmd.hasOption("c")) {
                String opt_config = cmd.getOptionValue("config");
                System.out.println("Config set to " + opt_config);
            }
        } catch (ParseException e) {
            System.out.println(e.getMessage());
            helper.printHelp("Usage:", options);
            System.exit(0);
        }
    }
}

Utilizzo di Java e opzioni

Le opzioni consentono agli utenti di modificare il funzionamento dei comandi. Esistono molti modi per analizzare le opzioni quando si utilizza Java e commons-cli è una soluzione open source robusta e flessibile. Provalo nel tuo prossimo progetto Java.

Articoli correlati: