เป็นวิธีที่ดีในการแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่งใน Java คืออะไร?

ลองดูสิ

• http://commons.apache.org/cli/
• http://www.martiansoftware.com/jsap/
• http://picocli.info/

หรือหมุนของคุณเอง:

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

ตัวอย่างเช่นนี่คือวิธีที่คุณใช้commons-cliในการแยกวิเคราะห์อาร์กิวเมนต์ของสตริง 2:

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

ดูJCommander ที่ใหม่กว่า

ฉันสร้างมันขึ้นมา ฉันยินดีรับคำถามหรือขอคุณสมบัติ

ฉันพยายามรักษารายการตัวแยกวิเคราะห์ Java CLIparsers

• สายการบิน
  • Active Fork: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• CLI-parser
• CmdLn
• บรรทัดคำสั่ง
• DocOpt.java
• โลมา getopt
• DPML CLI (จาการ์ตาคอมมอนส์ CLI2 ส้อม)
• Dr. Matthias Laux
• จาการ์ตาคอมมอนส์ CLI
• jargo
• jargp
• jargs
• Java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (เขียนโดยฉัน)
• ง่ายต่อการสมัคร
• jsap
• naturalcli
• บทความ Object Mentor CLI (เพิ่มเติมเกี่ยวกับการเปลี่ยนโครงสร้างและ TDD)
• แยก cmd
• ritopt
• Rop
• คำสั่ง TE-Code
• picocliมีวิธีใช้ ANSI colorized และการเติมข้อความอัตโนมัติ

มันเป็นปี 2020 เวลาในการทำดีกว่า Commons CLI ... :-)

คุณควรสร้างตัวแยกวิเคราะห์บรรทัดคำสั่ง Java ของคุณเองหรือใช้ไลบรารี?

แอปพลิเคชันที่มีลักษณะคล้ายยูทิลิตี้ขนาดเล็กจำนวนมากอาจม้วนการแยกบรรทัดคำสั่งของตนเองเพื่อหลีกเลี่ยงการพึ่งพาภายนอกเพิ่มเติม picocliอาจเป็นทางเลือกที่น่าสนใจ

Picocli เป็นห้องสมุดที่ทันสมัยและกรอบการทำงานสำหรับการสร้างแอพบรรทัดคำสั่งที่ใช้งานง่ายและมีประสิทธิภาพ GraalVM ที่ใช้งานง่าย มันอาศัยอยู่ในไฟล์ต้นฉบับ 1 ไฟล์เพื่อให้แอปสามารถรวมเป็นแหล่งที่มาเพื่อหลีกเลี่ยงการเพิ่มการพึ่งพา

รองรับสีการเติมข้อความอัตโนมัติคำสั่งย่อยและอื่น ๆ เขียนใน Java สามารถใช้งานได้จาก Groovy, Kotlin, Scala และอื่น ๆ

คุณสมบัติ:

• คำอธิบายประกอบตาม: ประกาศ , หลีกเลี่ยงการทำสำเนาและเป็นการแสดงออกโปรแกรมเมอร์เจตนา
• สะดวก: แยกวิเคราะห์ผู้ใช้และเรียกใช้ตรรกะทางธุรกิจของคุณด้วยรหัสหนึ่งบรรทัด
• พิมพ์ทุกอย่างมาก - ตัวเลือกบรรทัดคำสั่งรวมถึงพารามิเตอร์ตำแหน่ง
• ตัวเลือกแบบสั้นของคลัสเตอร์ POSIX ( <command> -xvfInputFileรวมถึง<command> -x -v -f InputFile)
• การควบคุมแบบละเอียด : โมเดล arity ที่อนุญาตจำนวนพารามิเตอร์ต่ำสุด, สูงสุดและตัวแปรเช่น"1..*",,"3..5"
• คำสั่งย่อย (สามารถซ้อนกันเป็นความลึกโดยพลการ)
• มีคุณลักษณะหลากหลาย : กลุ่ม arg แบบเรียงต่อได้, การแยก args ที่อ้างอิง, คำสั่งย่อยที่ทำซ้ำได้และอื่น ๆ
• ใช้งานง่าย : ข้อความช่วยเหลือการใช้งานใช้สีเพื่อตัดกันองค์ประกอบที่สำคัญเช่นชื่อตัวเลือกจากส่วนที่เหลือของการใช้งานช่วยลดภาระการรับรู้ของผู้ใช้
• แจกจ่ายแอปของคุณเป็นรูปภาพดั้งเดิมของ GraalVM
• ทำงานร่วมกับJava 5และสูงกว่า
• เอกสารที่กว้างขวางและพิถีพิถัน

ข้อความช่วยเหลือการใช้งานนั้นง่ายต่อการปรับแต่งด้วยหมายเหตุประกอบ (ไม่มีการตั้งโปรแกรม) ตัวอย่างเช่น:

(ที่มา )

ฉันไม่สามารถต้านทานการเพิ่มภาพหน้าจออีกหนึ่งภาพเพื่อแสดงว่าข้อความช่วยเหลือการใช้งานเป็นไปได้อย่างไร ความช่วยเหลือในการใช้คือหน้าใบสมัครของคุณดังนั้นจงสร้างสรรค์และสนุก!

คำเตือน: ฉันสร้าง picocli ข้อเสนอแนะหรือคำถามยินดีต้อนรับมาก

ฉันใช้ JOpt แล้วพบว่ามันค่อนข้างมีประโยชน์: http://jopt-simple.sourceforge.net/

หน้าแรกยังมีรายการของห้องสมุดอื่นอีก 8 แห่งตรวจสอบและเลือกห้องสมุดที่ตรงกับความต้องการของคุณมากที่สุด

มีคนชี้ให้ฉันดูargs4jเมื่อเร็ว ๆ นี้ซึ่งมีคำอธิบายประกอบ ฉันชอบมันมาก!

นี่คือห้องสมุดแยกบรรทัดคำสั่งของ Google ที่มาเปิดเป็นส่วนหนึ่งของโครงการ Bazel โดยส่วนตัวฉันคิดว่าเป็นสิ่งที่ดีที่สุดและง่ายกว่า Apache CLI

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(s) ของคุณ

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

ลองดูที่โครงการCommons CLIสิ่งดีๆมากมายในนั้น

Yeap

ฉันคิดว่าคุณกำลังมองหาสิ่งนี้: http://commons.apache.org/cli

ไลบรารี Apache Commons CLI จัดเตรียม API สำหรับการประมวลผลอินเตอร์เฟสบรรทัดคำสั่ง

ฉันรู้ว่าคนส่วนใหญ่ที่นี่จะหาเหตุผล 10 ล้านเหตุผลที่พวกเขาไม่ชอบวิธีของฉัน แต่ไม่เป็นไร ฉันชอบที่จะทำให้สิ่งต่าง ๆ เรียบง่ายดังนั้นฉันเพิ่งแยกกุญแจออกจากค่าโดยใช้ '=' และเก็บไว้ใน HashMap ดังนี้:

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

คุณสามารถรักษารายการที่มีข้อโต้แย้งที่คุณต้องการเพื่อช่วยผู้ใช้ในกรณีที่เขาลืมข้อโต้แย้งหรือใช้รายการผิด ... อย่างไรก็ตามถ้าคุณต้องการคุณสมบัติมากเกินไปวิธีนี้ไม่ได้แก้ปัญหาสำหรับคุณ

อาจจะเป็นเหล่านี้

• ตัวเลือกบรรทัดคำสั่ง JArgs แยกชุดสำหรับ Java - โครงการเล็ก ๆ นี้ให้ความสะดวกสบายขนาดกะทัดรัดก่อนบรรจุและชุดเอกสารที่ครอบคลุมของตัวเลือกบรรทัดคำสั่งตัวแยกวิเคราะห์สำหรับการใช้งานของโปรแกรมเมอร์ Java เริ่มแรกแยกวิเคราะห์เข้ากันได้กับ 'getopt' สไตล์ GNU

• ritopt, ตัวแยกวิเคราะห์ตัวเลือกขั้นสูงสำหรับ Java - แม้ว่ามาตรฐานตัวเลือกบรรทัดคำสั่งหลายอย่างได้รับการจัดเตรียม ritopt ปฏิบัติตามอนุสัญญาที่กำหนดไว้ในแพคเกจ opt

คุณอาจพบว่า meta-article นี้เป็นเรื่องน่าเศร้าที่น่าสนใจในฐานะจุดกระโดด:

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

ฉันเขียนอีกอันหนึ่ง: http://argparse4j.sourceforge.net/

Argparse4j เป็นไลบรารีตัวแยกวิเคราะห์อาร์กิวเมนต์บรรทัดคำสั่งสำหรับ Java โดยอิงตาม Python ของอาร์กิวเมนต์

หากคุณมีความคุ้นเคยกับ GNU getopt มีพอร์ต Java ที่: http://www.urbanophile.com/arenn/hacking/download.htm

ดูเหมือนจะมีบางคลาสที่ทำสิ่งนี้:

• http://docs.sun.com/source/816-5618-10/netscape/ldap/util/GetOpt.html
• http://xml.apache.org/xalan-j/apidocs/org/apache/xalan/xsltc/cmdline/getopt/GetOpt.html

สายการบิน @ Githubดูดี มันขึ้นอยู่กับคำอธิบายประกอบและพยายามเลียนแบบโครงสร้างบรรทัดคำสั่ง Git

หากคุณใช้ Spring Boot อยู่แล้วการแยกการโต้แย้งออกมาจากกล่อง

หากคุณต้องการรันบางสิ่งหลังจากเริ่มทำงานให้ใช้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;

   // ...
}

Argparse4j เป็นสิ่งที่ดีที่สุดที่ฉันได้พบ มันเลียนแบบ libparse argparse ของ Pyth ซึ่งสะดวกและมีประสิทธิภาพมาก

ถ้าคุณต้องการสิ่งที่มีน้ำหนักเบา (ขวดขนาด ~ 20 KB) และง่ายต่อการใช้งานคุณสามารถลองอาร์กิวเมนต์ parser สามารถใช้ในกรณีการใช้งานส่วนใหญ่รองรับการระบุอาร์เรย์ในอาร์กิวเมนต์และไม่ต้องพึ่งพาไลบรารีอื่น มันใช้งานได้กับ Java 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);
}

ตัวอย่างเพิ่มเติมสามารถพบได้ที่นี่

ฉันจะไม่แนะนำให้ใช้Apache Common CLIห้องสมุดเพราะมันไม่ได้เป็น threadsafe

มันใช้คลาส statefulty กับตัวแปรคงที่และวิธีการที่จะทำงานภายใน (เช่นOptionBuilder) และควรจะใช้ในสถานการณ์ที่ควบคุมอย่างเดียวเธรดเดียว

เป็นหนึ่งในความคิดเห็นที่กล่าวถึงก่อนหน้า ( 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) เมื่อเรียกใช้ commandline:

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

3) เมื่อคุณต้องการความช่วยเหลือในการใช้งานเพียงพิมพ์:

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

สำหรับผู้ใช้สปริงเราควรพูดถึงhttps://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html และพี่ชายฝาแฝดของเขาด้วยhttps: //docs.spring .io / spring / docs / current / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (การนำไปปฏิบัติของฟังก์ชั่นเดียวกัน) ข้อดีในฤดูใบไม้ผลิคือคุณสามารถผูกอาร์กิวเมนต์บรรทัดคำสั่งกับแอตทริบิวต์ได้โดยตรงมีตัวอย่างที่นี่https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/ CommandLinePropertySource.html