73 views

Hoe leem ik opdrachtregelargumenten in Java?

Hosted by Code Expert
java

Wat is een goede manier om opdrachtregelargumenten in Java te parseren?

1, Autoriteit 100%

Controleer deze:

of rol uw eigen:

Hier bijvoorbeeld, Dit is hoe u commons-cliom 2 stringargumenten te parseren: 

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 = null;//not a good practice, it serves it purpose 
        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);
    }
}

gebruik vanaf opdrachtregel:

$> 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

Antwoord 2, autoriteit 68%

Bekijk de recentere JCommander.

Ik heb het gemaakt. Ik ontvang graag vragen of functieverzoeken.

Antwoord 3, autoriteit 52%

Ik heb geprobeerd een lijst met Java CLI-parsersbij te houden.

Antwoord 4, autoriteit 18%

Het is 2021, tijd om het beter te doen dan Commons CLI… 🙂

Moet je je eigen Java-opdrachtregelparser bouwen of een bibliotheek gebruiken?

Veel kleine hulpprogramma-achtige toepassingen gebruiken waarschijnlijk hun eigen parsing van de opdrachtregel om de extra externe afhankelijkheid te vermijden. picoclikan een interessant alternatief zijn.

Picocli is een moderne bibliotheek en framework voor het eenvoudig bouwen van krachtige, gebruiksvriendelijke, voor GraalVM geschikte opdrachtregel-apps. Het leeft in 1 bronbestand, zodat apps het als bron kunnen opnemen om te voorkomen dat er een afhankelijkheid wordt toegevoegd.

Het ondersteunt kleuren, autocompletion, subcommands en meer. Geschreven in Java, bruikbaar uit Groovy, Kotlin, Scala, enz.

Kenmerken:

  • Annotatie op basis van annotatie: declaratief , vermijdt duplication en expresses programmeur intentie
  • Handig: Parse Gebruikersinvoer en voer uw bedrijfslogica uit met één regel code
  • sterk getypt alles – opdrachtregelopties en positionele parameters
  • Posix Clustered Short-opties (<command> -xvfInputFileEvenals <command> -x -v -f InputFile)
  • Fijnkorrelige bediening : een aritair model dat een minimum, maximaal en variabel aantal parameters mogelijk maakt, bijvoorbeeld "1..*", "3..5"
  • Subcommands (kan worden genesteld op willekeurige diepte)
  • Feature-Rich : componeerbare Arg-groepen, splitsen geciteerde args, herhaalbare subcommandels en nog veel meer
  • Gebruikersvriendelijk : Gebruik Help-bericht gebruikt kleuren om belangrijke elementen zoals optie-namen uit de rest van het gebruik Help aan te verminderen op de gebruiker
  • Distribueer uw app als een graalvm native afbeelding
  • Werkt met Java 5 en hoger
  • Uitgebreid en nauwgezet documentatie

Het gebruik van het gebruik van het gebruik is eenvoudig aan te passen met annotaties (zonder programmeren). Bijvoorbeeld:

(Bron )

Ik kon niet weerstaan ​​om nog een screenshot toe te voegen om te laten zien welke gebruik van het gebruik help-berichten mogelijk zijn. Gebruikshulp is het gezicht van uw toepassing, dus wees creatief en veel plezier!

Disclaimer: ik heb Picocli gemaakt. Feedback of vragen zeer welkom.

5, Autoriteit 5%

Ik heb Jopt gebruikt en vond het vrij handig: http://jopt-simple.sourceforge.net/

De voorpagina biedt ook een lijst met ongeveer 8 alternatieve bibliotheken, controleer ze en kies degene die het maximaal past bij uw behoeften.

6, Autoriteit 5%

Iemand heeft me gewezen op args4j de laatste tijd die annotatie is gebaseerd. Ik vind het echt leuk!

7, Autoriteit 2%

Dit is Google’s Command Line Parsing Library Open-sourced als onderdeel van het Bazel-project. Persoonlijk denk ik dat het de beste is, en ver gemakkelijker dan Apache CLI.

