Java Language
Java-implementatie

Invoering

Opmerkingen

Een uitvoerbare JAR maken vanaf de opdrachtregel

Om een pot te maken, hebt u een of meer klassenbestanden nodig. Dit moet een hoofdmethode hebben als het door een dubbele klik moet worden uitgevoerd.

Voor dit voorbeeld gebruiken we:

import javax.swing.*;
import java.awt.Container;

public class HelloWorld {

    public static void main(String[] args) {
        JFrame f = new JFrame("Hello, World"); 
        JLabel label = new JLabel("Hello, World");
        Container cont = f.getContentPane();
        cont.add(label);
        f.setSize(400,100); 
        f.setVisible(true);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

}

Het heeft de naam HelloWorld.java gekregen

Vervolgens willen we dit programma compileren.

U kunt elk programma gebruiken dat u wilt doen. Raadpleeg de documentatie over het compileren en uitvoeren van uw eerste Java-programma om vanaf de opdrachtregel te worden uitgevoerd .

Nadat u HelloWorld.class hebt, maakt u een nieuwe map en noemt u deze wat u maar wilt.

Maak een ander bestand met de naam manifest.txt en plak erin

Main-Class: HelloWorld
Class-Path: HelloWorld.jar

Plaats het in dezelfde map met HelloWorld.class
Gebruik de opdrachtregel om van uw huidige map ( cd C:\Your\Folder\Path\Here op windows) uw map te maken.

Gebruik Terminal en wijzig de map in de map ( cd /Users/user/Documents/Java/jarfolder op Mac) in uw map

Wanneer dat is gebeurd, typt u jar -cvfm HelloWorld.jar manifest.txt HelloWorld.class en drukt u op Enter. Dit maakt een jar-bestand (in de map met uw manifest en HelloWorld.class) met behulp van de opgegeven .class-bestanden met de naam HelloWorld.jar. Zie het gedeelte Syntaxis voor informatie over de opties (zoals -m en -v).
Ga na deze stappen naar uw map met het manifestbestand en u zou HelloWorld.jar moeten vinden
Als u hierop klikt, wordt Hello, World in een tekstvak weergegeven.

JAR-, WAR- en EAR-bestanden maken

De JAR-, WAR- en EAR-bestandstypen zijn in wezen ZIP-bestanden met een "manifest" -bestand en (voor WAR- en EAR-bestanden) een bepaalde interne map- / bestandsstructuur.

De aanbevolen manier om deze bestanden te maken, is door een Java-specifiek build-hulpmiddel te gebruiken dat de vereisten voor de respectieve bestandstypes "begrijpt". Als u geen build-tool gebruikt, is IDE "exporteren" de volgende optie om te proberen.

( Noot voor de redactie: de beschrijvingen van het maken van deze bestanden kunnen het beste in de documentatie voor de respectieve tools worden geplaatst. Plaats ze daar. Laat wat zelfbeheersing zien en laat ze niet in dit voorbeeld schrikken! )

JAR- en WAR-bestanden maken met Maven

Het creëren van een JAR of WAR met behulp van Maven is gewoon een kwestie van het juiste <packaging> -element in het POM-bestand plaatsen; e, g,

<packaging>jar</packaging>

of

<packaging>war</packaging>

Voor meer details. Maven kan worden geconfigureerd om "uitvoerbare" JAR-bestanden te maken door de vereiste informatie over de entry-pointklasse en externe afhankelijkheden toe te voegen als plug-ineigenschappen voor de maven jar-plug-in. Er is zelfs een plug-in voor het maken van "uberJAR" -bestanden die een applicatie en zijn afhankelijkheden combineren in een enkel JAR-bestand.

Raadpleeg de Maven-documentatie ( http://www.riptutorial.com/topic/898 ) voor meer informatie.

JAR-, WAR- en EAR-bestanden maken met Ant

De Ant-buildtool heeft afzonderlijke "taken" voor het bouwen van JAR, WAR en EAR. Raadpleeg de Ant-documentatie ( http://www.riptutorial.com/topic/4223 ) voor meer informatie.

JAR-, WAR- en EAR-bestanden maken met een IDE

De drie populairste Java IDE's hebben allemaal ingebouwde ondersteuning voor het maken van implementatiebestanden. De functionaliteit wordt vaak omschreven als "exporteren".

• Eclipse - http://www.riptutorial.com/topic/1143
• NetBeans - http://www.riptutorial.com/topic/5438
• Intellij-IDEA - Exporteren

JAR-, WAR- en EAR-bestanden maken met de opdracht jar .

Het is ook mogelijk om deze bestanden met de hand te maken met de opdracht jar . Het is gewoon een kwestie van het samenstellen van een bestandsstructuur met de juiste componentbestanden op de juiste plaats, het maken van een manifestbestand en het uitvoeren van jar om het JAR-bestand te maken.

Raadpleeg de jar opdracht Onderwerp ( JAR-bestanden maken en wijzigen ) voor meer informatie

Inleiding tot Java Web Start

De Oracle Java Tutorials vatten Web Start als volgt samen:

Java Web Start-software biedt de mogelijkheid om complete applicaties met een enkele klik te starten. Gebruikers kunnen applicaties downloaden en starten, zoals een compleet spreadsheetprogramma of een internetchatclient, zonder lange installatieprocedures te hoeven doorlopen.

Andere voordelen van Java Web Start zijn ondersteuning voor ondertekende code en expliciete verklaring van platformafhankelijkheden, en ondersteuning voor codecaching en implementatie van applicatie-updates.

Java Web Start wordt ook wel JavaWS en JAWS genoemd. De primaire informatiebronnen zijn:

• De Java-zelfstudies - Les: Java Web Start
• Java Web Start Guide
• Veelgestelde vragen over Java Web Start
• JNLP-specificatie
• javax.jnlp API-documentatie
• Java Web Start Developers Site

voorwaarden

Op een hoog niveau werkt Web Start door Java-toepassingen te verspreiden die als JAR-bestanden zijn verpakt vanaf een externe webserver. De voorwaarden zijn:

• Een reeds bestaande Java-installatie (JRE of JDK) op de doelcomputer waarop de toepassing moet worden uitgevoerd. Java 1.2.2 of hoger is vereist:

  • Vanaf Java 5.0 is ondersteuning voor Web Start opgenomen in JRE / JDK.
  • Voor eerdere releases wordt ondersteuning voor Web Start afzonderlijk geïnstalleerd.
  • De Web Start-infrastructuur bevat een aantal Javascript dat kan worden opgenomen in een webpagina om de gebruiker te helpen de benodigde software te installeren.

• De webserver die de software host, moet toegankelijk zijn voor de doelmachine.

• Als de gebruiker een Web Start-toepassing gaat starten met een link op een webpagina, dan:

  • ze hebben een compatibele webbrowser nodig, en
  • voor moderne (veilige) browsers moet hen worden verteld hoe ze de browser moeten laten weten dat Java moet worden uitgevoerd ... zonder de beveiliging van de webbrowser in gevaar te brengen.

Een voorbeeld JNLP-bestand

Het volgende voorbeeld is bedoeld om de basisfunctionaliteit van JNLP te illustreren.

<?xml version="1.0" encoding="UTF-8"?>
<jnlp spec="1.0+" codebase="https://www.example.com/demo" 
    href="demo_webstart.jnlp">
    <information>
        <title>Demo</title>
        <vendor>The Example.com Team</vendor>
    </information>
    <resources>
        <!-- Application Resources -->
        <j2se version="1.7+" href="http://java.sun.com/products/autodl/j2se"/>
        <jar href="Demo.jar" main="true"/>
    </resources>
    <application-desc
         name="Demo Application"
         main-class="com.example.jwsdemo.Main"
         width="300"
         height="300">
     </application-desc>
     <update check="background"/>
</jnlp>    

Zoals u kunt zien, is een JNLP-bestand gebaseerd op XML en de informatie bevindt zich allemaal in het element <jnlp> .

• Het kenmerk spec geeft de versie van de JNPL-specificatie waaraan dit bestand voldoet.
• Het codebase kenmerk geeft de basis-URL voor het oplossen van relatieve href URL's in de rest van het bestand.
• Het kenmerk href geeft de definitieve URL voor dit JNLP-bestand.
• Het element <information> bevat metagegevens van de toepassing, inclusief de titel, auteurs, beschrijving en help-website.
• Het element <resources> beschrijft de afhankelijkheden voor de toepassing, inclusief de vereiste Java-versie, OS-platform en JAR-bestanden.
• Het element <application-desc> (of <applet-desc> ) biedt informatie die nodig is om de toepassing te starten.

De webserver instellen

De webserver moet worden geconfigureerd om het application/x-java-jnlp-file als het MIMEtype voor .jnlp bestanden.

Het JNLP-bestand en de JAR-bestanden van de toepassing moeten op de webserver worden geïnstalleerd, zodat ze beschikbaar zijn via de URL's die worden aangegeven door het JNLP-bestand.

Starten via een webpagina inschakelen

Als de toepassing via een webkoppeling moet worden gestart, moet de pagina met de koppeling op de webserver worden gemaakt.

• Als u kunt aannemen dat Java Web Start al op de computer van de gebruiker is geïnstalleerd, moet de webpagina gewoon een koppeling bevatten om de toepassing te starten. Bijvoorbeeld.

  <a href="https://www.example.com/demo_webstart.jnlp">Launch the application</a>
  

• Anders moet de pagina ook wat scripting bevatten om het type browser te detecteren dat de gebruiker gebruikt en om de vereiste versie van Java te downloaden en te installeren.

OPMERKING: Het is een slecht idee om gebruikers aan te moedigen om Java op deze manier te installeren, of zelfs om Java in hun webbrowser in te schakelen zodat het starten van JNLP-webpagina's werkt.

Web Start-toepassingen starten vanaf de opdrachtregel

De instructies voor het starten van een Web Start-toepassing vanaf de opdrachtregel zijn eenvoudig. Ervan uitgaande dat de gebruiker Java 5.0 JRE of JDK heeft geïnstalleerd, hoeft u dit alleen maar uit te voeren:

$ javaws <url>

waarbij <url> de URL is voor het JNLP-bestand op de externe server.

Een UberJAR maken voor een applicatie en zijn afhankelijkheden

Een veelvoorkomende vereiste voor een Java-toepassing is dat deze kan worden geïmplementeerd door een enkel bestand te kopiëren. Voor eenvoudige toepassingen die alleen afhankelijk zijn van de standaardbibliotheken van Java SE-klasse, wordt aan deze eis voldaan door een JAR-bestand te maken dat alle (gecompileerde) toepassingsklassen bevat.

Dingen zijn niet zo eenvoudig als de applicatie afhankelijk is van externe bibliotheken. Als u eenvoudig JAR-afhankelijkheidsbestanden in een JAR-toepassing plaatst, kan de standaard Java-klassenlader de bibliotheekklassen niet vinden en wordt uw toepassing niet gestart. In plaats daarvan moet u een enkel JAR-bestand maken dat de toepassingsklassen en bijbehorende bronnen samen met de afhankelijkheidsklassen en bronnen bevat. Deze moeten worden georganiseerd als een enkele naamruimte voor de classloader om te zoeken.

Een dergelijk JAR-bestand wordt vaak een UberJAR genoemd.

Een UberJAR maken met de opdracht "jar"

De procedure voor het maken van een UberJAR is eenvoudig. (Ik zal voor de eenvoud Linux-opdrachten gebruiken. De opdrachten moeten identiek zijn voor Mac OS en vergelijkbaar voor Windows.)

1. Maak een tijdelijke map en wijzig deze erin.

   $ mkdir tempDir
   $ cd tempDir
   

2. Voor elk afhankelijk JAR-bestand, in de omgekeerde volgorde dat ze op het klassenpad van de toepassing moeten verschijnen, gebruikte u het jar commando om de JAR uit te pakken in de tijdelijke map.

   $ jar -xf <path/to/file.jar>
   

   Door dit te doen voor meerdere JAR-bestanden zal de inhoud van de JAR overlay.

3. Kopieer de toepassingsklassen van de build-structuur naar de tijdelijke map

   $ cp -r path/to/classes .
   

4. Maak de UberJAR op basis van de inhoud van de tijdelijke map:

   $ jar -cf ../myApplication.jar
   

   Als u een uitvoerbaar JAR-bestand maakt, neemt u een geschikte MANIFEST.MF op zoals hier wordt beschreven.

Een UberJAR maken met Maven

Als uw project is gebouwd met Maven, kunt u er een UberJAR van maken met behulp van de "maven-assembly" of "maven-shade" plug-ins. Zie het onderwerp Maven Assembly (in de Maven- documentatie) voor details.

De voor- en nadelen van UberJAR's

Enkele voordelen van UberJAR's zijn vanzelfsprekend:

• Een UberJAR is eenvoudig te verspreiden.
• U kunt de bibliotheekafhankelijkheid voor een UberJAR niet verbreken, omdat de bibliotheken op zichzelf staan.

Als u bovendien de juiste tooling gebruikt om de UberJAR te maken, kunt u bibliotheekklassen die niet worden gebruikt uit het JAR-bestand uitsluiten. Dat dit meestal wordt gedaan door statische analyse van de klassen. Als uw toepassing reflectie, annotatieverwerking en soortgelijke technieken gebruikt, moet u ervoor zorgen dat klassen niet ten onrechte worden uitgesloten.

UberJAR's hebben ook enkele nadelen:

• Als u veel UberJAR's met dezelfde afhankelijkheden hebt, bevat elke exemplaar een kopie van de afhankelijkheden.
• Sommige open source bibliotheken hebben licenties waarvan ¹ het gebruik ervan in een UberJAR kan uitsluiten.

^{1 - Met sommige open source-bibliotheeklicenties kunt u de bibliotheek alleen gebruiken als de eindgebruiker de ene versie van de bibliotheek door een andere kan vervangen. UberJAR's kunnen het vervangen van versie-afhankelijkheden bemoeilijken.}