586

जावा में कमांड लाइन तर्क को पार्स करने का एक अच्छा तरीका क्या है?

4

Args4j और इसका उपयोग करने के लिए एक विस्तृत उदाहरण देखें: martin-thoma.com/how-to-parse-command-line-arguments-in-java

— मार्टिन थोमा

ऐसा लगता है कि मैं इस पार्टी के लिए बहुत देर हो चुकी हूं, लेकिन मैंने जावा के लिए एक कमांड-लाइन तर्क हैंडलर लिखा और इसे GitHub: MainArgsHandler पर डाल दिया । जैसा कि थ्रेड को बंद किया जा रहा है, मुझे लगता है कि यह एक बहुत ही उपयोगी थ्रेड है, लेकिन इसे संभवतः सामान्य प्रोग्रामिंग चर्चा के लिए स्टैक एक्सचेंज प्रोग्रामर साइट पर माइग्रेट किया जाना चाहिए।

— Bobulous

@RedGlyph - ऐसा लगता है कि SO / SE को अपने नियमों को सरल बनाने की आवश्यकता है। सवाल यह होना चाहिए था How to parse java command line arguments?:। लेकिन कोई भी वास्तव में ऐसा करने के लिए कोड लिखना नहीं चाहता है, बल्कि एक उपकरण का उपयोग करना चाहिए। लेकिन औजारों और पसंदों की खोज रचनात्मक नहीं है :(

— AlikElzin-kilaka

6

फिर से खोलने के लिए वोट किया गया। @AlikElzin: वास्तव में, उन्हें अपनी मॉडरेटिंग प्रक्रिया की समीक्षा करने की आवश्यकता है। मुझे संदेह है कि इतने सारे प्रश्नों को बंद करने के लिए एक बैज है, और यह है कि यह चाहने वाले मध्यस्थों को अति उत्साही होने का लालच दे रहा है।

— 17

8

यह प्रश्न खराब / वन-लाइन उत्तर और उपकरण अनुशंसाओं के लिए एक हनीपोट है। इसे बंद ही रहना चाहिए।

— JAL

405

ये देखें:

या अपना खुद का रोल करें:

http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

उदाहरण के लिए, यह है कि आप commons-cli2 स्ट्रिंग तर्क को पार्स करने के लिए कैसे उपयोग करते हैं:

import org.apache.commons.cli.*;

public class Main {


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

        Options options = new Options();

        Option input = new Option("i", "input", true, "input file path");
        input.setRequired(true);
        options.addOption(input);

        Option output = new Option("o", "output", true, "output file");
        output.setRequired(true);
        options.addOption(output);

        CommandLineParser parser = new DefaultParser();
        HelpFormatter formatter = new HelpFormatter();
        CommandLine cmd;

        try {
            cmd = parser.parse(options, args);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
            formatter.printHelp("utility-name", options);

            System.exit(1);
        }

        String inputFilePath = cmd.getOptionValue("input");
        String outputFilePath = cmd.getOptionValue("output");

        System.out.println(inputFilePath);
        System.out.println(outputFilePath);

    }

}

कमांड लाइन से उपयोग:

$> java -jar target/my-utility.jar -i asd                                                                                       
Missing required option: o

usage: utility-name
 -i,--input <arg>    input file path
 -o,--output <arg>   output file

— विन्को वर्सलोविक
स्रोत

40

ध्यान दें कि कई अन्य अपाचे पुस्तकालयों के विपरीत, अपाचे सीएलआई की कोई निर्भरता नहीं है।

— व्लादिमीर Dyuzhev

9

कई अपाचे-कॉमन्स परियोजनाओं के लिए एक नकारात्मक पहलू यह है कि वे कम और कम आवागमन प्राप्त करते हैं और अंततः समाप्त हो जाते हैं।

— ब्रेट रयान

4

Apache CLI प्रोजेक्ट के लिए "उपयोग परिदृश्य" पृष्ठ यहाँ है, इसका उपयोग कैसे जल्दी से शुरू करने के लिए विस्तार से किया गया है: commons.apache.org/cli/usage.html

— ब्रैड पार्क्स

मुझे नहीं लगता कि Args4J / JCommander जैसा कोई है जहां आप एक इंटरफ़ेस को परिभाषित करते हैं और विधियों को एनोटेट करते हैं? मैं कभी भी उन वर्गों के शौकीन नहीं बन पाया, जो निजी क्षेत्रों में "डरावना इनिशियलाइज़ेशन" ...

— ट्रेकजैक

5

@RemkoPopma आपकी पिकॉक लाइब्रेरी बस बहुत अच्छी लगती है और इसे करने के लिए धन्यवाद, वास्तव में। लेकिन मैं समझता हूं कि आप यहां और अन्य पोस्टों में क्या कर रहे हैं (स्वीकार किए गए उत्तरों को संपादित करें और अपनी लाइब्रेरी को इसके शीर्ष पर बढ़ावा दें, यह खुलासा किए बिना कि यह पोस्ट के मूल लेखक से संपादित नहीं है और यह आपके काम का है) आपकी मॉडरेशन शक्तियों का एक भयानक भयानक दुरुपयोग है। इसे अन्य मॉड्स पर फ़्लैग करना।

— अलेक्जेंडर मालाखोव

312

हाल ही में JCommander पर एक नज़र डालें ।

मैंने इसे बनाया। मुझे प्रश्न या सुविधा अनुरोध प्राप्त करने में खुशी हो रही है।

— सिडरिक बीस्ट
स्रोत

7

खुशी है कि आप JCommander :-) को पसंद करते हैं कि मैं झंडे के साथ कैसे व्यवहार किया जाता है, इसलिए आपको बहुत अधिक अर्थ जोड़ने की ज़रूरत नहीं है, इसलिए आपको केवल उन एनोटेशन में समानार्थी शब्द जोड़ने की ज़रूरत है: @ पैरामीटर (नाम = {"-h", "- -help "}) मुझे लगा कि यह एक उचित समझौता है।

— सेड्रिक बीस्ट

14

महान उपकरण। शक्तिशाली, लचीला, और आपको कष्टप्रद, पारंपरिक विकल्प पार्सर्स से निपटना नहीं है।

— इयानगिलम

3

हाँ, मुझे लगता है कि मैं अपने कमांड लाइन तर्क पार्सर लिखा होगा ठीक उसी तरह जिस तरह से आप JCommander लिखा था। अच्छा कार्य।

— एसआरजी

9

@CedricBeust, यह एक शानदार पुस्तकालय है, मैं आपको बहुत-बहुत धन्यवाद देता हूं। चूँकि हम अपने स्वयं के आर्ग्स वर्गों को परिभाषित कर सकते हैं जो कि पुस्तकालयों के वर्ग पर किसी निर्भरता के बिना इसे पास किया जा सकता है जो इसे बेहद लचीला बनाता है।

— ब्रेट रायन

2

पानी से प्रतियोगिता को उड़ा देता है!

— मार्कस जूनियस ब्रूटस

235

मैं जावा सीएलआई पार्सर्स की एक सूची को बनाए रखने की कोशिश कर रहा हूं ।

एयरलाइन
- सक्रिय कांटा: https://github.com/rvesse/airline
argparse4j
argparser
args4j
clajr
CLI-पार्सर
CmdLn
कमांड लाइन
DocOpt.java
डॉल्फिन हो जाओ
DPML CLI (जकार्ता कॉमन्स CLI2 कांटा)
डॉ। माथियास लक्स
जकार्ता कॉमन्स सीएलआई
jargo
jargp
jargs
जावा-getopt
jbock
JCLAP
jcmdline
jcommander
jcommando
जौहरी (मेरे द्वारा लिखित)
सरल है
jsap
naturalcli
ऑब्जेक्ट मेंटर सीएलआई लेख (रीफैक्टरिंग और टीडीडी के बारे में अधिक)
पार्स-cmd
ritopt
Rop
TE- कोड कमांड
picocli में ANSI रंगीन उपयोग सहायता और स्वतः पूर्ण है

