CLI Apache Commons - Guide rapide

La CLI Apache Commons sont les composants d'Apache Commons qui sont dérivés de l'API Java et fournissent une API pour analyser les arguments / options de ligne de commande qui sont passés aux programmes. Cette API permet également d'imprimer de l'aide relative aux options disponibles.

Le traitement en ligne de commande comprend trois étapes. Ces étapes sont expliquées ci-dessous -

  • Étape de définition
  • Étape d'analyse
  • Étape d'interrogatoire

Étape de définition

En phase de définition, nous définissons les options qu'une application peut prendre et agir en conséquence. La CLI Commons fournit la classe Options, qui est un conteneur pour les objets Option.

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

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

Ici, nous avons ajouté un indicateur d'option a, tandis que false comme deuxième paramètre, signifie que l'option n'est pas obligatoire et le troisième paramètre indique la description de l'option.

Étape d'analyse

Lors de la phase d'analyse, nous analysons les options passées à l'aide d'arguments de ligne de commande après la création d'une instance d'analyseur.

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

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

Étape d'interrogatoire

Dans l'étape d'interrogation, nous vérifions si une option particulière est présente ou non, puis traitons la commande en conséquence.

//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
}

Dans ce chapitre, nous en apprendrons davantage sur la configuration de l'environnement local d'Apache Commons CLI et comment configurer le chemin de la CLI Commons pour Windows 2000 / XP, Windows 95/98 / ME etc. Nous comprendrons également certains éditeurs Java populaires et comment télécharger l'archive CLI de Commons.

Configuration de l'environnement local

Si vous souhaitez toujours configurer votre environnement pour le langage de programmation Java, ce chapitre vous explique comment télécharger et configurer Java sur votre machine. Veuillez suivre les étapes mentionnées ci-dessous pour configurer l'environnement.

Java SE est disponible gratuitement à partir du lien https://www.oracle.com/java/technologies/oracle-java-archive-downloads.html. Vous pouvez donc télécharger une version basée sur votre système d'exploitation.

Suivez les instructions pour télécharger Java et exécutez le .exe pour installer Java sur votre machine. Une fois que vous avez installé Java sur votre machine, vous devez définir des variables d'environnement pour qu'elles pointent vers les répertoires d'installation corrects.

Chemin pour Windows 2000 / XP

Nous supposons que vous avez installé Java dans c:\Program Files\java\jdk annuaire.

  • Faites un clic droit sur 'My Computer' et sélectionnez 'Properties'.

  • Clique sur le 'Environment variables' bouton sous le 'Advanced' languette.

  • Maintenant, modifiez le 'Path'variable, de sorte qu'il contienne également le chemin d'accès à l'exécutable Java. Exemple, si le chemin est actuellement défini sur'C:\WINDOWS\SYSTEM32', puis changez votre chemin pour lire 'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Chemin pour Windows 95/98 / ME

Nous supposons que vous avez installé Java dans c:\Program Files\java\jdk annuaire.

  • Modifier le 'C:\autoexec.bat' fichier et ajoutez la ligne suivante à la fin - 'SET PATH=%PATH%;C:\Program Files\java\jdk\bin'.

Chemin pour Linux, UNIX, Solaris, FreeBSD

La variable d'environnement PATH doit être définie sur point, où les binaires Java ont été installés. Reportez-vous à la documentation de votre shell, si vous rencontrez des difficultés pour cela.

Exemple, si vous utilisez bash comme shell, vous ajouteriez la ligne suivante à la fin de votre '.bashrc: export PATH = / path / to / java: $ PATH'

Éditeurs Java populaires

Pour écrire vos programmes Java, vous avez besoin d'un éditeur de texte. Il existe de nombreux IDE sophistiqués disponibles sur le marché. Mais pour l'instant, vous pouvez envisager l'un des éléments suivants -

  • Notepad - Sur la machine Windows, vous pouvez utiliser n'importe quel éditeur de texte simple comme Notepad (recommandé pour ce tutoriel), TextPad.

  • Netbeans- Il s'agit d'un IDE Java open-source et gratuit qui peut être téléchargé sur www.netbeans.org/index.html .

  • Eclipse- Il s'agit également d'un IDE Java développé par la communauté open source eclipse et peut être téléchargé sur www.eclipse.org .

Télécharger l'archive CLI commune

Téléchargez la dernière version du fichier jar Apache Common CLI à partir de commons-cli-1.4-bin.zip . Au moment de la rédaction de ce tutoriel, nous avons téléchargé commons-cli-1.4-bin.zip et l'avons copié dans le dossier C: \> Apache.

OS Nom de l'archive
les fenêtres commons-cli-1.4-bin.zip
Linux commons-cli-1.4-bin.tar.gz
Mac commons-cli-1.4-bin.tar.gz

Environnement CLI commun Apache

Met le APACHE_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où le fichier jar Apache est stocké sur votre machine. Supposons que nous ayons extrait commonscollections4-4.1-bin.zip dans le dossier Apache sur divers systèmes d'exploitation comme suit -

