Du kan enkelt pakke hele programmets sett med klasser og ressurser i et Java Archive (JAR). Faktisk er det et mål å ha jar-filer. En annen er å la brukere enkelt kjøre applikasjonen som er lagret i arkivet. Hvorfor fungerer jar-filer deretter førsteklasses borgere i Java-universet - bare som arkiver - når de kan være førsteklasses, rett ved siden av innfødte kjørbare filer?
For å utføre en jar-fil, kan du bruke
java
kommandoen
-krukkealternativ. Si for eksempel at du har en kjørbar jar-fil kalt
myjar.jar
. Fordi filen kan kjøres, kan du utføre den slik:
java -jar myjar.jar.
Alternativt tilknytter Java Runtime Environment (JRE), når det er installert på et operativsystem som Microsoft Windows, jar-filer med JVM slik at du kan dobbeltklikke på dem for å kjøre applikasjonen. Disse JAR-ene må kunne kjøres.
Spørsmålet er: Hvordan lager du en JAR-kjørbar?
Manifestfilen og hovedklasseoppføringen
Inne i de fleste JAR, en fil kalt
MANIFEST.MF
lagres i en katalog som heter
META-INF
. Inne i filen, ringte en spesiell oppføring
Hovedklasse
forteller
java -jarkommando hvilken klasse du skal utføre.
Problemet er at du må legge denne spesielle oppføringen til manifestfilen riktig - den må gå på et bestemt sted og må ha et bestemt format. Noen av oss liker imidlertid ikke å redigere konfigurasjonsfiler.
La APIen gjøre det for deg
Siden Java 1.2, en pakke som heter java.util.jar har latt deg jobbe med jar-filer. (Merk: Den bygger på java.util.zip pakke.) Spesielt lar jar-pakken deg enkelt manipulere den spesielle manifestfilen via Manifest klasse.
La oss skrive et program som bruker dette API. Først må dette programmet vite om tre ting:
- JAR vi ønsker å gjøre kjørbare
- Hovedklassen vi ønsker å utføre (denne klassen må eksistere inne i JAR)
- Navnet på en ny JAR for produksjonen vår, fordi vi ikke bare skal overskrive filer
Skriv programmet
Listen over vil utgjøre programmets argumenter. På dette punktet, la oss velge et passende navn for denne applikasjonen. Hvordan gjør MakeJarRunnable lyd?
Sjekk argumentene til main
Anta at vårt viktigste inngangspunkt er en standard main (String []) metode. Vi bør først sjekke programargumentene her:
if (args.length! = 3) {System.out.println ("Bruk: MakeJarRunnable" + ""); System.exit (0); } Vær oppmerksom på hvordan argumentlisten tolkes, da den er viktig for følgende kode. Argumentrekkefølgen og innholdet er ikke satt i stein; husk imidlertid å endre den andre koden på riktig måte hvis du endrer dem.
Få tilgang til JAR og dens manifestfil
Først må vi lage noen objekter som vet om JAR og manifestfiler:
// Opprett JarInputStream-objektet, og få manifestet JarInputStream jarIn = nytt JarInputStream (nytt FileInputStream (args [0])); Manifest manifest = jarIn.getManifest (); if (manifest == null) {// Dette vil skje hvis ingen manifest eksisterer manifest = new Manifest (); } Still inn hovedklasse-attributtet
Vi setter Hovedklasse oppføring i manifestfilens hovedattributtdel. Når vi oppnår dette attributtsettet fra manifestobjektet, kan vi stille inn riktig hovedklasse. Men hva om en Hovedklasse attributt eksisterer allerede i den opprinnelige JAR? Dette programmet skriver bare ut en advarsel og går ut. Kanskje vi kan legge til et kommandolinjeargument som forteller programmet å bruke den nye verdien i stedet for den allerede eksisterende:
Attributter a = manifest.getMainAttribute (); Streng oldMainClass = a.putValue ("Main-Class", args [1]); // Hvis det eksisterer en gammel verdi, fortell brukeren og avslutt hvis (oldMainClass! = Null) {System.out.println ("Advarsel: gammel hovedklasseverdi er:" + oldMainClass); System.exit (1); } Send ut den nye JAR
Vi må lage en ny jar-fil, så vi må bruke JarOutputStream klasse. Merk: Vi må sørge for at vi ikke bruker den samme filen for utdata som for input. Alternativt, kanskje programmet burde vurdere tilfellet hvor de to jar-filene er de samme og be brukeren om han ønsker å overskrive originalen. Imidlertid forbeholder jeg meg dette som en øvelse for leseren. På med koden!
System.out.println ("Skriver til" + args [2] + "..."); JarOutputStream jarOut = ny JarOutputStream (ny FileOutputStream (args [2]), manifest); Vi må skrive hver oppføring fra inngangen JAR til utgangen JAR, så gjenta over oppføringene:
// Lag en lesebuffer for å overføre data fra inngangsbyte [] buf = ny byte [4096]; // Iterer oppføringene JarEntry-oppføring; while ((entry = jarIn.getNextJarEntry ())! = null) {// Ekskluder manifestfilen fra den gamle JAR hvis ("META-INF / MANIFEST.MF" .equals (entry.getName ())) fortsetter; // Skriv oppføringen til utgangen JAR jarOut.putNextEntry (oppføring); int lese; mens ((read = jarIn.read (buf))! = -1) {jarOut.write (buf, 0, read); } jarOut.closeEntry (); } // Skyll og lukk alle strømmer jarOut.flush (); jarOut.close (); jarIn.close (); Komplett program
Selvfølgelig må vi plassere denne koden i en hoved- metode, inne i en klasse, og med et passende sett med importuttalelser. Ressursdelen inneholder hele programmet.
Brukseksempel
La oss bruke dette programmet med et eksempel. Anta at du har et program der hovedinngangsstedet er i en klasse som heter HelloRunnableWorld. (Dette er hele klassenavnet.) Anta også at du har opprettet et JAR-navn myjar.jar, som inneholder hele applikasjonen. Løpe MakeJarRunnable på denne jar-filen slik:
java MakeJarRunnable myjar.jar HelloRunnableWorld myjar_r.jar
Igjen, som nevnt tidligere, legg merke til hvordan jeg bestiller argumentlisten. Hvis du glemmer bestillingen, er det bare å kjøre dette programmet uten argumenter, og det vil svare med en bruksmelding.
Prøv å kjøre
java -jarkommandoen på
myjar.jar
og så videre
myjar_r.jar
. Legg merke til forskjellen! Når du har gjort det, kan du utforske manifestfilene (
META-INF / MANIFEST.MF
) i hver JAR. (Du finner begge JAR-ene i
kildekode
.)
Her er et forslag: Prøv å lage MakeJarRunnable program til en kjørbar JAR!
Løp med det
Å kjøre en JAR ved å dobbeltklikke på den eller bruke en enkel kommando er alltid mer praktisk enn å måtte inkludere den i klassen din og kjøre en bestemt hovedklasse. For å hjelpe deg med dette, gir JAR-spesifikasjonen en Hovedklasse attributt for JARs manifestfil. Programmet jeg presenterer her lar deg bruke Java's JAR API til å enkelt manipulere dette attributtet og gjøre JAR-ene dine kjørbare.
Lær mer om dette emnet
- Last ned kildekoden og JAR for dette tipset
//images.techhive.com/downloads/idge/imported/article/jvw/2002/05/makejarrunnable.zip
- "Java Tip 120Execute Self-Extracting JARs," Z. Steve Jin og John D. Mitchell (JavaWorld, November 2001)
//www.javaworld.com/javaworld/javatips/jw-javatip120.html
- JAR-filspesifikasjon
//java.sun.com/j2se/1.3/docs/guide/jar/jar.html
- jar — Java Archive Tool
//java.sun.com/j2se/1.3/docs/tooldocs/win32/jar.html
- Vis alle forrige Java-tips og send inn dine egne
//www.javaworld.com/javatips/jw-javatips.index.html
- Lær Java fra grunnen av i JavaWorld 's Java 101 kolonne
//www.javaworld.com/javaworld/topicalindex/jw-ti-java101.html
- Java-eksperter svarer på de tøffeste Java-spørsmålene dine i JavaWorld 's Java Q&A kolonne
//www.javaworld.com/javaworld/javaqa/javaqa-index.html
- Bla gjennom Core Java seksjon av JavaWorld 's Aktuell indeks
//www.javaworld.com/channel_content/jw-core-index.shtml
- Hold deg på toppen av vår Tips 'N Tricks ved å abonnere på JavaWorld 's gratis ukentlige nyhetsbrev
//www.javaworld.com/subscribe
- Lær det grunnleggende om klientsiden Java i JavaWorld 's Java Nybegynner diskusjon. Kjerneemner inkluderer Java-språket, Java Virtual Machine, API-er og utviklingsverktøy
//forums.idg.net/webx?50@@.ee6b804
- Du finner et vell av IT-relaterte artikler fra søsterpublikasjonene våre på .net
Denne historien, "Java Tip 127: See JAR run" ble opprinnelig utgitt av JavaWorld.
