Fractionner une chaîne contenant des paramètres de ligne de commande en une chaîne [] en Java

Question

Similaire à this thread for C#, je dois diviser une chaîne contenant les arguments de la ligne de commande dans mon programme pour permettre aux utilisateurs d'exécuter facilement plusieurs commandes. Par exemple, je pourrais avoir la chaîne suivante:

-p /path -d "here's my description" --verbose other args 

Compte tenu de ce qui précède, Java passerait normalement les éléments suivants pour principal:

Array[0] = -p 
Array[1] = /path 
Array[2] = -d 
Array[3] = here's my description 
Array[4] = --verbose 
Array[5] = other 
Array[6] = args 

Je ne ai pas besoin de vous soucier de l'expansion du shell, mais il doit être assez intelligent pour gérer les guillemets simples et doubles et les échappements qui peuvent être présents dans la chaîne. Est-ce que quelqu'un connaît un moyen d'analyser la chaîne comme le shell dans ces conditions?

NOTE: Je ne pas besoin de faire l'analyse syntaxique de la ligne de commande, j'utilise déjà joptsimple pour le faire. Au contraire, je veux rendre mon programme facilement scriptable. Par exemple, je souhaite que l'utilisateur puisse placer dans un seul fichier un ensemble de commandes dont chacune serait valide sur la ligne de commande. Par exemple, ils pourraient taper la commande suivante dans un fichier:

--addUser admin --password Admin --roles administrator,editor,reviewer,auditor 
--addUser editor --password Editor --roles editor 
--addUser reviewer --password Reviewer --roles reviewer 
--addUser auditor --password Auditor --roles auditor 

Ensuite, l'utilisateur courraient mon outil d'administration comme suit:

adminTool --script /path/to/above/file 

main() vous trouverez alors l'option --script et itérer sur les différentes lignes dans le fichier, en séparant chaque ligne dans un tableau que je déclencherais alors à une instance de joptsimple qui serait alors passée dans mon pilote d'application. Joptsimple est livré avec un analyseur qui a un parse method, mais il ne prend en charge qu'un tableau String. De même, les constructeurs GetOpt nécessitent également un String[] - d'où la nécessité d'un analyseur.

Answer 1

Voici une alternative assez facile pour diviser une ligne de texte à partir d'un fichier dans un vecteur d'argument afin que vous pouvez introduire dans votre analyseur d'options:

Ceci est la solution:

public static void main(String[] args) { 
    String myArgs[] = Commandline.translateCommandline("-a hello -b world -c \"Hello world\""); 
    for (String arg:myArgs) 
     System.out.println(arg); 
} 

Le classe magique Commandline fait partie de ant. Donc vous devez soit mettre fourmi sur le classpath ou simplement prendre la classe Commandline car la méthode utilisée est statique.

Answer 2

Moderne Parser d'argument de ligne de commande orienté objet Je suggère mes Java Simple Argument Parser préférés. Et how to use JSAP, cela utilise Groovy à titre d'exemple, mais il en est de même pour Java direct. Il y a aussi args4j qui est à certains égards plus moderne que JSAP car il utilise des annotations, reste à l'écart des choses apache.commons.cli, il est vieux et cassé et très procédural et non-Java-eques dans son API. Mais je retombe toujours sur JSAP parce qu'il est si facile de construire vos propres gestionnaires d'arguments personnalisés.

Il existe de nombreux analyseurs par défaut pour les URL, les numéros, InetAddress, Color, Date, File, Class, et il est très facile d'ajouter les vôtres.

Par exemple ici est un gestionnaire de carte args à énumérations:

import com.martiansoftware.jsap.ParseException; 
import com.martiansoftware.jsap.PropertyStringParser; 

/* 
This is a StringParser implementation that maps a String to an Enum instance using Enum.valueOf() 
*/ 
public class EnumStringParser extends PropertyStringParser 
{ 
    public Object parse(final String s) throws ParseException 
    { 
     try 
     { 
      final Class klass = Class.forName(super.getProperty("klass")); 
      return Enum.valueOf(klass, s.toUpperCase()); 
     } 
     catch (ClassNotFoundException e) 
     { 
      throw new ParseException(super.getProperty("klass") + " could not be found on the classpath"); 
     } 
    } 
} 

