Apache Commons CLI - Guia rápido

O Apache Commons CLI são os componentes do Apache Commons derivados da API Java e fornecem uma API para analisar argumentos / opções de linha de comando que são passados ​​para os programas. Esta API também permite imprimir ajuda relacionada às opções disponíveis.

O processamento da linha de comando compreende três estágios. Essas etapas são explicadas abaixo -

  • Estágio de Definição
  • Estágio de análise
  • Estágio de interrogação

Estágio de Definição

Na fase de definição, definimos as opções que um aplicativo pode tomar e agir de acordo. Commons CLI fornece a classe Options, que é um contêiner para objetos Option.

// create Options object
Options options = new Options();

// add a option
options.addOption("a", false, "add two numbers");

Aqui, adicionamos um sinalizador de opção a, embora falso como segundo parâmetro, significa que a opção não é obrigatória e o terceiro parâmetro indica a descrição da opção.

Estágio de análise

No estágio de análise, analisamos as opções passadas usando argumentos de linha de comando após criar uma instância do analisador.

//Create a parser
CommandLineParser parser = new DefaultParser();

//parse the options passed as command line arguments
CommandLine cmd = parser.parse( options, args);

Estágio de interrogação

Na fase de interrogação, verificamos se uma determinada opção está presente ou não e, em seguida, processamos o comando de acordo.

//hasOptions checks if option is present or not
if(cmd.hasOption("a")) {
   // add the two numbers
} else if(cmd.hasOption("m")) {
   // multiply the two numbers
}

Neste capítulo, aprenderemos sobre a configuração do ambiente local do Apache Commons CLI e como configurar o caminho do Commons CLI para Windows 2000 / XP, Windows 95/98 / ME etc. Também entenderemos sobre alguns editores Java populares como baixar o arquivo Commons CLI.

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para a linguagem de programação Java, este capítulo o guiará sobre como baixar e configurar o Java em sua máquina. Siga as etapas mencionadas abaixo para configurar o ambiente.

Java SE está disponível gratuitamente no link https://www.oracle.com/java/technologies/oracle-java-archive-downloads.html. Assim, você pode baixar uma versão com base em seu sistema operacional.

Siga as instruções para baixar o Java e execute o .exe para instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir as variáveis ​​de ambiente para apontar para os diretórios de instalação corretos.

Caminho para Windows 2000 / XP

Estamos assumindo que você instalou o Java em c:\Program Files\java\jdk diretório.

  • Clique com o botão direito em 'My Computer' e selecione 'Properties'.

  • Clique no 'Environment variables' botão sob o 'Advanced' aba.

  • Agora, altere o 'Path'variável, de modo que também contenha o caminho para o executável Java. Exemplo, se o caminho está atualmente definido para'C:\WINDOWS\SYSTEM32', então mude seu caminho para ler 'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Caminho para Windows 95/98 / ME

Estamos assumindo que você instalou o Java em c:\Program Files\java\jdk diretório.

  • Edite o 'C:\autoexec.bat' arquivo e adicione a seguinte linha no final - 'SET PATH=%PATH%;C:\Program Files\java\jdk\bin'.

Caminho para Linux, UNIX, Solaris, FreeBSD

A variável de ambiente PATH deve ser definida para apontar, onde os binários Java foram instalados. Consulte a documentação do shell, se tiver problemas para fazer isso.

Por exemplo, se você usar bash como seu shell, então você adicionaria a seguinte linha ao final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editores Java populares

Para escrever seus programas Java, você precisa de um editor de texto. Existem muitos IDEs sofisticados disponíveis no mercado. Mas, por agora, você pode considerar um dos seguintes -

  • Notepad - Na máquina Windows você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial), TextPad.

  • Netbeans- É um IDE Java de código aberto e gratuito que pode ser baixado em www.netbeans.org/index.html .

  • Eclipse- Também é um IDE Java desenvolvido pela comunidade de código aberto eclipse e pode ser baixado de www.eclipse.org .

Baixar arquivo CLI comum

Baixe a versão mais recente do arquivo jar do Apache Common CLI em commons-cli-1.4-bin.zip . No momento de escrever este tutorial, baixamos commons-cli-1.4-bin.zip e o copiamos para a pasta C: \> Apache.

SO Nome do arquivo
janelas commons-cli-1.4-bin.zip
Linux commons-cli-1.4-bin.tar.gz
Mac commons-cli-1.4-bin.tar.gz

Ambiente CLI comum do Apache

Colocou o APACHE_HOMEvariável de ambiente para apontar para o local do diretório base onde o jar do Apache está armazenado em sua máquina. Suponha que extraímos commonscollections4-4.1-bin.zip na pasta Apache em vários sistemas operacionais da seguinte forma -

SO Resultado
janelas Defina a variável de ambiente APACHE_HOME para C: \ Apache
Linux export APACHE_HOME = / usr / local / Apache
Mac export APACHE_HOME = / Library / Apache

Variável CLASSPATH

