JavaSeStarterDe

Einstieg in NetBeans: Jave SE - Projekte

Motivation

Bei all der Vielfalt der Möglichkeiten, die eine IDE wie NetBeans bietet, sollte sie auch in der Lage sein, die Entwicklung eines einfachen, ausführbaren Programms ohne nennenswerte Logik mit überschaubarem Aufwand zu unterstützen. Anhand einer solchen einfachen Anwendung soll nun ein grundsätzlicher Einstieg in die Entwicklung von Java SE-Anwendungen mit der IDE erfolgen.

Java SE - Projekttypen

Für die Entwicklung von Java SE - Anwendungen (d.h. Anwendungen, die auf der Java Standard Edition basieren), bietet NetBeans insgesamt fünf versschiedene Projekttypen an, die sich teilweise nur in Details unterscheiden:

File:JavaSeStarterDe/jse-01-types JavaSeStarterDe.jpg

  • 'Java Application' und 'Java Class Library' repräsentieren den allgemeinsten Typ des per NetBeans generierbaren Java SE - Projektes. Einziger Unterschied: Während die 'Class Library' in einer Sammlung von (etwa als .jar verpackbaren) Java-Klassen endet, stellt die IDE für 'Application' bereits zur Erzeugungszeit die Möglichkeit zur Verfügung, eine Start-Klasse zu generieren, die die main(...) - Methode beinhaltet. Gleichermaßen wird für 'Application' während des Builds eine .jar-Datei generiert, die via 'java -jar' ausführbar ist.
  • 'Java Desktop Application' erzeugt, basierend auf 'Java Application', eine leere Struktur für eine Desktop-Anwendung unter Nutzung des Swing Application Framework. Dieses Framework implementiert JSR-296 und soll die Entwicklung von Java-Desktop-Applikationen durch die Bereitstellung einer grundlegenden, anwendungsunabhängigen Infrastruktur vereinfachen. Der entsprechende NetBeans-Projekttyp erzeugt ein leeres Programmfenster und sonstige erforderliche Basisklassen.
  • Die letzten beiden Typen bieten Hilfestellung für die Migration bzw. Nutzung bestehender Source-Trees in NetBeans: 'Java Project From Existing Sources' erlaubt die Generierung eines Projektes analog zu 'Java Class Library' mit dem Unterschied, daß hier der Pfad für Java-Sources, in den per NetBeans erzeugten Projekten normalerweise der Unterordner 'src' im Projektverzeichnis, an beliebiger Stelle im Filesystem liegen und bei der Projekterzeugung eingebunden werden kann. 'Java Free-Form Project', schließlich, ermöglicht den kompletten Import eines Projektes aus Java-Sources mit zugehörigem ant-Buildfile in die IDE, was die Wiederverwendung bestehender Projekte erheblich vereinfacht, aber zur Konsequenz hat, daß Änderungen am Build-Prozess, die sich sonst über die NetBeans-Oberfläche einstellen lassen würden, nur per manueller Modifikation der entsprechenden build.xml erreichen lassen.

Beispiel: SystemProperties

Als minimales Beispiel soll eine Anwendung erzeugt werden, die die System-Properties der Java-Umgebung, erreichbar über
System.getProperties()
, liest und zeilenweise ausschreibt.

Erzeugung und Ansicht

Über "File" -> "New Project" -> "Java" -> "Java Application" aufgerufen, startet der Assistent zur Erstellung einer neuen ausführbaren Java-Anwendung...

File:JavaSeStarterDe/jse-02-newproject JavaSeStarterDe.jpg

... in dem die Felder folgende Bedeutung haben:

  1. Project Name: Name des Projektes (der in der IDE angezeigt wird)
  2. Project Location: Basis-Ordner, in dem NetBeans den Projektordner erzeugen soll
  3. Project Folder: Unterordner für das Projekt im Basis-Ordner, dessen Name dem Projektnamen entspricht
  4. Create Main Class: weist die IDE an, eine Klasse mit main(...) - Methode zu erzeugen