https://github.com/pcj/Google-Options

Installatie

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>

Gebruik

Maak een klasse die zich OptionsBaseuitbreidt en definieert uw @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;
}

Ontmeer de argumenten en gebruik ze. 

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

8, Autoriteit 2%

Kijk eens naar het Commons CLI-project, daar staat veel goeds in.

Antwoord 9, autoriteit 2%

Ja.

Ik denk dat je zoiets zoekt:
http://commons.apache.org/cli

De Apache Commons CLI-bibliotheek biedt een API voor het verwerken van opdrachtregelinterfaces.

Antwoord 10

Misschien deze

  • JArgs-opdrachtregeloptie parseren
    suite voor Java    – dit kleine project biedt een handige, compacte, voorverpakte en uitgebreid gedocumenteerde suite van opdrachtregeloptieparsers voor gebruik door Java-programmeurs. In eerste instantie wordt parsing geleverd die compatibel is met ‘getopt’ in GNU-stijl.

  • ritopt, The Ultimate Options Parser voor Java– Hoewel verschillende standaarden voor opdrachtregelopties voorgezet, volgt ritopt de conventies die zijn voorgeschreven in het opt-pakket.

Antwoord 11

Als je Spring Boot al gebruikt, is het parseren van argumenten een uitkomst.

Als u iets na het opstarten wilt uitvoeren, implementeert u de ApplicationRunner-interface:

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

Uw runMethod wordt opgeroepen nadat de context met succes is gestart.

Als u toegang tot de argumenten vóór nodig heeft, schakelt u uw aanvraagcontext op, u kunt gewoon de applicatieargumenten handmatig parseren: 

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

En ten slotte, als u toegang hebt tot uw argumenten in een boon, injecteer gewoon de ApplicationArguments: 

@Component
public class MyBean {
   @Autowired
   private ApplicationArguments arguments;
   // ...
}

12

Ik schreef nog een: http://argparse4j.sourceforge.net/

ArgParse4j is een opdrachtregel Argument Parser-bibliotheek voor Java, op basis van Python’s Argparse.

13

Als u bekend bent met GNU GETOPT, is er een Java-poort op: http: //www.urbanophile.com/arenn/hacking/download.htm .

Er lijkt een aantal klassen te zijn die dit doen:

Antwoord 14

airline @ Github ziet er goed uit. Het is gebaseerd op annotaties en probeert Git-opdrachtregelstructuren te emuleren.

Antwoord 15

Argparse4j is de beste die ik heb gevonden. Het bootst de argparse-bibliotheek van Python na, wat erg handig en krachtig is.

Antwoord 16

Als je iets lichtgewichts (potgrootte ~ 20 kb) en eenvoudig te gebruiken wilt, kun je argument-parser. Het kan in de meeste gevallen worden gebruikt, ondersteunt het specificeren van arrays in het argument en is niet afhankelijk van een andere bibliotheek. Het werkt voor Java 1.5 of hoger. Onderstaand fragment toont een voorbeeld van hoe het te gebruiken:

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

Meer voorbeelden vindt u hier

Antwoord 17

Ik wil je mijn implementatie laten zien: ReadyCLI

Voordelen:

  • voor luie programmeurs: een heel klein aantal lessen om te leren, kijk maar naar de twee kleine voorbeelden op de README in de repository en je bent al bij 90% van het leren; begin gewoon met het coderen van uw CLI/Parser zonder enige andere kennis;
    ReadyCLI maakt het coderen van CLI’s op de meest natuurlijke manier mogelijk;
  • het is ontworpen met de Developer Experiencein gedachten; het maakt grotendeels gebruik van het Builder-ontwerppatroon en functionele interfaces voor Lambda Expressions, om een zeer snelle codering mogelijk te maken;
  • het ondersteunt Opties, Vlaggenen Subopdrachten;
  • het maakt het mogelijk om argumenten vanaf de opdrachtregel te ontleden en om complexere en interactievere CLI’s te bouwen;
  • een CLI kan net zo gemakkelijk worden gestart op Standard I/O als op elke andere I/O-interface, zoals sockets;
  • het geeft geweldige ondersteuning voor het documenteren van commando’s.

Ik heb dit project ontwikkeld omdat ik nieuwe functies nodig had (opties, vlag, subopdrachten) en die op de eenvoudigst mogelijke manier in mijn projecten konden worden gebruikt.

Antwoord 18

Als een van de eerder genoemde opmerkingen (https://github.com/pcj/google-options ) zou een goede keuze zijn om mee te beginnen.

Eén ding dat ik wil toevoegen is:

1) Als je een parserreflectiefout tegenkomt, probeer dan een nieuwere versie van de guave te gebruiken. in mijn geval:

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) Bij het uitvoeren van de opdrachtline: 

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

3) Wanneer u de gebruikshulp nodig hebt, typt u gewoon: 

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

19

Voor veergebruikers moeten we ook https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/simplecommandlinepropertysource.html en zijn tweelingbroer https://docs.sspring.io/spring/ DOCS / CURRENT / JAVADOC-API / ORG / SpringFramework / Core / Env / JoptcommandlinePropertySource.html (Jopt-implementatie van dezelfde functionaliteit).
Het voordeel in het voorjaar is dat u de opdrachtregelargumenten rechtstreeks kunt binden aan attributen, er is een voorbeeld hier https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/commandlinepropertysource.html

Previous articleniet-standaard syntaxis; gebruik ‘&’ om een verwijzing naar een lid te maken
Next articleVBA: tekst naar nummer converteren

Other episodes

tomcat-dbcp vs commons-dbcp

java Code Expert - 0
Het lijkt erop dat er veel verwarring bestaat tussen deze twee bibliotheken voor het poolen van verbindingen. Wat ik wil weten is welke beter...
Read more

Hoe automatisch N “verschillende” kleuren genereren?

java Code Expert - 0
Ik heb de twee onderstaande methoden geschreven om automatisch N verschillende kleuren te selecteren. Het werkt door een stuksgewijs lineaire functie op de RGB-kubus...
Read more

Wat is het doel van @SmallTest-, @MediumTest- en @LargeTest-annotaties in Android?

java Code Expert - 0
Ik ben nieuw bij Android en ik heb voorbeeldcode gezien met deze annotaties. Bijvoorbeeld: @SmallTest public void testStuff() { TouchUtils.tapView(this, anEditTextView); ...
Read more

Hoe de hoofdklasse van de Spring-boot-toepassing te testen

java Code Expert - 0
Ik heb een spring-bootapplicatie waar mijn @SpringBootApplicationstartersklasse eruitziet als een standaard. Dus ik heb veel tests gemaakt voor al mijn functionaliteiten en de samenvatting...
Read more

Firebase Cloud Firestore: ongeldige verzamelingsreferentie. Collectiereferenties moeten een oneven aantal segmenten hebben

java Code Expert - 0
Ik heb de volgende code en krijg een foutmelding: Invalid collection reference. Collection references must have an odd number of segments En de code : private...
Read more

Java 9 + maven + junit: heeft testcode zijn eigen module-info.java nodig en waar moet deze worden geplaatst?

java Code Expert - 0
Stel dat ik een Java-project heb met Maven 3 en junit. Er zijn mappen src/main/javaen src/test/javadie respectievelijk hoofdbronnen en testbronnen bevatten (alles is standaard). Nu...
Read more

Verschil tussen veranderlijke objecten en onveranderlijke objecten

java Code Expert - 0
Iedereen, geef het verschil tussen veranderlijke objecten en onveranderlijke objecten met een voorbeeld. Antwoord 1, autoriteit 100% Veranderlijke objecten hebben velden die kunnen worden gewijzigd, onveranderlijke...
Read more

© Copyright - Code Expert 2021