— lexicalscope
स्रोत

7

@ बीन फ्लिन हे, वहाँ कुछ काफी आश्चर्यजनक और दिलचस्प आकार के पहिये हैं। मुझे लगता है कि इसका एक सबसे हानिरहित तरीका है यह दिखाने के लिए कि इसे करने के लिए एक से अधिक तरीके हैं!

— lexicalscope

14

मैं नोट करता हूं जोप्ट सिंपल का लेखक बहुत समान सूची रखता है! हमें इन सूचियों को एक तालिका में बदलने के लिए पाठ की आवश्यकता है, सुविधाओं और रुचि के बिंदुओं को सूचीबद्ध करना, ताकि हम गरीब उपयोगकर्ता एक सूचित विकल्प बना सकें।

— टॉम एंडरसन

1

मैंने Rop - github.com/ryenus/rop का निर्माण किया है , जिसमें एनोटेशन आधारित सॉल्यूशन की सुविधा है, जिसे आप कमांड और विकल्प के माध्यम से सादे वर्गों और क्षेत्रों के माध्यम से घोषित करते हैं, कमांड लाइन पार्सर्स के निर्माण के लिए बहुत अधिक घोषणात्मक तरीका। यह ऐप्स की तरह Git (सिंगल-cmd) या Maven (मल्टी-cmd) बना सकता है।

— रीनस

8

सूचीबद्ध अधिकांश परियोजनाएं अनिवार्य रूप से परित्याग हैं। सूची के माध्यम से जाने के बाद मैं कहूंगा कि बड़े हिटर, कि सक्रिय रूप से बनाए रखा गया है और लोकप्रिय है, कॉमन्स-क्ली, जेंकैंडर, args4j, jopt-simple और picocli लगता है। Argparse4j और cli-parser जैसी चीजों के लेखकों के लिए माफी - मुझे कुछ हद तक मनमानी रैंकिंग बनानी थी, और शीर्ष पांच को चुना, स्पष्ट रूप से सूची में अन्य परियोजनाएं लोकप्रिय हैं और अभी भी सक्रिय विकास के तहत हैं।

— जॉर्ज हॉकिन्स

2

मैं किसी को चुनौती देता हूं कि वह प्रत्येक पार्सर के अंतिम स्थिर रिलीज की तारीख को शामिल करे।

— स्लेज

50

यह 2020 है, कॉमन्स CLI से बेहतर करने का समय ... :-)

क्या आपको अपनी स्वयं की जावा कमांड लाइन पार्सर का निर्माण करना चाहिए, या एक पुस्तकालय का उपयोग करना चाहिए?

कई छोटे उपयोगिता-जैसे एप्लिकेशन संभवतः अतिरिक्त बाहरी निर्भरता से बचने के लिए अपनी स्वयं की कमांड लाइन पार्सिंग को रोल करते हैं। पिकॉकली एक दिलचस्प विकल्प हो सकता है।

पिकोली एक आधुनिक पुस्तकालय और शक्तिशाली, उपयोगकर्ता के अनुकूल, आसानी से ग्रैल्वीएम-सक्षम कमांड लाइन एप्लिकेशन के निर्माण के लिए रूपरेखा है। यह 1 स्रोत फ़ाइल में रहता है इसलिए एक निर्भरता जोड़ने से बचने के लिए ऐप्स इसे स्रोत के रूप में शामिल कर सकते हैं।

यह रंग, स्वत: पूर्णता, उप-क्रम, और बहुत कुछ का समर्थन करता है। जावा में लिखा, ग्रूवी, कोटलिन, स्काला, आदि से प्रयोग करने योग्य।

विशेषताएं:

एनोटेशन आधारित: घोषणात्मक , दोहराव से बचा जाता है और प्रोग्रामर इरादे को व्यक्त करता है
सुविधाजनक: उपयोगकर्ता इनपुट को पार्स करें और कोड की एक पंक्ति के साथ अपना व्यावसायिक तर्क चलाएं
सब कुछ टाइप किया - कमांड लाइन विकल्प के साथ-साथ स्थितीय पैरामीटर
POSIX क्लस्टर किए गए छोटे विकल्प ( <command> -xvfInputFileसाथ ही <command> -x -v -f InputFile)
दानेदार नियंत्रण : एक एरिटी मॉडल जो मापदंडों की एक न्यूनतम, अधिकतम और परिवर्तनीय संख्या की अनुमति देता है, जैसे "1..*","3..5"
उपखंड (मनमानी गहराई के लिए घोंसले के शिकार हो सकते हैं)
फ़ीचर से भरपूर : कंपोज़ेबल अरग ग्रुप्स, स्प्लिट कोटेड आर्ग्स, रिपीटेबल सबकमबैंड्स और भी कई
उपयोगकर्ता के अनुकूल : उपयोग सहायता संदेश रंगों का उपयोग करता है इसके विपरीत महत्वपूर्ण तत्व जैसे विकल्प नाम के उपयोग से उपयोगकर्ता पर संज्ञानात्मक को कम करने में मदद मिलती है
अपने एप्लिकेशन को एक GraalVM मूल छवि के रूप में वितरित करें
जावा 5 और उच्चतर के साथ काम करता है
व्यापक और सावधानीपूर्वक प्रलेखन

उपयोग सहायता संदेश एनोटेशन (प्रोग्रामिंग के बिना) के साथ अनुकूलित करना आसान है। उदाहरण के लिए:

( स्रोत )

मैं यह दिखाने के लिए एक और स्क्रीनशॉट जोड़ने का विरोध नहीं कर सका कि संदेशों का उपयोग क्या संभव है। उपयोग सहायता आपके एप्लिकेशन का चेहरा है, इसलिए रचनात्मक रहें और मज़े करें!

डिस्क्लेमर: मैंने पिकॉकली बनाई। प्रतिक्रिया या प्रश्न बहुत स्वागत करते हैं।

— रेम्को पोपमा
स्रोत

5

प्रतिभाशाली! यह शर्म की बात है कि इस जवाब को नीचे दफन किया गया है। Apache Commons CLI क्रिया, छोटी गाड़ी है, और इसे लंबे समय में अपडेट नहीं किया गया है। और मैं Google के CLI पार्सर का उपयोग नहीं करना चाहता क्योंकि मैं अपने कमांड लाइन तर्क उपयोग इतिहास के आधार पर लक्षित विज्ञापन नहीं चाहता हूं। लेकिन यह वैसे भी पिकॉकली की तुलना में थोड़ा अधिक वर्बोज़ लगता है।

— पीट

2

मैं यहां @Pete हूं ... मैं ऊपर की सूची के माध्यम से गया था जो नीचे दफन इस समय के साथ पूरी तरह से बेकार था। यह एक मील द्वारा शीर्ष उत्तर होना चाहिए। अच्छा काम! मेरी आवश्यकताओं को अपाचे सीएलआई या इनमें से अधिकांश अन्य पार्सर द्वारा कवर नहीं किया जा सकता है। वे पिकॉकली के लिए भी चुनौती दे रहे थे, लेकिन यह मुझे उस वाक्य रचना / व्यवहार के लिए निकटतम चीज़ देने में सक्षम था जिसे मैं चाहता था और जो मुझे वास्तव में ज़रूरत थी उसे हैक करने के लिए पर्याप्त लचीला था। एक बोनस के रूप में यह एएनएसआई सामान के लिए बहुत अच्छा लग रहा है।

— Shai Almog

@ShaiAlmog शीर्ष-मतदान का उत्तर 10 साल पुराना और पुराना है। मैं मानता हूं कि 2019 में कॉमन्स सीएलआई की सिफारिश करना आईएमएचओ को भ्रमित करना है। कृपया शीर्ष उत्तर को फिर से लिखने के लिए इसे और अधिक अद्यतित करने पर विचार करें ।