Colocou o CLASSPATHvariável de ambiente para apontar para o local do jar CLI comum. Suponha que você tenha armazenado commons-cli-1.4.jar na pasta Apache em vários sistemas operacionais da seguinte forma -

SO Resultado
janelas Armazena bots AIML </ Defina a variável de ambiente CLASSPATH para% CLASSPATH%;% APACHE_HOME% \ commons-cli-1.4.jar;.;
Linux export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-cli-1.4.jar :.
Mac export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-cli-1.4.jar :.

Vamos criar um exemplo de aplicativo baseado em console, cujo objetivo é obter a soma dos números passados ​​ou a multiplicação dos números passados ​​com base nas opções usadas.

Crie uma classe java chamada CLITester.

Exemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
public class CLITester {
   public static void main(String[] args) throws ParseException {
      //***Definition Stage***
      // create Options object
      Options options = new Options();
      
      // add option "-a"
      options.addOption("a", false, "add numbers");
      
      // add option "-m"
      options.addOption("m", false, "multiply numbers");

      //***Parsing Stage***
      //Create a parser
      CommandLineParser parser = new DefaultParser();

      //parse the options passed as command line arguments
      CommandLine cmd = parser.parse( options, args);

      //***Interrogation Stage***
      //hasOptions checks if option is present or not
      if(cmd.hasOption("a")) {
         System.out.println("Sum of the numbers: " + getSum(args));
      } else if(cmd.hasOption("m")) {
         System.out.println("Multiplication of the numbers: " + getMultiplication(args));
      }
   }
   public static int getSum(String[] args) {
      int sum = 0;
      for(int i = 1; i < args.length ; i++) {
         sum += Integer.parseInt(args[i]);
      }
      return sum;
   }
   public static int getMultiplication(String[] args) {
      int multiplication = 1;
      for(int i = 1; i < args.length ; i++) {
         multiplication *= Integer.parseInt(args[i]);
      }
      return multiplication;
   }
}

Resultado

Execute o arquivo, passando -a como opção e números para obter a soma dos números como resultado.

java CLITester -a 1 2 3 4 5
Sum of the numbers: 15

Execute o arquivo, passando -m como opção e números para obter a multiplicação dos números como resultado.

java CLITester -m 1 2 3 4 5
Multiplication of the numbers: 120

O objeto Opção é usado para representar a Opção passada ao programa de linha de comando. A seguir estão várias propriedades que um objeto Option possui.

Sr. Não Nome (tipo) & amps; Descrição
1

opt (String)

Sequência de identificação da opção.
2

longOpt (String)

Alias ​​e string de identificação mais descritiva.
3

description (String)

Descrição da função da opção.
4

required (boolean)

Sinalize para verificar se a opção deve aparecer na linha de comando.
5

arg (boolean)

Sinalize para verificar se a opção possui um argumento.
6

args (boolean)

Sinalize para verificar se a opção leva mais de um argumento.
7

optionalArg (boolean)

Sinalize para verificar se o argumento da opção é opcional.
8

argName (String)

Nome do valor do argumento da instrução de uso.
9

valueSeparator (char)

O valor do caractere usado para dividir a string do argumento.
10

type (Object)

Tipo de argumento.
11

value (String)

Valor da opção.
12

values (String[])

Valores da opção.

Uma opção booleana é representada em uma linha de comando por sua presença. Por exemplo, se a opção estiver presente, então seu valor é verdadeiro, caso contrário, é considerado falso. Considere o exemplo a seguir, onde estamos imprimindo a data atual e se o sinalizador -t estiver presente. Então, imprimiremos o horário também.

Exemplo

CLITester.java

import java.util.Calendar;
import java.util.Date;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      options.addOption("t", false, "display time");
      
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);

      Calendar date = Calendar.getInstance();
      int day = date.get(Calendar.DAY_OF_MONTH);
      int month = date.get(Calendar.MONTH);
      int year = date.get(Calendar.YEAR);

      int hour = date.get(Calendar.HOUR);
      int min = date.get(Calendar.MINUTE);
      int sec = date.get(Calendar.SECOND);

      System.out.print(day + "/" + month + "/" + year);
      if(cmd.hasOption("t")) {
         System.out.print(" " + hour + ":" + min + ":" + sec);
      }
   }
}

Resultado

Execute o arquivo sem passar nenhuma opção e veja o resultado.

java CLITester
12/11/2017

Execute o arquivo, passando -t como opção e veja o resultado.

java CLITester
12/11/2017 4:13:10

Uma opção de argumento é representada em uma linha de comando por seu nome e seu valor correspondente. Por exemplo, se a opção estiver presente, o usuário deve passar seu valor. Considere o seguinte exemplo, se estivermos imprimindo logs em algum arquivo, para o qual, queremos que o usuário insira o nome do arquivo de log com a opção de argumento logFile.

Exemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      Option logfile = Option.builder()
         .longOpt("logFile")
         .argName("file" )
         .hasArg()
         .desc("use given file for log" )
         .build();

      options.addOption(logfile);
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);
      
      // has the logFile argument been passed?
      if(cmd.hasOption("logFile")) {
         //get the logFile argument passed
         System.out.println( cmd.getOptionValue( "logFile" ) );
      }
   }
}

Resultado

Execute o arquivo, passando --logFile como opção, nome do arquivo como valor da opção e veja o resultado.

java CLITester --logFile test.log
test.log

Uma opção de propriedades é representada em uma linha de comando por seu nome e suas propriedades correspondentes como sintaxe, que é semelhante ao arquivo de propriedades java. Considere o exemplo a seguir, se estivermos passando opções como -DrollNo = 1 -Dclass = VI -Dname = Mahesh, devemos processar cada valor como propriedades. Vamos ver a lógica de implementação em ação.

Exemplo

CLITester.java

import java.util.Properties;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      Option propertyOption = Option.builder()
         .longOpt("D")
         .argName("property=value" )
         .hasArgs()
         .valueSeparator()
         .numberOfArgs(2)
         .desc("use value for given properties" )
         .build();
      
      options.addOption(propertyOption);
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);
      
      if(cmd.hasOption("D")) {
         Properties properties = cmd.getOptionProperties("D");
         System.out.println("Class: " + properties.getProperty("class"));
         System.out.println("Roll No: " + properties.getProperty("rollNo"));
         System.out.println("Name: " + properties.getProperty("name"));
      }
   }
}

Resultado

Execute o arquivo, passando as opções como pares de valores-chave e veja o resultado.

java CLITester -DrollNo = 1 -Dclass = VI -Dname = Mahesh
Class: VI
Roll No: 1
Name: Mahesh

Um analisador Posix é usado para analisar Posix como argumentos passados. Agora ele está obsoleto e foi substituído por DefaultParser.

Exemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      //Create posix like options
      Options posixOptions = new Options();
      posixOptions.addOption("D", false, "Display");
      posixOptions.addOption("A", false, "Act");
      
      CommandLineParser posixParser = new PosixParser();
      
      CommandLine cmd = posixParser.parse(posixOptions, args);
      
      if( cmd.hasOption("D") ) {
         System.out.println("D option was used.");
      }
      if( cmd.hasOption("A") ) {
         System.out.println("A option was used.");
      }
   }
}

Resultado

Execute o arquivo passando -D -A como opções e veja o resultado.

java CLITester -D -A
D option was used.
A option was used.

Execute o arquivo passando --D como opção e veja o resultado.

java CLITester --D
D option was used.

Um analisador GNU é usado para analisar gnu como argumentos passados. Agora ele está obsoleto e foi substituído por DefaultParser.

Exemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      //Create GNU like options
      Options gnuOptions = new Options();
      gnuOptions.addOption("p", "print", false, "Print")
         .addOption("g", "gui", false, "GUI")
         .addOption("n", true, "Scale");

      CommandLineParser gnuParser = new GnuParser();
      CommandLine cmd = gnuParser.parse(gnuOptions, args);
      
      if( cmd.hasOption("p") ) {
         System.out.println("p option was used.");
      }
      if( cmd.hasOption("g") ) {
         System.out.println("g option was used.");
      }
      if( cmd.hasOption("n") ) {
         System.out.println("Value passed: " + cmd.getOptionValue("n"));
      }
   }
}

Resultado

Execute o arquivo passando -p -g -n 10 como opção e veja o resultado.

java CLITester -p -g -n 10
p option was used.
g option was used.
Value passed: 10

Apache Commons CLI fornece a classe HelpFormatter para imprimir o guia de uso de argumentos de linha de comando. Veja o exemplo abaixo -

Exemplo

CLITester.java

import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
	
      Options options = new Options();
      options.addOption("p", "print", false, "Send print request to printer.")
         .addOption("g", "gui", false, "Show GUI Application")
         .addOption("n", true, "No. of copies to print");
			
      HelpFormatter formatter = new HelpFormatter();
      formatter.printHelp("CLITester", options);
   }
}

Resultado

Execute o arquivo e veja o resultado.

java CLITester
usage: CLITester
-g,--gui Show GUI Application
-n <arg> No. of copies to print
-p,--print Send print request to printer.

Apache Commons CLI fornece a classe HelpFormatter para imprimir a ajuda relacionada aos argumentos da linha de comando. Veja o exemplo.

Exemplo

CLITester.java

import java.io.PrintWriter;

import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      Options options = new Options();
      options.addOption("p", "print", false, "Send print request to printer.")
         .addOption("g", "gui", false, "Show GUI Application")
         .addOption("n", true, "No. of copies to print");
      
      HelpFormatter formatter = new HelpFormatter();

      final PrintWriter writer = new PrintWriter(System.out);
      formatter.printUsage(writer,80,"CLITester", options);
      writer.flush();
   }
}

Resultado

Execute o arquivo e veja o resultado.

java CLITester
usage: CLITester [-g] [-n <arg>] [-p]