OS Production
les fenêtres Définissez la variable d'environnement APACHE_HOME sur C: \ Apache
Linux export APACHE_HOME = / usr / local / Apache
Mac export APACHE_HOME = / Bibliothèque / Apache

Variable CLASSPATH

Met le CLASSPATHvariable d'environnement pour pointer vers l'emplacement du fichier jar CLI commun. Supposons que vous ayez stocké commons-cli-1.4.jar dans le dossier Apache sur divers systèmes d'exploitation comme suit -

OS Production
les fenêtres Stocke les bots AIML </ Définissez la variable d'environnement CLASSPATH sur% 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 :.

Créons un exemple d'application basée sur une console, dont le but est d'obtenir soit la somme des nombres passés, soit la multiplication des nombres passés en fonction des options utilisées.

Créez une classe Java nommée CLITester.

Exemple

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;
   }
}

Production

Exécutez le fichier en passant -a comme option et des nombres pour obtenir la somme des nombres comme résultat.

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

Exécutez le fichier, en passant -m comme option et des nombres pour obtenir la multiplication des nombres comme résultat.

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

L'objet Option est utilisé pour représenter l'option transmise au programme de ligne de commande. Voici différentes propriétés qu'un objet Option possède.

Sr.Non Nom (Type) & amps; La description
1

opt (String)

Chaîne d'identification de l'option.
2

longOpt (String)

Alias ​​et chaîne d'identification plus descriptive.
3

description (String)

Description de la fonction de l'option.
4

required (boolean)

Indicateur pour vérifier si l'option doit apparaître sur la ligne de commande.
5

arg (boolean)

Indicateur pour vérifier si l'option prend un argument.
6

args (boolean)

Indicateur pour vérifier si l'option prend plus d'un argument.
sept

optionalArg (boolean)

Indicateur pour vérifier si l'argument de l'option est facultatif.
8

argName (String)

Nom de la valeur de l'argument pour l'instruction d'utilisation.
9

valueSeparator (char)

Valeur de caractère utilisée pour diviser la chaîne d'argument.
dix

type (Object)

Type d'argument.
11

value (String)

Valeur d'option.
12

values (String[])

Valeurs de l'option.

Une option booléenne est représentée sur une ligne de commande par sa présence. Par exemple, si l'option est présente, alors sa valeur est true, sinon, elle est considérée comme false. Prenons l'exemple suivant, où nous imprimons la date actuelle et si l'indicateur -t est présent. Ensuite, nous imprimerons également l'heure.

Exemple

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);
      }
   }
}

Production

Exécutez le fichier sans passer aucune option et voyez le résultat.

java CLITester
12/11/2017

Exécutez le fichier, tout en passant -t comme option et voyez le résultat.

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

Une option Argument est représentée sur une ligne de commande par son nom et sa valeur correspondante. Par exemple, si l'option est présente, l'utilisateur doit transmettre sa valeur. Prenons l'exemple suivant, si nous imprimons des journaux dans un fichier, pour lequel nous voulons que l'utilisateur saisisse le nom du fichier journal avec l'option d'argument logFile.

Exemple

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" ) );
      }
   }
}

Production

Exécutez le fichier, en passant --logFile comme option, nom du fichier comme valeur de l'option et voyez le résultat.

java CLITester --logFile test.log
test.log

Une option Propriétés est représentée sur une ligne de commande par son nom et ses propriétés correspondantes comme la syntaxe, qui est similaire au fichier de propriétés java. Prenons l'exemple suivant, si nous transmettons des options telles que -DrollNo = 1 -Dclass = VI -Dname = Mahesh, nous devons traiter chaque valeur comme des propriétés. Voyons la logique de mise en œuvre en action.

Exemple

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"));
      }
   }
}

Production

Exécutez le fichier, tout en passant les options sous forme de paires clé / valeur et voyez le résultat.

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

Un analyseur Posix est utilisé pour analyser Posix comme les arguments passés. Il est maintenant obsolète et est remplacé par DefaultParser.

Exemple

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.");
      }
   }
}

Production

Exécutez le fichier en passant -D -A comme options et voyez le résultat.

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

Exécutez le fichier en passant --D comme option et voyez le résultat.

java CLITester --D
D option was used.

Un analyseur GNU est utilisé pour analyser gnu comme les arguments passés. Il est maintenant obsolète et est remplacé par DefaultParser.

Exemple

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"));
      }
   }
}

Production

Exécutez le fichier en passant -p -g -n 10 comme option et voyez le résultat.

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

La CLI Apache Commons fournit la classe HelpFormatter pour imprimer le guide d'utilisation des arguments de ligne de commande. Voir l'exemple ci-dessous -

Exemple

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);
   }
}

Production

Exécutez le fichier et voyez le résultat.

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

La CLI Apache Commons fournit la classe HelpFormatter pour imprimer l'aide relative aux arguments de ligne de commande. Voir l'exemple.

Exemple

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();
   }
}

Production

Exécutez le fichier et voyez le résultat.

java CLITester
usage: CLITester [-g] [-n <arg>] [-p]
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved