inhoudstafel en auteursrecht
* STER *
Goed object-georiënteerd programmeren resulteert in kleine bronbestanden. Als een bronbestand van een klasse groot wordt, betekent dat meestal dat er een mogelijkheid bestaat om sommige van de programmacode in een aparte klasse onder te brengen. Zo blijft de broncode van je systeem makkelijk leesbaar en dus onderhoudbaar.
De keerzijde van de medaille is dat een Java-programma al gauw uit een aanzienlijk aantal verschillende klassen bestaat. Als je bovendien gebruik maakt van een indeling van de klassen in verschillende pakketten (en dat is meestal een goed idee), dan zitten zowel de bronbestanden als de gecompileerde klassenbestanden verspreid over een complete boomstructuur van mappen. Dat maakt het soms minder eenvoudig een afgewerkt programma op een gebruikersmachine te installeren.
Een archief is een bestand dat de inhoud van verscheidene andere bestanden en mappen groepeert.
Als je al een beetje met computers gewerkt hebt, heb je zeker al kennisgemaakt met archieven. MS Windows-gebruikers
zijn vertrouwd met ZIP-bestanden. Linux-gebruikers kennen zeker de formaten TAR en GZ (soms gecombineerd tot TAZ).
Op de meeste computers zijn één of meer hulpprogramma's geïnstalleerd waarmee de inhoud van een
archief weer tot een normale mappen- en bestandenstructuur kan worden omgevormd, en waarmee omgekeerd een archief
kan worden gecreëerd vanuit een bestaande structuur. Een bekende utility voor MS Windows is het
commerciële product WinZip. In de laatste versies van MS Windows XP is een archiefprogramma voor ZIP-bestanden
ingebouwd in het beheerssysteem. De Open Source-wereld biedt ondermeer 7-Zip
(http://www.7-zip.org). Het Unix-archiefformaat TAR kan worden behandeld met
de standaard Unix-opdracht tar, en GZ is het eigen formaat van het Open Source-programma GNU ZIP.
Sommige archiefformaten hanteren ook compressie. Dat betekent dat de binaire codes intern herschikt worden
om dezelfde informatie op een kleiner stuk harde schijf te bewaren. ZIP en GZ zijn voorbeelden van compressieformaten,
TAR niet.
De Java-wereld heeft haar eigen archiefformaat: JAR. Dat is de afkorting van Java archive. Logisch, toch ?
Het bijhorende hulpprogramma om archieven te creëren en te lezen heet eveneens jar, en het maakt
deel uit van de gewone Java Development Kit.
Jar combineert het beste van twee werelden. Intern is het JAR-formaat compatibel met ZIP. Dat betekent dat je
jar-bestanden kunt bekijken met je favoriete zipprogramma. Het opdrachtregelformaat van jar is nagenoeg
identiek aan dat van de Unix-opdracht tar. Voor ons zijn voorlopig alleen de volgende twee
opdrachtvormen van belang:
jar cvf archiefnaam lijst jar xvf archiefnaam
De eerste opdracht creëert een nieuw jar-bestand met de naam archiefnaam (vergeet de extensie
.jar niet), waarvan de inhoud bepaald wordt door de opsomming van bestanden en mappen in lijst.
De tweede opdracht leest de inhoud van een gegeven jar-bestand met de naam archiefnaam en herstelt de
erin vervatte mappen en bestanden in hun oorspronkelijke staat. Onthou deze twee vormen aan de hand van de letters
c (creatie) en x (extractie). Er is ook een leesopdracht die geen enkel bestand extraheert, maar die alleen de inhoud
van een archief weergeeft in het opdrachtvenster:
jar tvf archiefnaam
Het jar-formaat is weliswaar compatibel met het zip-formaat, maar het is rijker - je kunt dus geen jarfile aanmaken
met een klassieke zip-tool. Jar voegt bij de creatie van een archief automatisch een manifestbestand toe.
Dat is een bestand met aanvullende informatie over de verschillende systeemcomponenten die in het archief zijn
opgenomen. Het heet MANIFEST.MF en bevindt zich in een
map met de naam META-INF. Het standaard-manifestbestand is tamelijk klein, maar je kan
er aanvullende informatie in laten opnemen met de m-optie:
jar cvfm archiefnaam manifestbestand lijst
Voor de inhoud van het manifestbestand bestaan allerlei gespecialiseerde conventies naargelang van het soort toepassing. We beperken ons in dit hoofdstuk voorlopig tot één nuttig voorbeeld: het toepassingsarchief. In paragraaf 8.2 zullen we zien dat JARs en manifesten ook een specifieke rol spelen bij de definitie van componenten (JavaBeans).
Een toepassingsarchief bevat een klassenbestand dat als het startpunt van een zelfstandige applicatie
kan dienen, dus met de bekende methode public static void main(String[] args) Je kunt de naam
van deze klasse signaleren door aan het manifestbestand een regel toe te voegen van de vorm
Main-class: klassennaam
Je kunt dan het programma uitvoeren met de opdrachtregel
java -jar archiefnaam
dus zonder nog uitdrukkelijk de naam van de klasse te specificeren.
Compileer het hallo-programma van paragraaf 1.2. Maak een bestand met de naam mijnmanifest.txt en
met als inhoud de volgende regel
Main-class: Hallo
Let erop dat de regel door een terugkeerteken (carriage return) wordt beëindigd. Maak een java-archief met de opdracht
jar cvfm voorbeeld.jar mijnmanifest.txt Hallo.class
Inspecteer de inhoud van het bestand META-INF\MANIFEST.MF, bijvoorbeeld met behulp van 7-Zip.
Bij ons blijkt het uit de volgende 3 regels te bestaan:
Manifest-Version: 1.0 Created-By: 1.5.0 (Sun Microsystems Inc.) Main-class: Hallo
Je kunt nu het programma uitvoeren met de opdracht
java -jar voorbeeld.jar
met het bekende resultaat.
inhoudstafel en auteursrecht
* STER *