— रेमको पोपमा

मैं देख रहा हूँ कि आपने पहले से ही कोशिश की है, मुझे नहीं लगता कि यह मेरे लिए भी काम करेगा ... यदि आपने 1Picoli जैसा नाम चुना होता तो हम 3 उत्तर को वर्णानुक्रम से सॉर्ट कर सकते थे; ;-)

— Shai Almog

मुझे लगता है कि मेरे बदलाव का कारण यह था कि मैंने अपनी संबद्धता का खुलासा नहीं किया (क्योंकि मैं लेखक हूं)। अन्य लोगों के पास वह मुद्दा नहीं होना चाहिए।

— रेमको पोपमा

23

मैंने जोप्ट का उपयोग किया है और इसे काफी उपयोगी पाया है: http://jopt-simple.sourceforge.net/

फ्रंट पेज लगभग 8 वैकल्पिक पुस्तकालयों की एक सूची भी प्रदान करता है, उन्हें देखें और अपनी आवश्यकताओं के अनुसार सबसे अधिक चुनें।

— GaryF
स्रोत

21

किसी ने मुझे हाल ही में args4j को इंगित किया जो एनोटेशन आधारित है। मुझे वास्तव में यह पसंद है!

— आंद्रे
स्रोत

1

Args4J के लिए +1! अत्यधिक मानव-अनुकूल, लचीला, और समझने योग्य। मुझे लगता है कि यह जावा सीएलआई ऐप्स बनाने के लिए मानक गो-टू लाइब्रेरी होना चाहिए।

— जरीन 18’13

ग्रेट कि यह अनऑर्डिनेट (फ़ील्ड ऑर्डर द्वारा सॉर्ट किया गया) उपयोग प्रिंट संभाल सकता है, जो कि JCommander नहीं कर सकता है, और यह अधिक लचीला है।

— डैनियल हारी

@ डैनियल हेर्री सिर्फ जानकारी के लिए, जेकोनेंडर (कुछ देर 2017 के अंत में)

— नाथन

9

यह Google की कमांड लाइन है जिसे लाइब्रेरी को Bazel प्रोजेक्ट के हिस्से के रूप में ओपन-सोर्स किया गया है। व्यक्तिगत रूप से मुझे लगता है कि यह वहां से सबसे अच्छा है, और अपाचे सीएलआई की तुलना में बहुत आसान है।

https://github.com/pcj/google-options

स्थापना

Bazel

maven_jar(
    name = "com_github_pcj_google_options",
    artifact = "com.github.pcj:google-options:jar:1.0.0",
    sha1 = "85d54fe6771e5ff0d54827b0a3315c3e12fdd0c7",
)

Gradle

dependencies {
  compile 'com.github.pcj:google-options:1.0.0'
}

Maven

<dependency>
  <groupId>com.github.pcj</groupId>
  <artifactId>google-options</artifactId>
  <version>1.0.0</version>
</dependency>

प्रयोग

एक वर्ग बनाएं जो OptionsBaseआपके @Option(ओं) को विस्तारित और परिभाषित करता है ।

package example;

import com.google.devtools.common.options.Option;
import com.google.devtools.common.options.OptionsBase;

import java.util.List;

/**
 * Command-line options definition for example server.
 */
public class ServerOptions extends OptionsBase {

  @Option(
      name = "help",
      abbrev = 'h',
      help = "Prints usage info.",
      defaultValue = "true"
    )
  public boolean help;

  @Option(
      name = "host",
      abbrev = 'o',
      help = "The server host.",
      category = "startup",
      defaultValue = ""
  )
  public String host;

  @Option(
    name = "port",
    abbrev = 'p',
    help = "The server port.",
    category = "startup",
    defaultValue = "8080"
    )
    public int port;

  @Option(
    name = "dir",
    abbrev = 'd',
    help = "Name of directory to serve static files.",
    category = "startup",
    allowMultiple = true,
    defaultValue = ""
    )
    public List<String> dirs;

}

तर्कों को पार्स करें और उनका उपयोग करें।

package example;

import com.google.devtools.common.options.OptionsParser;
import java.util.Collections;

public class Server {

  public static void main(String[] args) {
    OptionsParser parser = OptionsParser.newOptionsParser(ServerOptions.class);
    parser.parseAndExitUponError(args);
    ServerOptions options = parser.getOptions(ServerOptions.class);
    if (options.host.isEmpty() || options.port < 0 || options.dirs.isEmpty()) {
      printUsage(parser);
      return;
    }

    System.out.format("Starting server at %s:%d...\n", options.host, options.port);
    for (String dirname : options.dirs) {
      System.out.format("\\--> Serving static files at <%s>\n", dirname);
    }
  }

  private static void printUsage(OptionsParser parser) {
    System.out.println("Usage: java -jar server.jar OPTIONS");
    System.out.println(parser.describeOptions(Collections.<String, String>emptyMap(),
                                              OptionsParser.HelpVerbosity.LONG));
  }

}

https://github.com/pcj/google-options

— पॉल
स्रोत

हाय पॉल। जब मैं आपके उत्तर या आपके प्रोजेक्ट डॉक्यूमेंटेशन को पढ़ता हूं तो मुझे यह पता नहीं होता है कि यह किस तरह की कमांड लाइन है। उदाहरण के लिए, आप कुछ ऐसा प्रदान कर सकते हैं myexecutable -c file.json -d 42 --outdir ./out। और मैं यह नहीं देखता कि आप छोटे / लंबे / विवरण विकल्पों को कैसे परिभाषित करते हैं ... चीयर्स

— ओलिवर

8

कॉमन्स सीएलआई परियोजना पर नज़र डालें, वहां बहुत सारी अच्छी चीजें हैं।

— मार्क नोवाकोव्स्की
स्रोत

8

यीप।

मुझे लगता है कि आप कुछ इस तरह की तलाश कर रहे हैं: http://commons.apache.org/cli

अपाचे कॉमन्स सीएलआई पुस्तकालय कमांड लाइन इंटरफेस के प्रसंस्करण के लिए एक एपीआई प्रदान करता है।

— OscarRyz
स्रोत

7

मुझे पता है कि यहां ज्यादातर लोग 10 मिलियन कारणों से जा रहे हैं कि वे मेरे रास्ते को क्यों नापसंद करते हैं, लेकिन कभी नहीं। मैं चीजों को सरल रखना पसंद करता हूं, इसलिए मैं बस '=' का उपयोग करके मूल्य से कुंजी को अलग करता हूं और उन्हें किसी HashMap में संग्रहीत करता हूं जैसे:

Map<String, String> argsMap = new HashMap<>();
for (String arg: args) {
    String[] parts = arg.split("=");
    argsMap.put(parts[0], parts[1]);
}

आप हमेशा उन तर्कों के साथ एक सूची बनाए रख सकते हैं जिनकी आप अपेक्षा कर रहे हैं, उपयोगकर्ता को इस मामले में मदद करने के लिए कि वह एक तर्क भूल गया या एक गलत इस्तेमाल किया ... हालाँकि, यदि आप बहुत सारी सुविधाएँ चाहते हैं, तो यह समाधान वैसे भी आपके लिए नहीं है।

— जॉन कॉमरेलस
स्रोत

7

शायद ये

जावा के लिए JArgs कमांड लाइन विकल्प पार्सिंग सूट - यह छोटा प्रोजेक्ट जावा प्रोग्रामर के उपयोग के लिए एक सुविधाजनक, कॉम्पैक्ट, पूर्व-पैक और व्यापक रूप से प्रलेखित सुइट ऑफ कमांड लाइन विकल्प पार्सर प्रदान करता है। प्रारंभ में, GNU- शैली 'गेटटॉप' के साथ संगत पार्सिंग प्रदान की जाती है।
जावा के लिए अंतिम विकल्प पार्सर - हालांकि, कई कमांड लाइन विकल्प मानकों को पूर्व निर्धारित किया गया है, रिटॉप ऑप्ट पैकेज में निर्धारित सम्मेलनों का अनुसरण करता है।

