streamalism.org

Zoals we zojuist hebben gezien, wordt voor opties zonder argumenten hun aanwezigheid of afwezigheid altijd geëvalueerd als a boolean waarde.

Het is echter mogelijk om opties te registreren die argumenten accepteren. We kunnen dit eenvoudig doen door te verklaren dat ons veld van een ander type is. Laten we een bericht optie voor onze plegen opdracht:

@Option (names = {"-m", "--message"}) privé String-bericht; @Override public void run () {System.out.println ("Bestanden vastleggen in het staging-gebied, hoe geweldig?"); if (bericht! = null) {System.out.println ("Het vastlegbericht is" + bericht); }}

Het is niet verwonderlijk dat de bericht optie, zal het commando het vastlegbericht op de console tonen. Later in dit artikel bespreken we welke typen door de bibliotheek worden verwerkt en hoe u met andere typen kunt omgaan.

5.3. Optie met meerdere argumenten

Maar nu, wat als we willen dat onze opdracht meerdere berichten opneemt, zoals wordt gedaan met de echte git commit opdracht? Geen zorgen, laten we ons veld een array of een Verzameling, en we zijn zo ongeveer klaar:

@Option (names = {"-m", "--message"}) privé String [] berichten; @Override public void run () {System.out.println ("Bestanden vastleggen in het staging-gebied, hoe geweldig?"); if (messages! = null) {System.out.println ("Het vastlegbericht is"); voor (String bericht: berichten) {System.out.println (bericht); }}}

Nu kunnen we de bericht optie meerdere keren:

commit -m "Mijn commit is geweldig" -m "Mijn commit is prachtig"

Het is echter mogelijk dat we de optie maar één keer willen geven en de verschillende parameters door een regex-scheidingsteken van elkaar willen scheiden. Daarom kunnen we de splitsen parameter van de @Keuze annotatie:

@Option (names = {"-m", "--message"}, split = ",") private String [] berichten;

Nu kunnen we slagen -m "Mijn commitment is geweldig", "Mijn commitment is mooi" om hetzelfde resultaat te bereiken als hierboven.

5.4. Vereiste optie

Soms hebben we misschien een optie die vereist is. De verplicht argument, dat standaard is ingesteld op false, stelt ons in staat om dat te doen:

@Option (names = {"-m", "--message"}, required = true) private String [] berichten;

Nu is het onmogelijk om de plegen commando zonder het bericht keuze. Als we dat proberen, picocli zal een foutmelding afdrukken:

Ontbrekende vereiste optie '--message =' Gebruik: git commit -m = [-m =] ... -m, --message =

6. Positieparameters beheren

6.1. Leg positionele parameters vast

Laten we ons nu concentreren op onze toevoegen commando omdat het nog niet erg krachtig is. We kunnen alleen besluiten om alle bestanden toe te voegen, maar wat als we specifieke bestanden willen toevoegen?

We zouden een andere optie kunnen gebruiken om dat te doen, maar een betere keuze zou zijn om positionele parameters te gebruiken. Inderdaad, positionele parameters zijn bedoeld om commando-argumenten vast te leggen die specifieke posities innemen en zijn geen subcommando's of opties.

In ons voorbeeld zou dit ons in staat stellen om zoiets te doen als:

voeg file1 file2

Om positionele parameters vast te leggen, we maken gebruik van de @Parameters annotatie:

@Parameters privélijstbestanden; @Override public void run () {if (allFiles) {System.out.println ("Alle bestanden aan het verzamelgebied worden toegevoegd"); } if (files! = null) {files.forEach (pad -> System.out.println ("Toevoegen" + pad + "aan het verzamelgebied")); }}

Nu zou ons commando van eerder afdrukken:

Bestand1 aan het verzamelgebied toevoegen Bestand2 aan het verzamelgebied toevoegen

6.2. Leg een subset van positionele parameters vast

Dankzij de inhoudsopgave parameter van de annotatie. De index is gebaseerd op nul. Dus als we definiëren:

@Parameters (index = "2 .. *")

Dit zou argumenten vastleggen die niet overeenkomen met opties of subopdrachten, van de derde tot het einde.

De index kan een bereik of een enkel getal zijn, dat een enkele positie vertegenwoordigt.

7. Een woord over typeconversie

Zoals we eerder in deze tutorial hebben gezien, picocli voert zelf een typeconversie uit. Het wijst bijvoorbeeld meerdere waarden toe aan arrays of Collecties, maar het kan ook argumenten aan specifieke typen toewijzen, zoals wanneer we de Pad klasse voor de toevoegen opdracht.

Eigenlijk, picocli wordt geleverd met een heleboel voorbewerkte soorten. Dit betekent dat we die typen direct kunnen gebruiken zonder dat we er zelf over na hoeven te denken om ze om te zetten.

Het is echter mogelijk dat we onze opdrachtargumenten moeten toewijzen aan andere typen dan degene die al zijn afgehandeld. Gelukkig voor ons, dit is mogelijk dankzij de ITypeConverter interface en de CommandLine # registerConverter methode, die een type aan een converter koppelt.

Laten we ons voorstellen dat we de config subcommando aan onze git commando, maar we willen niet dat gebruikers een configuratie-element wijzigen dat niet bestaat. Dus besluiten we om die elementen toe te wijzen aan een enum:

openbare opsomming ConfigElement {USERNAME ("user.name"), EMAIL ("user.email"); private laatste String-waarde; ConfigElement (String-waarde) {this.value = value; } public String value () {retourwaarde; } public static ConfigElement from (String value) {return Arrays.stream (values ​​()) .filter (element -> element.value.equals (waarde)) .findFirst () .orElseThrow (() -> new IllegalArgumentException ("De argument "+ waarde +" komt niet overeen met een ConfigElement ")); }}

Plus, in onze nieuw gecreëerde GitConfigCommand klasse, laten we twee positionele parameters toevoegen:

@Parameters (index = "0") privé ConfigElement-element; @Parameters (index = "1") private String-waarde; @Override public void run () {System.out.println ("Setting" + element.value () + "to" + value); }

Op deze manier zorgen we ervoor dat gebruikers niet-bestaande configuratie-elementen niet kunnen wijzigen.

Ten slotte moeten we onze converter registreren. Wat mooi is, is dat als we Java 8 of hoger gebruiken, we niet eens een klasse hoeven te maken die het ITypeConverter koppel. We kunnen gewoon een lambda- of methodeverwijzing doorgeven aan de registerConverter () methode:

CommandLine commandLine = nieuwe CommandLine (nieuwe GitCommand ()); commandLine.registerConverter (ConfigElement.class, ConfigElement :: from); commandLine.parseWithHandler (nieuwe RunLast (), args);

Dit gebeurt in de GitCommand hoofd() methode. Merk op dat we het gemak moesten loslaten CommandLine.run () methode.

Bij gebruik met een niet-afgehandeld configuratie-element, zou de opdracht het helpbericht weergeven plus een stukje informatie dat ons vertelt dat het niet mogelijk was om de parameter naar een ConfigElement:

Ongeldige waarde voor positionele parameter bij index 0 (): kan 'user.phone' niet converteren naar ConfigElement (java.lang.IllegalArgumentException: het argument user.phone komt niet overeen met een ConfigElement) 

8. Integratie met Spring Boot

Laten we tot slot eens kijken hoe we dat allemaal kunnen Springify!

Inderdaad, we werken misschien in een Spring Boot-omgeving en willen hiervan profiteren in ons opdrachtregelprogramma. Om dat te doen, we moeten een SpringBootApplicationimplementatie van de CommandLineRunner koppel:

@SpringBootApplication openbare klasse Toepassing implementeert CommandLineRunner {openbare statische leegte hoofd (String [] args) {SpringApplication.run (Application.class, args); } @Override public void run (String ... args) {}}

Plus, laten we al onze commando's en subcommando's annoteren met de Spring @Component annotatie en autowire dat alles in onze Toepassing:

privé GitCommand gitCommand; privé GitAddCommand addCommand; privé GitCommitCommand commitCommand; private GitConfigCommand configCommand; openbare toepassing (GitCommand gitCommand, GitAddCommand addCommand, GitCommitCommand commitCommand, GitConfigCommand configCommand) {this.gitCommand = gitCommand; this.addCommand = addCommand; this.commitCommand = commitCommand; this.configCommand = configCommand; }

Merk op dat we elk subcommando automatisch moesten bedraden. Helaas komt dit omdat, voorlopig, picocli is nog niet in staat om subopdrachten uit de Spring-context op te halen wanneer ze declaratief worden gedeclareerd (met annotaties). We zullen die bedrading dus zelf moeten doen, op een programmatische manier:

@Override public void run (String ... args) {CommandLine commandLine = nieuwe CommandLine (gitCommand); commandLine.addSubcommand ("add", addCommand); commandLine.addSubcommand ("commit", commitCommand); commandLine.addSubcommand ("config", configCommand); commandLine.parseWithHandler (nieuwe CommandLine.RunLast (), args); }

En nu werkt ons opdrachtregelprogramma als een zonnetje met Spring-componenten. Daarom zouden we een aantal serviceklassen kunnen maken en deze in onze opdrachten kunnen gebruiken, en Spring de afhankelijkheidsinjectie laten verzorgen.

9. Conclusie

In dit artikel hebben we enkele belangrijke kenmerken van de picocli bibliotheek. We hebben geleerd hoe we een nieuwe opdracht kunnen maken en er enkele subopdrachten aan kunnen toevoegen. We hebben veel manieren gezien om met opties en positionele parameters om te gaan. Bovendien hebben we geleerd hoe we onze eigen typeconverters kunnen implementeren om onze opdrachten sterk getypt te maken. Eindelijk hebben we gezien hoe we Spring Boot in onze opdrachten kunnen brengen.

Er valt natuurlijk nog veel meer over te ontdekken. De bibliotheek biedt volledige documentatie.

Wat betreft de volledige code van dit artikel, deze is te vinden op onze GitHub.