Die IDE ist darauf ausgelegt, parallel mehrere Java-Projekte geöffnet zu haben und zu bearbeiten (was in der Regel der Fall sein wird, da es sich anbietet, häufig und durch mehrere Anwendungen genutzten Code in separate Bibliotheks-Projekte auszulagern). In solch einem Fall läßt sich via Set Main Project ein "Hauptprojekt" markieren, welches ausgeführt wird, wenn in der IDE File:JavaSeStarterDe/js3-03-runbutton JavaSeStarterDe.jpg geklickt (bzw. "Run" -> "Run Main Project" gewählt) wird.

Über "Finish" beendet, erzeugt und öffnet die IDE das Projekt in der Oberfläche. Es zeigt sich:

File:JavaSeStarterDe/jse-04-openedproject JavaSeStarterDe.jpg

  • Im 'Projects'-Fenster ist die Struktur von 'demo.proplist' geöffnet. Unter 'Source Packages' lassen sich die Quelltexte der Java-Klassen im Projekt einsehen, unter 'Test Packages' analog dazu eventuell existente Unit-Tests. Über 'Libraries' und 'Test Libraries' kann der Entwickler durch den Java-Classpath der Anwendung navigieren (der bislang nur das JDK selbst und die junit-Bibliotheken enthält). Interessant an diesem Punkt bereits der Vergleich zwischen "Project" und "File", der zeigt, daß im 'Projects'-Fenster die wesentliche Infrastruktur, die das Projektverzeichnis neben dem eigentlichen Code enthält, versteckt ist, sich die Dateien aus 'src' in 'Source Packages' und analog jene aus 'test' in 'Test Packages' wiederfinden:

File:JavaSeStarterDe/jse-05-fileproject JavaSeStarterDe.jpg

  • Im 'Editor' ist die automatisch erzeugte 'Main'-Klasse geöffnet und mit einem Standard-Gerüst gefüllt, welches sich auch über die Konfiguration der IDE definieren läßt.
  • Im 'Navigator' ist der 'Members View' aktiv, der die Struktur der geöffneten Klasse darstellt (welche sich auf die statische 'main'-Methode beschränkt):

File:JavaSeStarterDe/jse-06-navimembers JavaSeStarterDe.jpg

Über "Run" - > "Run Main Project" (oder den Hotkey F6) läßt sich die Anwendung bereits ausführen. Wenngleich "demo.proplist" bislang noch nichts tut, läßt sich auf diese Weise bereits im 'Output'-Bereich beobachten, wie die IDE arbeitet:

File:JavaSeStarterDe/jse-07-output JavaSeStarterDe.jpg


Arbeit im Projekt

Angesichts der geringen Komplexität des Beispielprojektes läge es nahe, den entsprechenden Code einfach in die automatisch generierte main(...)-Methode zu schreiben; um jedoch ein wenig mehr mit der IDE zu arbeiten, soll eine Hilfsklasse
PropDumper
erzeugt werden, die über eine statische Methode 'dumpProps(Properties props)' ein beliebiges Properties-Objekt in ausgabefähigen String umwandeln können soll.

Um eine neue Klasse im einem Java-Projekt zu erzeugen, existieren mehrere Wege: Zum einen kann über "File" -> "New File..." (oder alternativ "New File" über das Kontextmenu des 'Projects'-Fensters) der allgemeine Assistent zum Erzeugen neuer Objekte aufgerufen werden, bei dem sich die 'Java Class' in der Rubrik 'Java' findet:

File:JavaSeStarterDe/jse-08-classnew-1 JavaSeStarterDe.jpg

Alternativ bietet das Kontextmenu in 'Projects', so ein Eintrag (Paket, Klasse, ...) innerhalb eines Java-Projektes selektiert ist, auch die Möglichkeit, eine Java-Klasse direkt per "New..." -> "Java Class" zu erzeugen,...

File:JavaSeStarterDe/jse-09-classnew-2 JavaSeStarterDe.jpg

..., was im Grunde genommen nur die Typ-Auswahl des vorangegangenen Schrittes überspringt:

File:JavaSeStarterDe/jse-10-classnew-3 JavaSeStarterDe.jpg

Ruft man den Assistenten per Rechtsklick auf ein Java-Package in 'Projects' auf, wird dessen Name ins Feld Package übernommen; ansonsten obliegt es dem Entwickler, erzeugte Klassen nach Möglichkeit in einer sinnvollen Paket-Hierarchie unterzubringen. Nach Abschluß mit "Finish" öffnet NetBeans die neu erzeugte, leere Klasse im Editor, in die folgender Code kopiert werden soll:

public static String dumpProps(Properties props)
{
String value="";
        
for (Object key: props.keySet())
{
value=value+key+" : "+props.getProperty((String)key)+"\n";
}
        
return value;
}

Im Ergebnis zeigen sich danach zwei Erkenntnisse: Zum einen ist der per Copy&Paste eingefügte Code nur grob formatiert und, was aber allenfalls ein ästhetisches Problem ist. Zum anderen zeigen rote Marken im Editor-Fenster, daß die Klasse in dieser Form sich nicht kompilieren lassen wird, da das Symbol 'Properties' noch nicht bekannt ist.

File:JavaSeStarterDe/jse-11-codeedit JavaSeStarterDe.jpg

Der NetBeans-Editor hilft schnell, diese Probleme zu beseitigen: <ALT>+<SHIFT>+<F> 'reformatiert' den Code der Klasse und sorgt dafür, daß Methodendefinitionen, Klammerung etc. einheitlich und lesbar ausgerichtet werden. <CTRL>+<SHIFT>+ organisiert die 'import'-Statements in der Klasse, sorgt hier also dafür, daß java.util.Properties importiert wird:

File:JavaSeStarterDe/jse-12-classfixed JavaSeStarterDe.jpg


Nach dieser Behandlung ist die Klasse PropDumper fehlerfrei, kann die Anwendung fertiggestellt werden durch Einfügen des entsprechenden Code-Segments in die main(...)-Funktion der Main-Klasse:


System.out.println(PropDumper.dumpProps(System.getProperties()));

Nach einer erneuten Ausführung des Projektes zeigt folglich auch das 'Output'-Fenster mehr Aktivität:

File:JavaSeStarterDe/jse-13-run1 JavaSeStarterDe.jpg


Build&Run ohne Oberfläche

Somit ist das erste Projekt, wenn auch mit minimaler Funktion, fertiggestellt, läßt sich kompilieren und ausführen - zumindest von innerhalb der IDE. Einer der großen Vorteile von NetBeans besteht jedoch darin, daß der Build von Java-Projekten auch intern unter Verwendung von ant geschieht, mithin die Projekte notfalls auch ohne NetBeans übersetzt, ausgeführt oder deployed werden können (insbesondere im Falle von Java EE - Entwicklung ein enorm nützliches Feature, wenn man jemals in die Situation kommt, Anwendungen auf dem eigenen Entwicklungs-System mittels SSH oder Telnet aus der Ferne korrigieren und neu starten zu müssen).

Um diesen Mechanismus zu untersuchen, lohnt ein Blick in das Projektverzeichnis im Dateisystem, wahlweise über das 'Files'-Window oder einen File-Manager:

File:JavaSeStarterDe/jse-14-projectfolder JavaSeStarterDe.jpg

build.xml ist das ant-Skript, mit dessen Hilfe das Projekt übersetzt, verpackt, ausgeführt werden kann, wobei build.xml selbst im Wesentlichen auf der NetBeans-Projektkonfiguration im Ordner nbproject/ basiert und ein Set von ant-targets bietet, um mit dem Projekt auch ohne die IDE arbeiten zu können:

File:JavaSeStarterDe/jse-15-antrun-1 JavaSeStarterDe.jpg

Über ant run läßt sich die Applikation ausführen, gegeben, daß eine Klasse mit main(...)-Funktion vorhanden ist,...

File:JavaSeStarterDe/jse-16-antrun-2 JavaSeStarterDe.jpg

... und über ant jar, das Default-Target, wird das Projekt übersetzt, in eine .jar-Datei (<projektname>.jar) verpackt und im Unterverzeichnis dist/ eine Struktur erzeugt, auf deren Basis die Anwendung auf andere Systeme verteilbar ist:

  • In dist/ selbst liegt das (ausführbare) .jar des Projektes sowie eine allgemeine README-Datei.
  • dist/lib/ beinhaltet .jar-Dateien, die eventuell zur Entwicklungszeit im Classpath des Projektes waren und für die Ausführung erforderlich sind.

Die verpackte Anwendung in dist/ läßt sich danach wie gewohnt starten:

File:JavaSeStarterDe/jse17-jar-run JavaSeStarterDe.jpg

Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo