streamalism.org

1. Overzicht

Doorgaans bevat elke zinvolle applicatie een of meer JAR-bestanden als afhankelijkheden. Er zijn echter momenten dat een JAR-bestand zelf een zelfstandige toepassing of een webtoepassing vertegenwoordigt.

In dit artikel zullen we ons concentreren op het stand-alone toepassingsscenario. Hierna noemen we het een JAR-applicatie.

In deze zelfstudie leren we eerst hoe u een JAR-toepassing maakt. Later zullen we leren hoe dat moet voer een JAR-toepassing uit met of zonder opdrachtregelargumenten.

2. Maak een POT Toepassing

Een JAR-bestand kan een of meer hoofdklassen bevatten. Elke hoofdklasse is het startpunt van een applicatie. In theorie kan een JAR-bestand dus meer dan één applicatie bevatten, maar het moet ten minste één hoofdklasse bevatten om te kunnen worden uitgevoerd.

Een JAR-bestand kan één ingangspunt hebben in het manifestbestand. In dit geval is het JAR-bestand een uitvoerbare JAR. De hoofdklasse moet in dat JAR-bestand worden opgenomen.

Laten we eerst een snel voorbeeld bekijken van hoe we onze klassen kunnen compileren en een uitvoerbare JAR kunnen maken met een manifestbestand:

$ javac com / baeldung / jarArguments / *. java $ jar cfm JarExample.jar ../resources/example_manifest.txt com / baeldung / jarArguments / *. class

Een niet-uitvoerbare JAR is gewoon een JAR-bestand dat geen Hoofdklasse gedefinieerd in het manifestbestand. Zoals we later zullen zien, kunnen we nog steeds een hoofdklasse uitvoeren die zich in het JAR-bestand zelf bevindt.

Hier is hoe we een niet-uitvoerbare JAR zouden maken zonder een manifestbestand:

$ jar cf JarExample2.jar com / baeldung / jarArguments / *. class

3. Java-opdrachtregelargumenten

Net als elke andere toepassing accepteert een JAR-toepassing een willekeurig aantal argumenten, inclusief nul-argumenten. Het hangt allemaal af van de behoefte van de applicatie.

Hierdoor kan de gebruiker specificeer configuratiegegevens wanneer de toepassing wordt gestart.

Het resultaat is dat de applicatie hardgecodeerde waarden kan vermijden en nog steeds veel verschillende gebruiksscenario's aankan.

Een argument kan alle alfanumerieke tekens, Unicode-tekens en mogelijk enkele speciale tekens bevatten die door de shell zijn toegestaan, bijvoorbeeld ‘@ '.

Argumenten worden gescheiden door een of meer spaties. Als een argument spaties moet bevatten, moeten de spaties tussen aanhalingstekens worden geplaatst. Enkele aanhalingstekens of dubbele aanhalingstekens werken prima.

Gewoonlijk voert de gebruiker voor een typische Java-applicatie bij het aanroepen van de applicatie opdrachtregelargumenten in achter de naam van de klasse.

Dit is echter niet altijd het geval voor JAR-toepassingen.

Zoals we al hebben besproken, is het startpunt van een Java-hoofdklasse de belangrijkste methode. De argumenten zijn allemaal Draads en worden doorgegeven aan de hoofdmethode als een Draad array.

Dat gezegd hebbende, kunnen we binnen de applicatie elk element van het Draad array naar andere gegevenstypen, zoals char, int, dubbele, hun wrapper klassen, of andere geschikte typen.

4. Voer een uitvoerbaar bestand uit POT met argumenten

Laten we eens kijken naar de basissyntaxis voor het uitvoeren van een uitvoerbaar JAR-bestand met argumenten:

java -jar jar-bestandsnaam [args ...]

De uitvoerbare JAR die eerder is gemaakt, is een eenvoudige toepassing die alleen de ingevoerde argumenten afdrukt. We kunnen het uitvoeren met een willekeurig aantal argumenten. Hieronder staat een voorbeeld met twee argumenten:

$ java -jar JarExample.jar "arg 1" [e-mail beveiligd] 

We zien de volgende uitvoer in de console:

Hallo Baeldung-lezer in Jar Voorbeeld! Er zijn 2 argument (en)! Argument (1): arg 1 Argument (2): [e-mail beveiligd] 

Zo, wanneer we een uitvoerbare JAR aanroepen, hoeven we de naam van de hoofdklasse niet op de opdrachtregel op te geven. We voegen simpelweg onze argumenten toe na de JAR-bestandsnaam. Als we een klassenaam opgeven na de uitvoerbare JAR-bestandsnaam, wordt dit gewoon het eerste argument voor de eigenlijke hoofdklasse.

Meestal is een JAR-toepassing een uitvoerbare JAR. Een uitvoerbare JAR kan maximaal één hoofdklasse hebben die is gedefinieerd in het manifestbestand.

Bijgevolg kunnen andere toepassingen in hetzelfde uitvoerbare JAR-bestand niet in het manifestbestand worden ingesteld, maar we kunnen ze nog steeds vanaf de opdrachtregel uitvoeren, net zoals we zouden doen voor een niet-uitvoerbare JAR. We zullen precies zien hoe in de volgende sectie.

5. Voer een niet-uitvoerbaar bestand uit POT met argumenten

Om een ​​applicatie in een niet-uitvoerbaar JAR-bestand uit te voeren, moeten we -cp optie in plaats van -pot. We gebruiken de -cp optie (afkorting van classpath) om het JAR-bestand te specificeren dat het class-bestand bevat dat we willen uitvoeren:

java -cp jar-bestandsnaam hoofdklasse-naam [args ...]

Zoals je kunt zien, in dit geval moeten we de naam van de hoofdklasse in de opdrachtregel opnemen, gevolgd door argumenten.

De eerder gemaakte niet-uitvoerbare JAR bevat dezelfde eenvoudige applicatie. We kunnen het uitvoeren met elk (inclusief nul) argumenten. Hier is een voorbeeld met twee argumenten:

$ java -cp JarExample2.jar com.baeldung.jarArguments.JarExample "arg 1" [e-mail beveiligd]

En, net zoals we hierboven zagen, zullen we de volgende uitvoer zien:

Hallo Baeldung-lezer in Jar Voorbeeld! Er zijn 2 argument (en)! Argument (1): arg 1 Argument (2): [e-mail beveiligd]

6. Conclusie

In deze zelfstudie hebben we twee manieren geleerd om een ​​JAR-toepassing op de opdrachtregel uit te voeren met of zonder argumenten.

We hebben ook aangetoond dat een argument spaties en speciale tekens kan bevatten (indien toegestaan ​​door de shell).

Zoals altijd is de code voor de voorbeelden beschikbaar op GitHub.