Análise de linha de comando em Java

Este artigo apresenta como executar a análise de linha de comando em java.

Análise de linha de comando em Java

Às vezes, para executar programas Java, exigimos algumas entradas básicas antes de executar o programa. Normalmente, essas entradas são fornecidas por argumentos de linha de comando. Em java, os argumentos da linha de comando são salvos em String[] args dentro da função main().

Para aceitar argumentos do terminal / prompt de comando, precisamos definir Opções no programa Java. Cada argumento de linha de comando que você passa precisa ser armazenado em Opções. No exemplo de código abaixo, as duas opções criadas implicam o fenômeno de copiar e colar. Veja a explicação.

import org.apache.commons.cli.*;
public class Main {
  public static void main(String[] args) throws Exception {
    Options options = new Options(); // Options Arguments which are Acceptable By Program.
    Option source = new Option("s", "source", true, "source file path");
    source.setRequired(true);
    options.addOption(source);
    Option destination = new Option("d", "Destination", true, "Destination file Path");
    destination.setRequired(true);
    options.addOption(destination);

    CommandLineParser parser = new BasicParser();
    // use to read Command Line Arguments
    HelpFormatter formatter = new HelpFormatter(); // // Use to Format
    CommandLine cmd = null;

    try {
      cmd = parser.parse(
          options, args); // it will parse according to the options and parse option value
    } catch (ParseException e) {
      System.out.println(e.getMessage());
      formatter.printHelp("utility-name", options);

      System.exit(1);
    }

    String argument1 = cmd.getOptionValue("source");
    String argument2 = cmd.getOptionValue("Destination");

    System.out.println(argument1);
    System.out.println(argument2);
  }
}

Existem duas opções criadas no programa acima. Um é a origem e o outro é o destino. Ao criar a opção de origem, atribuímos seu argumento de curto prazo como s e nomeamos sua origem. O s é um comando que obtém o valor dos argumentos de origem. Ao executar o programa, o usuário deve usar -s como um comando seguido de seu valor. Veja a saída abaixo. Também definimos o requisito como verdadeiro e fornecemos a descrição como um caminho de arquivo de origem. Posteriormente, adicionamos este argumento de opção de origem dentro de Opções. Da mesma forma, com a opção destino, realizamos a mesma coisa com valores diferentes.

Quando se trata de analisar essas duas opções, criamos um objeto de CommandLineParser. Com a ajuda de HelpFormatter, formatamos os argumentos do comando se precisássemos exibir a exceção.

Dentro do método try...catch, usando parse() para analisar as opções de parâmetros e args. Então, simplesmente obtemos os valores da opção usando getOptionValue() e passamos o nome das opções entre parênteses.

Estamos simplesmente imprimindo os valores. Por outro lado, você pode executar programas diferentes usando essa abordagem.

Para executar o programa, temos que usar os seguintes comandos.

javac
    - cp 'org.apache.commons.cli-1.2.0.jar' Main.java

          java
    - cp 'org.apache.commons.cli-1.2.0.jar' Main.java - s 'D://textfile.txt'
    - d 'D://DuplicatFolder//'

Aqui, -s e -d são os comandos. Ambos são seguidos por seus valores, respectivamente. Por exemplo, no programa acima, colocaremos o caminho de origem para s e o destino para d.

O programa acima fornecerá a seguinte saída.

D : // textfile.txt
    D: // DuplicatFolder//