— mepcotterell
स्रोत

6

कूदने के बिंदु के रूप में आपको नाखुश का यह मेटा-लेख दिलचस्प लग सकता है:

http://furiouspurpose.blogspot.com/2008/07/command-line-parsing-libraries-for-java.html

— एलेक्स मिलर
स्रोत

2

वह लड़का बहुत बेकार है "कॉमन्स सीएलआई जाहिर तौर पर यहां के विकल्पों में सबसे पुराना है, और टिप्पणीकारों से बहुत सम्मान नहीं मिलता है, इसलिए मैंने वास्तव में इसे बहुत करीब से नहीं देखा ..", लेकिन वैसे भी लिंक के लिए धन्यवाद।

— जेम्स मैकमोहन

5

मैंने एक और लिखा: http://argparse4j.sourceforge.net/

Argparse4j Python के argparse के आधार पर Java के लिए कमांड लाइन तर्क पार्सर लाइब्रेरी है।

— तात्सुहिरो त्सिजिकावा
स्रोत

ढेर अतिप्रवाह में आपका स्वागत है! अपना उत्तर पोस्ट करने के लिए धन्यवाद! कृपया सेल्फ-प्रमोशन पर अक्सर पूछे जाने वाले प्रश्नों को ध्यान से पढ़ें ।

— एंड्रयू बार्बर

5

यदि आप ग्नू गेटटॉप से परिचित हैं, तो इसमें एक जावा पोर्ट है: http://www.urbanophile.com/arenn/hacking/download.htm ।

ऐसा करने वाले कुछ वर्ग प्रतीत होते हैं:

— रे तयेक
स्रोत

4

एयरलाइन @ Github अच्छा लग रहा है। यह एनोटेशन पर आधारित है और Git कमांड लाइन संरचनाओं का अनुकरण करने की कोशिश कर रहा है।

— cthiebaud
स्रोत

4

यदि आप पहले से ही स्प्रिंग बूट का उपयोग कर रहे हैं, तो तर्क पार्सिंग बॉक्स से बाहर आता है।

यदि आप स्टार्टअप के बाद कुछ चलाना चाहते हैं, तो ApplicationRunnerइंटरफ़ेस लागू करें:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(ApplicationArguments args) {
    args.containsOption("my-flag-option"); // test if --my-flag-option was set
    args.getOptionValues("my-option");     // returns values of --my-option=value1 --my-option=value2 
    args.getOptionNames();                 // returns a list of all available options
    // do something with your args
  }
}

runसंदर्भ सफलतापूर्वक शुरू होने के बाद आपका तरीका लागू किया जाएगा।

यदि आपको अपने एप्लिकेशन संदर्भ को फायर करने से पहले तर्कों तक पहुंच की आवश्यकता है, तो आप बस मैन्युअल रूप से आवेदन के तर्कों को पार्स कर सकते हैं:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    ApplicationArguments arguments = new DefaultApplicationArguments(args);
    // do whatever you like with your arguments
    // see above ...
    SpringApplication.run(Application.class, args);
  }

}

और अंत में, यदि आपको एक सेम में अपने तर्कों तक पहुंच की आवश्यकता है, तो बस इंजेक्ट करें ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

— स्टीफन हैबर
स्रोत

यह कमाल का है :)।

— जॉन हम्फ्रेस - w00te

3

Argparse4j सबसे अच्छा मैंने पाया है। यह पायथन के अर्गपर्स लिबरी की नकल करता है जो बहुत सुविधाजनक और शक्तिशाली है।

— Trismegistos
स्रोत

2

