Du kan nemt pakke en applikations hele sæt klasser og ressourcer i et Java Archive (JAR). Faktisk er det et mål at have jar-filer. En anden er at lade brugerne nemt udføre den applikation, der er gemt i arkivet. Hvorfor fungerer jar-filer derefter andenklasses borgere i Java-universet - kun som arkiver - når de kan være i første klasse lige ved siden af indfødte eksekverbare filer?
For at udføre en jar-fil kan du bruge
java
kommandos
-krukke
mulighed. Sig for eksempel, at du har en kørende fil, der kan køres
myjar.jar
. Fordi filen kan køres, kan du udføre den sådan:
java -jar myjar.jar
.
Alternativt tilknytter Java Runtime Environment (JRE), når det er installeret på et operativsystem som Microsoft Windows, jar-filer til JVM, så du kan dobbeltklikke på dem for at køre applikationen. Disse JAR'er skal kunne køres.
Spørgsmålet er: Hvordan laver man en JAR-kørbar?
Manifestfilen og posten Main-Class
Inde i de fleste JAR'er kaldes en fil
MANIFEST.MF
er gemt i et kaldet bibliotek
META-INF
. Inde i denne fil hedder en særlig post
Hovedklasse
fortæller
java -jar
kommando hvilken klasse der skal udføres.
Problemet er, at du selv skal tilføje denne specielle post til manifestfilen - den skal gå et bestemt sted og skal have et bestemt format. Imidlertid kan nogle af os ikke lide at redigere konfigurationsfiler.
Lad API'en gøre det for dig
Siden Java 1.2 kaldes en pakke java.util.jar
har ladet dig arbejde med jar-filer. (Bemærk: Det bygger på java.util.zip
pakke.) Specielt giver jar-pakken dig mulighed for let at manipulere den specielle manifestfil via Manifest
klasse.
Lad os skrive et program, der bruger denne API. For det første skal dette program vide om tre ting:
- Den JAR, vi ønsker at gøre køreklar
- Hovedklassen, vi ønsker at udføre (denne klasse skal eksistere inde i JAR)
- Navnet på en ny JAR til vores output, fordi vi ikke bare skal overskrive filer
Skriv programmet
Ovenstående liste udgør vores programs argumenter. Lad os på dette tidspunkt vælge et passende navn til denne applikation. Hvordan gør det? MakeJarRunnable
lyd?
Kontroller argumenterne til main
Antag, at vores vigtigste indgangssted er en standard main (String [])
metode. Vi skal først kontrollere programargumenterne her:
if (args.length! = 3) {System.out.println ("Usage: MakeJarRunnable" + ""); System.exit (0); }
Vær opmærksom på, hvordan argumentlisten fortolkes, da den er vigtig for følgende kode. Argumentrækkefølgen og indholdet er ikke sat i sten; husk dog at ændre den anden kode korrekt, hvis du ændrer dem.
Få adgang til JAR og dens manifestfil
Først skal vi oprette nogle objekter, der kender til JAR og manifestfiler:
// Opret JarInputStream-objektet, og få dets manifest JarInputStream jarIn = ny JarInputStream (ny FileInputStream (args [0])); Manifest manifest = jarIn.getManifest (); if (manifest == null) {// Dette vil ske, hvis der ikke findes noget manifest manifest = new Manifest (); }
Indstil attributten Main-Class
Vi sætter Hovedklasse
post i manifestfilens hovedattributdel. Når vi først har fået dette attributssæt fra manifestobjektet, kan vi indstille den passende hovedklasse. Men hvad hvis en Hovedklasse
findes der allerede i den originale JAR? Dette program udskriver simpelthen en advarsel og afslutter. Måske kunne vi tilføje et kommandolinjeargument, der fortæller programmet at bruge den nye værdi i stedet for den allerede eksisterende:
Attributter a = manifest.getMainAttributter (); Streng oldMainClass = a.putValue ("Main-Class", args [1]); // Hvis der findes en gammel værdi, skal du fortælle brugeren og afslutte hvis (oldMainClass! = Null) {System.out.println ("Advarsel: gammel Main-Class-værdi er:" + oldMainClass); System.exit (1); }
Output den nye JAR
Vi er nødt til at oprette en ny jar-fil, så vi skal bruge JarOutputStream
klasse. Bemærk: Vi skal sikre, at vi ikke bruger den samme fil til output, som vi gør til input. Alternativt bør programmet måske overveje tilfældet, hvor de to jar-filer er de samme, og bede brugeren, hvis han ønsker at overskrive originalen. Jeg forbeholder mig dog dette som en øvelse for læseren. Fortsæt med koden!
System.out.println ("Skrivning til" + args [2] + "..."); JarOutputStream jarOut = ny JarOutputStream (ny FileOutputStream (args [2]), manifest);
Vi skal skrive hver post fra input JAR til output JAR, så gentag posterne:
// Opret en læsebuffer for at overføre data fra inputbyte [] buf = ny byte [4096]; // Iterer posterne JarEntry-post; while ((entry = jarIn.getNextJarEntry ())! = null) {// Ekskluder manifestfilen fra den gamle JAR, hvis ("META-INF / MANIFEST.MF" .equals (entry.getName ())) fortsætter; // Skriv posten til output JAR jarOut.putNextEntry (post); int læst; mens ((read = jarIn.read (buf))! = -1) {jarOut.write (buf, 0, read); } jarOut.closeEntry (); } // Skyl og luk alle streams jarOut.flush (); jarOut.close (); jarIn.close ();
Komplet program
Selvfølgelig skal vi placere denne kode inde i en vigtigste
metode inde i en klasse og med et passende sæt importopgørelser. Sektionen Ressourcer indeholder det komplette program.
Brugseksempel
Lad os bruge dette program med et eksempel. Antag at du har et program, hvis hovedindgangssted er i en klasse, der kaldes HelloRunnableWorld
. (Dette er det fulde klassenavn.) Antag også, at du har oprettet en JAR kaldet myjar.jar
, der indeholder hele applikationen. Løb MakeJarRunnable
på denne jar-fil som sådan:
java MakeJarRunnable myjar.jar HelloRunnableWorld myjar_r.jar
Igen, som nævnt tidligere, bemærk hvordan jeg bestiller argumentlisten. Hvis du glemmer ordren, skal du bare køre dette program uden argumenter, og det vil svare med en brugsmeddelelse.
Prøv at køre
java -jar
kommando til
myjar.jar
og derefter videre
myjar_r.jar
. Bemærk forskellen! Når du har gjort det, skal du udforske manifestfilerne (
META-INF / MANIFEST.MF
) i hver JAR. (Du kan finde begge JAR'er i
kildekode
.)
Her er et forslag: Prøv at lave MakeJarRunnable
programmer ind i en kørbar JAR!
Kør med det
At køre en JAR ved at dobbeltklikke på den eller bruge en simpel kommando er altid mere praktisk end at skulle inkludere den i din klassesti og køre en bestemt hovedklasse. For at hjælpe dig med dette giver JAR-specifikationen en Hovedklasse
attribut til JAR's manifestfil. Det program, jeg præsenterer her, giver dig mulighed for at bruge Java's JAR API til nemt at manipulere denne attribut og gøre dine JAR'er kørbare.
Lær mere om dette emne
- Download kildekoden og JAR til dette tip
//images.techhive.com/downloads/idge/imported/article/jvw/2002/05/makejarrunnable.zip
- "Java Tip 120 Udfør selvudpakkende JAR'er," Z. Steve Jin og John D. Mitchell (JavaWorld, November 2001)
//www.javaworld.com/javaworld/javatips/jw-javatip120.html
- JAR-filspecifikation
//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
- Se alle forrige Java-tip og indsend din egen
//www.javaworld.com/javatips/jw-javatips.index.html
- Lær Java fra bunden i JavaWorld 's Java 101 kolonne
//www.javaworld.com/javaworld/topicalindex/jw-ti-java101.html
- Java-eksperter besvarer dine hårdeste Java-spørgsmål i JavaWorld 's Java Q&A kolonne
//www.javaworld.com/javaworld/javaqa/javaqa-index.html
- Gennemse Core Java sektion af JavaWorld 's Aktuelt indeks
//www.javaworld.com/channel_content/jw-core-index.shtml
- Bliv på toppen af vores Tips 'N tricks ved at abonnere på JavaWorld 's gratis ugentlige e-mail-nyhedsbreve
//www.javaworld.com/subscribe
- Lær det grundlæggende i klientsiden Java i JavaWorld 's Java Nybegynder diskussion. Kernemner inkluderer Java-sproget, Java Virtual Machine, API'er og udviklingsværktøjer
//forums.idg.net/webx?50@@.ee6b804
- Du finder et væld af it-relaterede artikler fra vores søsterpublikationer på .net
Denne historie, "Java Tip 127: See JAR run" blev oprindeligt udgivet af JavaWorld.