et je ne suis pas fan de la programmation de configuration via XML, mais JSAP a une façon très agréable de déclarer les options et les paramètres en dehors de votre code , donc votre code n'est pas jonché de centaines de lignes de configuration qui encombre et obscurcit le vrai code fonctionnel, voir mon lien sur how to use JSAP pour un exemple, moins de code que toutes les autres bibliothèques que j'ai essayées.

C'est une solution de direction à votre problème tel que précisé par votre mise à jour, les lignes dans votre fichier « script » sont toujours commander des lignes. Lisez-les à partir du fichier ligne par ligne et appelez JSAP.parse(String);. J'utilise cette technique pour fournir des fonctionnalités de «ligne de commande» aux applications Web tout le temps. Une utilisation particulière était dans un jeu en ligne massivement multijoueur avec un front office Director/Flash que nous avons activé l'exécution de "commandes" du chat comme et utilisé JSAP sur le backend pour les analyser et exécuter du code basé sur ce qu'il analyse. Tout à fait comme ce que vous voulez faire, sauf que vous lisez les "commandes" d'un fichier au lieu d'un socket. Je jetterais joptsimple et juste utiliser JSAP, vous serez vraiment gâté par son extensibilité puissante.

Answer 3

je suppose que celui-ci vous aidera à:

CLI

Answer 4

J'utilise le Java Getopt port pour le faire.

Answer 5

Si vous ne devez prendre en charge que les systèmes d'exploitation de type UNIX, il existe une solution encore meilleure:. Contrairement à Commandline de fourmi, ArgumentTokenizer de DrJava est plus sh-like: il prend en charge les évasions!

Sérieusement, même quelque chose fou comme sh -c 'echo "\"un'\''kno\"wn\$\$\$'\'' with \$\"\$\$. \"zzz\""' se correctement dans tokenisé [bash, -c, echo "\"un'kno\"wn\$\$\$' with \$\"\$\$. \"zzz\""] (Soit dit en passant, lorsqu'il est exécuté, cette commande affiche "un'kno"wn$$$' with $"$$. "zzz").

Answer 6

/** 
* [code borrowed from ant.jar] 
* Crack a command line. 
* @param toProcess the command line to process. 
* @return the command line broken into strings. 
* An empty or null toProcess parameter results in a zero sized array. 
*/ 
public static String[] translateCommandline(String toProcess) { 
    if (toProcess == null || toProcess.length() == 0) { 
     //no command? no string 
     return new String[0]; 
    } 
    // parse with a simple finite state machine 

    final int normal = 0; 
    final int inQuote = 1; 
    final int inDoubleQuote = 2; 
    int state = normal; 
    final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true); 
    final ArrayList<String> result = new ArrayList<String>(); 
    final StringBuilder current = new StringBuilder(); 
    boolean lastTokenHasBeenQuoted = false; 

    while (tok.hasMoreTokens()) { 
     String nextTok = tok.nextToken(); 
     switch (state) { 
     case inQuote: 
      if ("\'".equals(nextTok)) { 
       lastTokenHasBeenQuoted = true; 
       state = normal; 
      } else { 
       current.append(nextTok); 
      } 
      break; 
     case inDoubleQuote: 
      if ("\"".equals(nextTok)) { 
       lastTokenHasBeenQuoted = true; 
       state = normal; 
      } else { 
       current.append(nextTok); 
      } 
      break; 
     default: 
      if ("\'".equals(nextTok)) { 
       state = inQuote; 
      } else if ("\"".equals(nextTok)) { 
       state = inDoubleQuote; 
      } else if (" ".equals(nextTok)) { 
       if (lastTokenHasBeenQuoted || current.length() != 0) { 
        result.add(current.toString()); 
        current.setLength(0); 
       } 
      } else { 
       current.append(nextTok); 
      } 
      lastTokenHasBeenQuoted = false; 
      break; 
     } 
    } 
    if (lastTokenHasBeenQuoted || current.length() != 0) { 
     result.add(current.toString()); 
    } 
    if (state == inQuote || state == inDoubleQuote) { 
     throw new RuntimeException("unbalanced quotes in " + toProcess); 
    } 
    return result.toArray(new String[result.size()]); 
} 

Answer 7

expansion sur Andreas_D's answer, au lieu de copier, utiliser CommandLineUtils.translateCommandline(String toProcess) de l'excellente bibliothèque Plexus Common Utilities.