यदि आप कुछ हल्का (जार आकार ~ 20 केबी) और उपयोग करने के लिए सरल चाहते हैं, तो आप तर्क-पार्सर की कोशिश कर सकते हैं । इसका उपयोग अधिकांश मामलों में किया जा सकता है, तर्क में सरणियों को निर्दिष्ट करने का समर्थन करता है और किसी अन्य पुस्तकालय पर कोई निर्भरता नहीं है। यह जावा 1.5 या इसके बाद के संस्करण के लिए काम करता है। नीचे अंश कैसे उपयोग करने के बारे में एक उदाहरण दिखाता है:

public static void main(String[] args) {
    String usage = "--day|-d day --mon|-m month [--year|-y year][--dir|-ds directoriesToSearch]";
    ArgumentParser argParser = new ArgumentParser(usage, InputData.class);
    InputData inputData = (InputData) argParser.parse(args);
    showData(inputData);

    new StatsGenerator().generateStats(inputData);
}

अधिक उदाहरण यहाँ मिल सकते हैं

— हिमांशु शेखर
स्रोत

1

लिंक मर चुका है। क्या आपने प्रोजेक्ट को मार दिया? :-(

— बेलाज

2

मैं Apache Common CLIपुस्तकालय का उपयोग करने की अनुशंसा नहीं करूंगा , क्योंकि यह गैर-सूत्र है।

यह स्टेटिबल क्लासेस का उपयोग स्टैटिक वैरिएबल्स और मेथड्स के साथ इंटरनल वर्क (जैसे OptionBuilder) करने के लिए करता है और इसे केवल सिंगल-थ्रेड्ड दृढ़ता से नियंत्रित स्थितियों में उपयोग किया जाना चाहिए।

— जेकब
स्रोत

18

यह ध्यान में रखना अच्छा है कि सीएलआई लाइब्रेरी थ्रेड-सुरक्षित नहीं है। हालांकि, मुझे लगता है कि कमांड-लाइन पार्सिंग आमतौर पर एप्लिकेशन स्टार्टअप के दौरान एक ही थ्रेड में किया जाता है, और फिर, मापदंडों के आधार पर, अन्य थ्रेड शुरू किए जा सकते हैं।

— एलेक्सी इवानोव

0

जैसा कि पहले उल्लेखित टिप्पणियों में से एक ( https://github.com/pcj/google-options ) के साथ शुरू करने के लिए एक अच्छा विकल्प होगा।

एक चीज जो मैं जोड़ना चाहता हूं वह है:

1) यदि आप कुछ पार्सर प्रतिबिंब त्रुटि में भाग लेते हैं, तो कृपया अमरूद के एक नए संस्करण का उपयोग करने का प्रयास करें। मेरे मामले में:

maven_jar(
    name = "com_google_guava_guava",
    artifact = "com.google.guava:guava:19.0",
    server = "maven2_server",
)

maven_jar(
    name = "com_github_pcj_google_options",
    artifact = "com.github.pcj:google-options:jar:1.0.0",
    server = "maven2_server",
)

maven_server(
    name = "maven2_server",
    url = "http://central.maven.org/maven2/",
)

2) कमांडलाइन चलाते समय:

bazel run path/to/your:project -- --var1 something --var2 something -v something

3) जब आपको उपयोग सहायता की आवश्यकता हो, तो बस टाइप करें:

bazel run path/to/your:project -- --help

— स्टीवंस
स्रोत

-1

स्प्रिंग उपयोगकर्ताओं के लिए, हमें https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandininePropertySource.html और उनके जुड़वां भाई https: //docs.spring का भी उल्लेख करना चाहिए। .io / वसंत / डॉक्स / वर्तमान / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (समान कार्यक्षमता का कार्यान्वयन)। बसंत में लाभ यह है कि आप कमांड लाइन के तर्कों को सीधे विशेषताओं में बाँध सकते हैं, यहाँ एक उदाहरण है https://docs.spring.io/spring/docs/current/javadoc-api/org/spritframework/core/env/ CommandLinePropertySource.html

— पियरलिगी वर्नेटो
स्रोत

मैं जावा में कमांड लाइन तर्क कैसे पार्स करूं?

स्थापना

Bazel

Gradle

Maven

प्रयोग