IDE`s im¨Uberblick

IDE’s im Überblick
Vergleich verschiedener Entwicklungsumgebungen
BA Stuttgart AS Horb, Flrorianstr. 15, 72160 Horb am Neckar
Andreas Schwer
Patrick Schilling
Stefan Kramer
Tobias Pfau
Abstract:
Softwareentwicklung findet heute typischerweise mit IDE (Integrierte Entwicklungsumgebung) statt. Dabei haben in den letzten Jahren auf dem Plugin-Konzept basierende Werkzeuge starke Verbreitung gefunden. Im Rahmen der Seminararbeit sind
die Anforderungen an IDE zu ermitteln und einige Plattformen (z.B. Eclipse, NetBeans, JDeveloper, JCreator) genauer zu untersuchen. Außerdem soll das Eclipse PluginKonzept vertieft betrachtet werden.
Inhaltsverzeichnis
1
2
Integrierte Entwicklungsumgebungen
5
1.1
Aufgaben einer IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.2
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
1.3
Beispiele verschiedener IDE’s . . . . . . . . . . . . . . . . . . . . . . .
6
JDeveloper
8
2.1
Core API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.2
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.3
Versionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.1
Java-Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.2
J2EE-Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3.3
Studio-Edition . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
Eigenschaften & Besonderheiten . . . . . . . . . . . . . . . . . . . . . .
9
2.4.1
Complete Lifecycle . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.4.2
Code-Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
2.4.3
Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
2.4.4
Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
2.4.5
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
2.4.6
Application Development Framework . . . . . . . . . . . . . . .
13
2.4.7
Java Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
2.4.8
UML-Modellierung . . . . . . . . . . . . . . . . . . . . . . . . .
13
2.4.9
JSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
2.4.10 Struts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
2.4.11 Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
2.4.12 JUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
2.4.13 CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
2.4
3
IntelliJ
16
3.1
Allgemeines zu IntelliJ . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
3.1.1
Systemvorraussetzungen . . . . . . . . . . . . . . . . . . . . . .
16
3.1.2
Lizenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
3.2
3.2.1
3.3
3.4
4
5
Erfolge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
3.3.1
Codevervollständigung . . . . . . . . . . . . . . . . . . . . . . .
18
3.3.2
Code Layout Manager . . . . . . . . . . . . . . . . . . . . . . .
19
3.3.3
Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
3.3.4
Webanwendungen . . . . . . . . . . . . . . . . . . . . . . . . .
20
3.3.5
Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
3.3.6
Live Templates . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.3.7
Versionskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.3.8
Fehlerverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.3.9
Clipboard Stacking . . . . . . . . . . . . . . . . . . . . . . . . .
23
Erweiterungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
JCreator
26
4.1
Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.2
Besonderheiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.3
Funktionsumfang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
4.3.1
Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
4.3.2
User Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
4.3.3
File Management . . . . . . . . . . . . . . . . . . . . . . . . . .
29
4.3.4
JAVA-Unterstützung . . . . . . . . . . . . . . . . . . . . . . . .
29
4.3.5
JSP-Unterstützung . . . . . . . . . . . . . . . . . . . . . . . . .
30
4.3.6
Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
NetBeans
31
5.1
Allgemeines zu NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . .
31
5.2
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
5.3
Die Anfänge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
5.4
Der Einstieg von Sun Microsystems . . . . . . . . . . . . . . . . . . . .
32
5.5
NetBeans wird Open Source . . . . . . . . . . . . . . . . . . . . . . . .
32
5.6
Funktionen von NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . .
32
5.7
GUI Builder – Matisse . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
5.8
Funktionen des Quelltexteditors . . . . . . . . . . . . . . . . . . . . . .
34
5.9
CVS Unterstützung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
6
5.10 Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
5.11 Erweiterungskonzept von NetBeans . . . . . . . . . . . . . . . . . . . .
38
5.11.1 NetBeans Packs . . . . . . . . . . . . . . . . . . . . . . . . . . .
38
5.11.2 NetBeans Plugins . . . . . . . . . . . . . . . . . . . . . . . . . .
38
Eclipse
40
6.1
Eclipse Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
6.2
Die Entstehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
6.3
Die Eclipse Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
6.4
Platform Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
6.4.1
OSGi-Framework . . . . . . . . . . . . . . . . . . . . . . . . . .
42
Die Eclipse Platform . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
6.5.1
SWT (Standard Widget Toolkit) . . . . . . . . . . . . . . . . . .
43
6.5.2
JFace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
6.5.3
Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
6.5.4
Help / Team / Debug . . . . . . . . . . . . . . . . . . . . . . . .
45
6.5.5
Eclipse RichClient Platform . . . . . . . . . . . . . . . . . . . .
46
JDT - Eclipse IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
6.6.1
JDT - Features . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
Übersicht über Eclips Plugins . . . . . . . . . . . . . . . . . . . . . . . .
47
6.5
6.6
6.7
Abbildungsverzeichnis
49
7
50
Abkürzungen
1
1.1
Integrierte Entwicklungsumgebungen
Aufgaben einer IDE
Die Vorläufer heutiger Entwicklungsumgebungen waren einfache Texteditoren. Mit diesem Programm arbeiteten viele Programmierer, um in Java, PHP oder C++ zu programmieren. Unter Windows ist hier UltraEdit sehr beliebt und weit verbreitet. Unter Linux
sind Emacs oder vi bekannte Texteditoren, die zur täglichen Ausstattung gehören. Macianer nutzen gerne BBEdit. Ein Programmierer braucht heute allerdings viel mehr als nur
einen Texteditor. Er muss im Falle von Java den Compiler aufrufen bzw. den Interpreter
starten. Oder bei der Entwicklung für PHP den Apache-Server mit PHP-Modul starten
bzw. stoppen. Diese Aktivitäten werden oft nebenbei über andere Tools oder Skripte erledigt. So nach und nach wurden die Texteditoren aufgebohrt und verbessert. Viele bieten so
genanntes Syntax-Highlighting an, um bestimmte Schlüsselworte einer Programmiersprache farbig zu markieren. Hinzu kamen oft weitere Verbesserungen, z.B. ein automatisierter
Aufruf des Compilers. Aber oft war ein Texteditor an die Programmiersprache gekoppelt
oder er bot nur für einige ausgewählte Sprachen eine spezielle Unterstützung an. Hinzu
kommt, dass einige Editoren nur auf einem Betriebssystem verfügbar sind (z.B. ist der gute UltraEdit nur für Windows erhältlich und BBEdit gibt es nur für Mac OS Classic bzw.
X).
Die Aufgaben und Fähigkeiten einer Integrierten Entwicklungsumgebung reichen weit
über das Können früherer Texteditoren hinaus. Eine moderne IDE umfasst im Regelfall
folgende Komponenten:
• Texteditor
• Compiler bzw. Interpreter
• Linker
• Debugger
• Teamwork-Unterstützungen
• GUI-Builder
• Build-Tools
• UML-Modellierung
• ...und vieles mehr
Insgesamt kann man sagen, dass man heute Software benötigt, die den gesamten Softwarelebenszyklus unterstützt.
Wer sich auf die Suche nach einer integrierten Entwicklungsumgebung für Java macht,
sieht sich einer beeindruckend großen und zudem stetig wachsenden Auswahl gegenübergestellt. Die Palette reicht von aufgebohrten Editoren bis hin zu umfangreichen Entwick-
lungsstudios mit riesigem Funktionsumfang. Ein ähnliches Spektrum decken auch die
Preise ab: von gratis“ bis für Privatleute unerschwinglich“ ist alles dabei.
”
”
1.2
Geschichte
Die weltweit erste Integrierte Entwicklungsumgebung für die Erstellung von Software
war die Maestro I von Softlab, welche ursprünglich Programm-Entwicklungs-Terminal”
System“ kurz PET“ genannt wurde. Maestro I wurde weltweit 22.000 mal installiert,
”
davon 6.000 mal in der Bundesrepublik Deutschland und war in den 70er und 80er Jahren
führend auf diesem Gebiet.
1975 Erste Vorstellung einer Entwicklungsumgebung: Harald Wieler, Mitgesellschafter
von Softlab, hat einen ersten Prototyp des PET auf Basis des Philips X 1150 Datensammelsystemes seit 1974 entwickelt. Wieler war vorher Architekt (und Programmierer) Betriebssystementwicklung für Großrechner von Radio Corporation of America und Siemens. Die
Entwicklung von Maestro I wurde mit BMFT-Mitteln gefördert. Ziel: interaktiver Programmierplatz für monatlich 1000 Mark.
Eine Woche lang und unermüdlich demonstrierte die charmante Spezialistin des Softlabs,
”
München, Frau Dr. Christiane Floyd - umringt von Trauben von Fachleuten - auf dem
Systems-Stand des Software-Hauses das Programm-Entwicklungs-Terminal-System PET“
– 21. November 1975 Computerwoche.
In den 80er Jahren kamen neben den Integrierten Entwicklungsumgebungen für Standardprogrammiersprachen der dritten Generation solche für 4GL-Programmiersprachen wie z.
B. Natural auf. Auch diese bieten neben der Programmiersprache in einer interaktiven integrierten Entwicklungsumgebung alle Werkzeuge wie: Analyse- und Designwerkzeug,
Texteditor, Maskeneditor, GUI Designer, Compiler bzw. Interpreter, Linker, Debugger,
Quelltextformatierungsfunktion.
1.3
Beispiele verschiedener IDE’s
• Eclipse
• Visual Studio
• NetBeans
• JDeveloper
• JCreator
• IntelliJ
Im folgenden Diagramm 1 sind die vier weit verbreitesten IDE’s mit ihrer prozentualen
Markverteilung angegeben: [1]
Abbildung 1: Top 4 IDE’s
1. Eclipse : 54,05 %
2. Intellij IDEA : 21,62 %
3. NetBeans : 21,62 %
4. JBuilder : 2,7 %
2
JDeveloper
JDeveloper ist eine integrierte Entwicklungsumgebung (IDE von engl. integrated development environment) der Firma Oracle ([8]). Die aktuelle Version trägt die Versionsnummer
10.1.3.3 (Stand 10/2007). Die verwendete Programmiersprache ist Java.
Neben der Entwicklung mit der Programmiersprache Java bietet der JDeveloper für folgende Programmier- und Skriptsprachen Bearbeitungs-Funktionen:
• XML
• SQL
• HTML
• Java Script
Der JDeveloper ist seit 2005 unter der Oracle Technology Network (OTN) Developer Li”
cense“ frei verfügbar und somit für Entwicklung und Deployment kostenlos. Die OTN
”
Developer License Terms “ können unter [9] eingesehen werden. Der JDeveloper ist einzeln oder als Teil der Oracle Business Platform erhältlich und kann über die Webseite der
Firma Oracle (siehe [8]) bezogen werden.
2.1
Core API
Die IDE stellt eine API (engl. Application Programming Interface), also eine Programmierschnittstelle, zu Verfügung mit welcher Erweiterungen geschrieben werden können.
So bauen auch viele weitere Oracle-Produkte auf dieser API auf, z.B. Oracle Business
Intelligence, BPEL und Portal (als Teil der Oracle Business Platform). Ebenfalls baut der
SQL-Developer auf dieser API auf. Zusätzlich gibt es auch ein PHP-Plugin welches über
diese Schnittstelle integriert wird.
2.2
Geschichte
Die erste Version des JDevelopers basiert auf dem JBuilder der Firma Borland (ebenfalls
eine IDE) und ist 1998 erschienen. Im Jahr 2001 wurde eine komplett auf Java-basierende
Neuentwicklung vorgenommen um ein rein Java-basierendes Produkt zu erhalten, die
Versionsnummer wurde damals als 9i“ bezeichnet. Die Versions-Nummer 10g“ führ”
”
te das ADF (engl. Application Development Framework) ein. Die aktuelle Version der
10g“ Entwicklungsreihe ist 10.1.3.3 (Stand 10/2007). Seit März 2007 bietet Oracle ei”
ne Vorschau-Version (Preview) der kommenden Versionen 11g“ an. Unter dem in [11]
”
angegeben Link gibt es weitere Informationen zur Geschichte.
2.3
Versionen
Der JDeveloper wird in drei unterschiedlichen Versionen angeboten. Dies sind die Versionen Java-Edition (Kapitel 2.3.1 auf Seite 9), J2EE-Edition (Kapitel 2.3.2 auf Seite 9) und
Studio-Edition (Kapitel 2.3.3 auf Seite 9). Alle Versionen werden für die Betriebssystem
Windows XP, 2003 und 2000, Linux sowie Max OS X 10.4 und höher angeboten.
2.3.1
Java-Edition
Die Java-Edition ist die Standard-Version und enthält die wichtigsten Programm-Features
einer IDE, so z.B. den Code-Editor und den Debugger. In Kapitel 2.4 auf Seite 9 wird näher
auf die wichtigsten Eigenschaften eingegangen. Die Bestandteile die für die DatenbankEntwicklung nötig sind fehlen, ebenso der UML-Teil sowie die Unterstützung für das Application Development Framework (siehe auch Kapitel 2.4.6 auf Seite 13).
2.3.2
J2EE-Edition
Die J2EE-Version enthält in Abgrenzung zur Java-Edition differenzierte Datenbank- und
UML-Funktionen sowie alle Features der Java-Edition.
2.3.3
Studio-Edition
Die Studio Edition enthält alle Features der Java- und J2EE-Edition und kann als komplet”
te Version“ angesehen werden, da in dieser Version auch das JDK (Java Development Kit)
enthalten ist. Das JDK besteht aus der Java-Laufzeitumgebung JRE (Java Runtime Environment), dem Java-Compiler und diversen Entwicklungswerkzeugen. In Abgrenzung zur
J2EE-Edition können in der Studio-Edition zusätzlich Applikationen nach dem Application Development Framework (siehe auch Kapitel 2.4.6 auf Seite 13) entwickelt werden.
2.4
Eigenschaften & Besonderheiten
Der JDeveloper bietet viele Komfort-Funktionen die dem Benutzer das entwickeln von
Applikationen erleicherten können, die Wichtigsten werden in diesem Abschnitt vorgestellt. Viele Funktionen gelten inzwischen als Trivial und werden nicht mehr dargestellt.
2.4.1
Complete Lifecycle
Der JDeveloper unterstützt die Entwicklung der Applikation während der gesamten Entwicklungsdauer. Die einzelnen Phasen die der JDeveloper in der Entwicklung abdeckt sind
in der folgenden Aufzählung und in der Abbildung 2 auf Seite 10 dargestellt.
Full Life Cycle Support:
1. Design (siehe auch UML (Kapitel 2.4.8 auf Seite 13))
2. Code (siehe auch Code-Editor (Kapitel 2.4.2 auf Seite 10))
3. Debug and Test (siehe auch Debugger (Kapitel 2.4.3 auf Seite 11) und JUnit (Kapitel
2.4.12 auf Seite 15))
4. Analyze
5. Tune
6. Deploy
7. Versioning (siehe auch CVS (Kapitel 2.4.13 auf Seite 15))
Abbildung 2: Full Life Cycle Support (Quelle: [8])
2.4.2
Code-Editor
Der Code-Editor des JDevelopers ist ein moderner Texteditor mit vielen Methoden der
Textmanipulierung, unter anderem bietet er ein Syntax-Highlighting, wodurch wichtige Schlüsselwörter und Sprachelemente der Programmiersprachen durch unterschiedliche
Schrift- und Farbvarienten gekennzeichnet. Diese Funktion ist für den Entwickler von erheblichem Vorteil, da das Syntax-Highlighting die Struktur des Quellcodes besser erkennen lässt. Auch vereinfacht es die Erstellung von XML- und HTML-Dateien erheblich.
Abbildung 3: Code-Editor (Quelle: [8])
Als weiteres Feature besitzt der Code-Editor ein Auto-Vervollständigung von bereits vorhanden Methoden, Klassen oder Objekten, dies spart Tipparbeit und Zeit. Dieses Feature
ist in Abbildung 3 auf Seite 11 dargestellt.
Zur einfacheren Navigation innerhalb eines Projektes gibt es einen Projekt-Explorer welcher einen Überblick über alle eingefügten Klassen und Ressourcen gibt. In diesem sind
die Klassen hierarchisch in einem Projekt-Baum eingefügt. Hierdurch ist ein einfaches
Suchen und Finden von bestimmten Methoden und Klassen möglich.
Der Code-Editor funktioniert nach dem heute üblichen Konzept What you see is what you
”
get“ (WYSIWYG, deutsch Was du siehst, ist was du bekommst“), das heisst Änderungen
”
am Code werden in Echtzeit umgesetzt und die Auswirkungen sind unmittelbar sichtbar.
Dies ist sowohl bei der Bearbeitung von HTML, JSF, JSP und Swing als auch bei der Bearbeitung des Quell-Codes ein Vorteil. Hierdurch ist eine komfortable visuelle Gestaltung
der Bedien-Oberfläche möglich.
2.4.3
Debugger
Der JDeveloper enthält einen modernen Debugger der dem Entwickler die üblichen Funktionen wie Break-Points und dem Anzeigen von Variablen-Inhalten während der Laufzeit
des Programms bietet. Mit dem Debugger reduziert sich der Aufwand für das Auffinden
von Fehler während der Entwicklung deutlich.
2.4.4
Online-Hilfe
Oracle bietet eine Online-Hilfe über die Taste F1“ oder die Menu-Taste Help“ an. In
”
”
ihr befindet sich Hilfe zu den wichtigsten Stichworten und Sprachelementen. Über die
Tastenkombination STRG+D“ können zusätzlich zu jeder Klasse die Informationen der
”
JavaDoc-Dokumentation abgefragt werden.
2.4.5
XML
Abbildung 4: XML-Modeler (Quelle: [8])
Mit dem JDeveloper können XML-Dateien (.XML) visuell erstellt und bearbeitet werden. Zusätzlich können XML-Schema-Dateien (.XSD) mit dem XML-Modeler erstellt,
ein Screenshot dieser Eingabe-Maske ist in Abbildung 4 auf Seite 12 zu sehen.
2.4.6
Application Development Framework
Der JDeveloper unterstützt mit der Studio-Edition (Kap. 2.3.3, Seite 9) die Entwicklung
von Anwendungen mit dem Application Development Framework, kurz ADF. ADF ist ein
Werkzeug mit welchem Applikationen nach dem MVC (Model-View-Controller) Architektur entwickelt werden können.
ADF basiert auf vier Schichten:
1. Business Services
2. Model
3. View
4. Controller
Die letzten drei Schichten basieren auf der MVC-Architektur. Die View-Schicht stellt z.B.
User-Interface (UI) der Applikation zu Verfügung. Dieses kann entweder Serverseitig über
JSP (Java Server Pages) oder JSF (Jave Server Pages) oder Clientseitig über Java Swing
angezeigt werden. Der Controller, steuert den Datenfluß innerhalb der Appikation, bei
Web-Applikationen meist über Struts oder JSF, welche von der Model-Schicht mit den
Business Services verknüpft werden. In dieser Business-Services-Schicht werden Verbindungen mit einer persistenten Datenschicht hergestellt. Das können zum Beispiel relationale Datenbanken oder XML-Dateien sein.
Die Architektur mit den verschiedenen Schichten kann in Abbildung 5 auf Seite 14 eingesehen werden. Weitere Informationen hierzu können auch unter [10] der Oracle Applica”
tion Development Framework FAQ“ nachgesehen werden.
2.4.7
Java Swing
Swing ist eine Java-Bibliothek zum Erstellen von graphischen Benutzer-Oberflächen. Swing
ist Bestandteil jeder Java-Installation und wird somit auch vom JDeveloper unterstützt.
2.4.8
UML-Modellierung
Mit dem JDeveloper können Applikationen unter Verwendung des UML-Models (Unified Modeling Language) entwickelt werden. UML wird eingesetzt um Prozesse als Form
einer Qualitätssicherung, meist graphisch, zu standardisieren. Die Maske für die Erstellung von Use-Cases ist in Abbildung 6 auf Seite 15 dargestellt. Auch Klassendiagramme
können mit UML und dem JDeveloper erstellt werden, als zusätzliche Komfort-Funktion
können daraus dann automatasiert echte“ Java-Klassen mit den jeweils passenden Metho”
denrümpfen erstellt werden. Dieses Feature gibt es erst ab der J2EE-Edtion (Kap. 2.3.2,
Seite 9).
Abbildung 5: Application Development Framework (Quelle: [8])
2.4.9
JSP
Der JDeveloper bietet Funktionen für die Entwicklung von JSP (Java Server Pages). Mit
JSP kann Java-Code innerhalb von HTML- und XML-Dateien eines Web-Servers dynamische Ausgaben erzeugen.
2.4.10
Struts
Der JDeveloper unterstützt die Java-Entwicklung unter Verwendung von Struts. Struts ist
ein freies Framework für die Entwicklung von Web-Applikationen.
2.4.11
Ant
Ant ist ein Entwicklungsprogramm mit welchem, ähnlich dem Programm make“, die
”
Erstellung und Kompilierung von Quellcode automatisiert werden kann. Der JDeveloper
unterstützt Ant.
Abbildung 6: UML Use-Case (Quelle: [8])
2.4.12
JUnit
JUnit ist eine Java-Test-Framework, welches zur Qualitätssicherung innerhalb des JDevelopers eingesetzt werden kann. Dabei werden meist einzelne Methoden oder Klassen
getestet.
2.4.13
CVS
CVS steht für Concurrent Versions System“ und wird zur Versionsverwaltung in der
”
Software-Entwicklung eingsetzt. JDeveloper bietet hier alle nötigen Funktionen um ein
Projekt über einen CVS-Server zu verwalten.
3
IntelliJ
3.1
Allgemeines zu IntelliJ
Die Java Entwicklungsumgebung IntelliJ IDEA ist von der Firma JetBrains und bekam
ihren Namen durch ihr verhalten, d.h. Sie unterstützt den Entwickler durch ein intelligen”
tes“ Verhalten. Die IDE bringt einigs schon mit sich, zum einen bestizt sie einen gut handhabbaren GUI-Generator, weiter besitzt sie auch Funktionen zur Versionierung(Rational
ClearCase, CVS), für Junit, für Ant und Unterstützt J2EE. Da die IDE komplett in Java entwickelt wurde ist sie Betriebssystem unabhängig und kann somit auf fast allen Systemen
benutzt werden. Des weiteren ist das Motto von IntelliJ IDEA develop with pleasure“
”
( entwickle mit Freude“) weshalb sehr auf umfangreiche Hilfefunktionen und niedriger
”
Verbrauch von Rechnerressourcen geachtet wurde
3.1.1
Systemvorraussetzungen
Diese System Voraussetzungen gelten für die aktuelle Version IntelliJ IDEA 7.0.1.[2]
Sprache: Englisch
Betriebssysteme: Windows NT, 2000, XP, 2003, Vista,
Linux,
Mac OS X, Mac OS X/Intel
Voraussetzungen: 800 MHz CPU,
256 MByte RAM,
300 MByte HD,
MacOS X 10.4 oder höher
3.1.2
Lizenz
IntelliJ ist kostenpflichtig für kleine Projekte ist es jedoch möglich eine Testversion zu
downloaden die man drei Monate benutzen kann.
Preise:[2]
3Monate Testversion kostenlos
Schullizenz kostenlos
Private Lizenz 249 USD
Kommerzielle Lizenz 499 USD
3.2
Geschichte
Die Wurzeln der IntelliJ IDEA IDE der polnischen Softwarefirma JetBrains liegen im
Refactoring. Anfangs wurden Refactoring Plugins für damals aktuelle Entwicklungsumgebungen wie z.B. der JBuilder von Borland erstellt. Über diesen Umweg mit den Plugins
wurde dann unter dem Motto IntelliJ: Develop with pleasure eine eigenständige IDE entwickelt, die mittlerweile zu den innovativsten und ausgereiftesten JAVA IDE’s gehört. Der
Name IntelliJ entstand daher, dass man über bestimmte intelligente“ Funktionen dem
”
Entwickler das Programmieren erleichtern wollte.
[7]
3.2.1
Erfolge
Best Java Application - IntelliJ IDEA 6.0
Best Java Debugging Tool - IntelliJ IDEA 6.0
Best Java EE App Dev. Framework - IntelliJ IDEA 6.0
Best Java IDE Environment - IntelliJ IDEA 6.0
Best Team Development Tool - “IntelliJ IDEA 6.0 / TeamCity 1.0
Best Tool for Rich Internet Applications - IntelliJ IDEA 6.0
Best IDE - IntelliJ IDEA 6.0
Best Web Development Tool - IntelliJ IDEA 6.0
IntelliJ IDEA wurde 2005 und 2006 von den über 17.000 Lesern des Java Developer’s
Journal (JDJ) zur besten Java-IDE gewählt.
3.3
3.3.1
Funktionen
Codevervollständigung
Der größte Vorteil der Codevervollständigung Funktion, ist dass man den genauen Aufbau des JDK nicht kennen muss, z.B. weißt IDEA auf vergessene bzw. fehlende importAnweisungen hin oder aber löscht nicht verwendete imports. Diese Funktion kommt vorallem Anfängern entgegen die sich dann mehr um das Programmdesign kümmern könnnen
und nicht erst nach richtiger Syntax und Einstellungen suchen müssen. Dadurch nimmt
IntelliJ auch ein Großteil der Tipparbeit für den Benutzer ab.
Selbstverständl ich können über die Codevervollständigung auch Klassennamen, Variablen, Methoden und Schlüsselwörter vervollständigt werden. Über diese vorgeschlagenen
Werte kann man sich somit auch einen Überblick verschaffen z.B. welche Methoden auf
eine Variable aufgerufen werden können.
Abbildung 7: Beispeil einer Codevervollständigung
[7]
Des Weiteren öffnet sich ein Popup Fenster, beim eingeben eines Methodenaufrufs, in
welchem alle möglichen Methodensignaturen aufgelistet werden, dies ist vor allem bei
Methoden hilfreich die sehr oft überladen wurden. Dazu wird der Entwickler noch weiter
von der IntelliJ IDEA unterstützt, da diese die Jeweilige Parameter Position in der auf
gepopten Parameterliste hervorhebt.
Abbildung 8: Popup Fenster bei Eingabe einer Methode
[7]
3.3.2
Code Layout Manager
Die Funktion des Code Layout Managers liegt darin den Code auf Wunsch des Users neu
und gut leserlich zu formatieren. Dazu bringt er auch noch den Vorteil, dass wenn man
im Team entwickelt man eine einheitlich Formatierung bekommt, ohne vorher erst groß
Regel festlegen zu müssen.
3.3.3
Refactoring
Da die Wurzeln von IntelliJ IDEA im Refactoring liegen wurde natürlich auch viel Wert
auf die Refactoringfähigkeiten gelegt. Hier eine kleine Beschreinung der bekanntesten Refactoring Funktionen[6].
Abbildung 9: alle Refactoringfunktionen im Überblick
[7]
Renaming:
über diese Funktion können Pakete, Klassen Methoden oder Variablen problemlos umbenannt werden. Hierzu wird zu allen betroffenen Sourcen und Referenzen ein Sourcebaum
erzeugt über den, dann die gewünschten Änderungen ganz oder aber auch wahlweise auf
einzelne Teile vorgenommen werden.
Move:
per move Funktion können komfortabel Klassen oder Pakete verschoben werden und die
Vererbungshierarchie wird ggf. angepasst.
Copy:
Klassen können hierdurch einfach kopiert werden, hierzu muss man nur noch den neuen
Klassennamen und der Name des Zielpakets angeben.
Introduce:
ein weiteres Refactoring Mittel ist das Introduce Verfahren, das ermöglich Variablen, Konstanten und Parameter für selektierte Ausdrücke zu erzeugen und eine Wertzuweisung vorzunehmen.
Extract:
Ausgewählte Anweisungen können über eine Extrahierungsfunktion unter Angabe von
Methodenname, Zugriffsmodifizierer und gegebenenfalls Übergabeparameter leicht zu einer Methode umgewandelt werden. Die Ausgliederung von Klasseneigenschaften in Interfaces oder Superklassen lässt sich über Extract Interface bzw. Extract Method bewerkstelligen.
3.3.4
Webanwendungen
Um Webanwendungen entwickeln zu können wurden von den JetBrains Entwicklern die
Technologien JSP und XML in die IDE eingefügt. Dadurch werden die User der IDE bei
der Entwicklung von JSP- bzw. XML-Programmen von der Quelltextvervollständigung
und der Syntaxhervorhebung unterstützt.
3.3.5
Sprachen
Zusätzlich zu Java unterstützt IntelliJ auch noch folgende weiter Sprachen ohne, dass der
Benutzer ein Plugin oder ähnliches installieren muss.
Java Script, Flex
HTML, XHTML, CSS
XML, XSL
Ruby, Jruby
Groovy
3.3.6
Live Templates
Unter Live Templates werden Makros verstanden, die teilweise vordefiniert aber auch vom
Benutzer erstellt werden können. Das Prinzip der Live Templates ist über ein Kürzel und
der Tab-Taste wird der Code vervollständigt.
Z.B. gibt man ein sout ein und drückt danach die Tab-Taste, erhält man ein in dieser Zeile
ein System.out.println( “).
”
3.3.7
Versionskontrolle
Neben den Plugins für alle aktuellen Versionskontollsystemen(CVS, Visual Source Save,
Startteam und ClearCase) bietet IntelliJ IDEA auch noch eine lokale History Verwaltung
mit der man alle Änderungen am Sourcecode überwachen kann und ggf. auf einen älteren
Stand zurück gehen kann.
Da CVS, aus Sicht der IntelliJ Entwicklern das beliebteste Versionskontrollsystem ist, wurde dieses umfangreich in diese Entwicklungsumgebung eingebettet, sodass kein weiterer
externer CVS Client nötig sein wird.
Dafür wurde eine grafische Komponete entwickelt die den Namen CVS File View“ hat.
”
Das CVS File View kann alle Daten in einer Listen- oder in einer Baumstruktur darstellen.
Dazu werden zu jeder Datei ihr Status(geändert, neu, gelöscht, zusammengefügt, Konflikte) angezeigt. Zusätzlich wird auch die CVS Historie mit allen Informationen(Versionsnummer,
Datum, CVS-Kommentar, Tag- und Branch-Angaben) übersichtlich dargestellt.
Darüber hinaus besitzt der CVS File Viewer den sogenannten Differce Viewer, der durch
Angabe einer Versionsnummer oder eines Datums die aktuelle Version mit der gewünschten Version vergleicht. Einen weitere Funktion ist Annotate, über die man sich am linken
Rand des Editors zu jeder Zeile CVS Informationen(z.B. Versionsnummer, Name des Entwicklers, ...) anzeigen lassen kann.
3.3.8
Fehlerverarbeitung
Der Editor dieser IDE erkennt sofort Synataxfehler und unterstreicht diese rot, Warnungen,
Fehler die in der Laufzeit auftreten können, werden gelb hinterlegt. Will man den Grund
eines Fehlers erfahren so muss man mit der Maus nur über die jeweilige Stelle fahren und
eine Fehlermeldung wird angezeigt.
Zusätzlich besitzt IntelliJ noch eine sogenannte Intention Action“, welche Fehlermeldun”
gen und Warnungen analysiert und dafür dann entsprechende Lösungsvorschläge bietet.
Verwendet man beispielsweise eine Anweisung, die eine Exception auslösen kann und es
Abbildung 10: CVS File Client
[7]
Abbildung 11: Feherlmarkierung in IntelliJ IDEA
[7]
Abbildung 12: Verbesserungsvorschläge
[7]
gibt weder eine throws-Deklaration noch einen entsprechenden try...catch-Block, unterbreitet IntelliJ beide Möglichkeiten als Lösungsvorschlag. Wählt man nun einen Lösungsvorschlag aus erzeugt IntelliJ das jeweilige Konstrukt.
Natürlich werden Fehler auch schon durch einfache Funktionen des Editors, wie SyntaxHighlighting, Codestyling und Formatierungsregeln, Farbschemata für verschiedene Dateitypen, übersichtliche Darstellung der geöffneten Dateien durch einzelne Reiter und Nettigkeiten wie das Auf- und Zuklappen von Methoden, symbolische Kennzeichnung von
überschriebenen und implementierten Methoden durch kleine Icons am linken Rand, Splitten des Editors in zwei Teile und ein Werkzeug zum Optimieren der Imports vorgebeugt.
3.3.9
Clipboard Stacking
Die Clipboard Stacking ist eine überaus nützliche Funktion die mit dieser Entwicklungsumgebung mitgeliefert wird. Hier werden in einem Stack mehrer Copy Aufrufe gespeichert, sodass man beim Einfügen auf mehrere kopierte Daten zurück greifen kann.
3.4
Erweiterungen
Die Entwicklungsumgebung wird über Plugins erweitert, die teileweise vom Hersteller
und teilweise von der IntelliJ Community entwickelt werden. Mittlerweile gibt es über
400 Verschidene Plugins, die die IDE um weitere Funktionen bereichern. Die Erweiterungen können auf der Plugin Seite des Herstellers begutachtet und heruntergeladen werden
(http://plugins.intellij.net/).
Grundsätzlich ist zu sagen dass es vom Hersteller JetBrains erwünscht ist, das Plugins für
IntelliJ entwickelt werden. Der Hersteller geht sogar noch ein Stück weiter und veranstalltet Wettbewerbe in denen Entwickler hoch dotierte Preise gewinnen können. Im Folgenden
die 10 beliebtesten und die 10 best bewertesten Plugins:
10 Top Downloads: (Downloads)[5]
1. SQL Query Plugin(98625) SQL Plugin das die JDBC nutzt.
2. IdeaJad(60354) Plugin für den Decompiler JAD
3. GenerateToString(60236) Fügt die toString() Methode in das Genarate Menü ein
4. simpleUML(53065) ermöglicht das erstellen von Klassen-, Abhänigkeits-, Paket
und Sequenzdiagrammen
5. JBoss Integration(50381) erlaubt das konfigurieren und benutzen des Jboss Apllication Servers
6. JunitGenerator(42776) erlaubt das erstellen vom JUnit Tests
7. unitTest(41652) vereinfacht das erstellen und erhalten von Unit Tests
8. RegexPlugin(40110) ein Explorer für Regular Expressions
9. Hibernate Tools(37154) ein Plugin für das Hibernate Framework
10. XPathView + XSLT-Support(34068) Plugin für XPath und XSLT Sprachen
10 Top Rated: (Ratings)[5]
1. ToggelTest(5.0) ermöglicht das springen zwischen dem Code und eines Testprogramms
2. MKS(5.0) Plugin für MKS Source Integrity Versionkontrollsystem
3. Describe Key(5.0) mit diesem Plugin kann man raus finden was für eine Funktion
ein Schlüssel oder ein Shortcut hat
4. Lineage(5.0) erstellt eine Klasse die alle nicht finalen Klassen einbindet
5. FaTPlug(5.0) FTP Plugin
6. Axis TCP Monitor Plugin(5.0) integriet die Apache Axis Engine
7. TunnelliJ(5.0) erlaubt das sniffen einer TCP Verbindung
8. IdeaVIM(5.0) VI Emulator
9. TabRecoder(5.0) Tabellenverarbeitung
10. File Info(5.0) zeigt Informationen über das aktuelle File an
4
JCreator
Abbildung 13: Logo Xinox JCreator
4.1
Allgemeines
JCreator ist eine integrierte Entwicklungsumgebung für JAVA von der Firma Xinox Software.[17]
Xinox Software ist mit dieser Entwicklungsumgebung seit dem Jahr 2000 am Markt und
bietet den JCreator derzeit in der Version 4.5 in zwei Asführungen, einer kostenlosen Lite Edition und einer kommerziellen Pro Version, welche einige zusätzliche Features unterstützt. Die Lite Version ist allerdings nur für kleinere Projekte geeignet, da bei dieser Variante des JCreator einige wichtige Funktionen, wie zum Beipiel ein Debugger, Codevervollständigung oder eine CVS Integration nicht vorhanden sind. Die bessere Pro-Version
der IDE kann beim Hersteller als Trial heruntergeladen werden und muss nach Ablauf der
Testzeit für 89 US$ registriert werden. Eine Übersicht über den genauen Funktionsumfang
der beiden JCreator Versionen wir in Abschnitt 4.3 auf Seite 27 gegeben.
Insgesamt ist diese integrierte Entwicklungsumgebung sowohl für Fortgeschrittene Programmierer als auch für Anfänger im Bereich der JAVA Programmierung ausgelegt. Die
Philosophie des JCreator ist die allgemeine Einfachheit und Übersichtlichkeit der Bedienung, die vor allem Anfängern, den Einstieg in das Arbeiten mit Entwicklungstools
erleichtern sollen. Der Entwickler soll sich voll und ganz auf seine eigentliche Arbeit,
das Programmieren konzentrieren können, und sich nicht durch unverständliche Menüs
quälen.
4.2
Besonderheiten
JCreator wurde im Gegensatz zu den meisten anderen Java Entwicklungsumgebungen
nicht in Java sondern in C++ implementiert. Durch die C++ Implementation ist diese Platform sehr viel performanter und Ressourcen sparender als vergleichbare Softwarelösungen
und ermöglicht ein sehr flüssiges Arbeiten mit der grafischen Bedienoberfläche. Desweiteren ermöglichte es die Entscheidung zu C++ als Programmiersprache eine echtes“ Win”
dows Look & Feel“ bei der Benutzeroberfläche zu erhalten.[15] In Java programmierte
”
Oberflächen erreichen dies meistens nur eingeschränkt und das Look & Feel“ ist einge”
fleischten Windows-Benutzern immer ein wenig fremd. Das flüssiges Arbeiten mit JAVA basierten grafischen Oberflächen erfordert außerdem deutlich schnellere Systeme und
mehr Systemressourcen. Allerdings hat JCreator den Nachteil, dass es nur für Windows
Betriebssysteme erhältlich ist. Abbildung 14 zeigt den Startbildschirm und das typische
Windows Look & Feel“.
”
Abbildung 14: JCreator Start Bildschirm
Für JCreator spricht außerdem der übersichtliche Aufbau und die relativ einfache Bedienung der Oberfläche. Gerade Einsteiger freuen sich, wenn Sie vor dem ersten Kompilieren nicht liebevoll und sorgfältig in der Menüstruktur versteckte Parameter konfigurieren
müssen. Auch laufen JCreator-Benutzer nicht Gefahr, sich von vorlauten Assistenten fertige Applikations-Gerüste monströsen Ausmaßes vorwerfen zu lassen die sie nicht verstehen. Trotzdem finden auch Profis reichlich Möglichkeiten ihre Arbeit zu optimieren.
4.3
Funktionsumfang
JCreator verfügt weitestgehen über alle üblichen Fähigkeiten moderner integrierter Entwicklungsumgebungen. Der IDE fehlt jedoch im Vergleich zu manchen Konkurrenzproukten ein GUI Builder, der nicht einmal in der Pro Version enthalten ist. Der genaue Funktionsumfang des JCreator kann in die Bereiche [16]
• Editor
• GUI
• File Management
• JAVA
• JSP
• Ant
gegliedert werden und wird in den folgenden Unterkapiteln näher erleutert.
4.3.1
Editor
Der Quelltexteditor enthält folgende Features:
• Syntaxhervorhebung
• Zeilennummerierung
• Search and Replace Funktionen
• Auto-Vervollständigung
• Bookmarking
• Intelligente Formatierung und Einrückung des Codes
• Blockauswahl
Die Pro Version enthält zusätzlich die Unterstützung von Code Templates und Macros.
4.3.2
User Interface
Die Benutzeroberfläche von JCreator lässt sich individuell anpassen und konfigurieren. Sie
bietet die üblichen Sichten, wie beispielsweise eine Package-Ansicht oder eine Taskansicht
für Aufgabenlisten. Außerdem gibt es noch eine Klassenansicht und eine Dateiansicht. Die
Abbildung 15 zeigt den Editor mit Java Code Beispiel und den Ansichten Package-View“
”
und File-View“.
”
Beim Anpassen der Oberfläche helfen unterstützende Docking Assistenten, es lassen sich
eigene Buttons definieren man kann Code im Vollscreen Modus bearbeiten. Aus den Menüs
lassen sich diverse Assistenten starten, die das bequeme Erstellen von Projekten über
Projektmanagementfunktionen, Klassen, Schnittstellen, Java Beans und anderem ermöglichen.
Abbildung 15: JCreator User Interface
4.3.3
File Management
JCreator bietet eine Workspace Struktur, in die sich mehrere Projekte integrieren lassen.
Projekte werden in virtuellen Ordnern verwaltet. Dateien können direkt aus der Datei Ansicht des Editors gelöscht, umbenannt, importiert und exportiert werden. Weitere Einstellungen können über den File Properties Viewer vorgenommen werden. In der Pro-Version
verfügt der JCreator außerdem über eine CVS Unterstützung zur Teamarbeit.
4.3.4
JAVA-Unterstützung
• Klassen und Schnittstellen Wizard
• File Splitter
• Projekt Builder
• JDK Tools
• Classpath Management
• Java Console
Die Pro Version enthält außerdem:
• Schnittstellen Wizard
• Java Beans Wizard
• Java Debugger
• Code Vervollständigung
• Context-sensitive Hilfe für Java Klassen, Methoden und Variablen
4.3.5
JSP-Unterstützung
JCreator verfügt standartmäßig ebenfalls über eine JSP-Unterstützung mit speziell eingefärbter Syntaxhervorhebung. In der Professional Ausführung kommt eine Code Vervollständigung für JAVA und HTML Tags und die Unterstützung für spezielle Code Templates hinzu.
4.3.6
Ant
Das Build Tool Ant wird ebenfalls unterstützt und die Syntax besonders hervorgehoben.
In der kostenpflichtigen Version gibt es auch hier weitere Funtkionen die sich wie folgt
darstellen:
• Code-Vervollständigung
• Code-Templates
• Explorer Ansicht
• Zuweisen von IDE Kommandos
5
5.1
NetBeans
Allgemeines zu NetBeans
NetBeans ist eine integrierte Entwicklungsumgebung, die unter einer dualen Lizenz, bestehend aus der Common Development and Distribution License (CDDL) v1.0 und der
GNU General Public License (GPL) v2 steht.
Abbildung 16: NetBeans 5.5.1 – Willkommensbildschirm
Die Entwicklungsumgebung (kurz IDE, Integrated Development Environment) ist komplett in Java geschrieben, daher kann sie grundsätzlich auf allen Plattformen, für welche
eine Java Virtual Machine verfügbar ist, eingesetzt werden. NetBeans ist in erster Linie
für die Entwicklung von Java Programmen erstellt worden, doch durch den modularen
Aufbau kann die IDE auch für Sprachen wie C, C++, Ruby und Fortan verwendet werden. NetBeans verfügt bereits ohne die Installation zusätzlicher Komponenten über einen
GUI-Builder, mit dem sehr einfach Grafische Benutzeroberflächen erstellt werden können.
Außerdem wird vom NetBeans Projekt das NetBeans Framework zur Verfügung gestellt.
Dabei handelt es sich um eine “leere Anwendung”, die lediglich Grundfunktionen zur
Verfügung stellt. Um eine vollwertige Anwendung zu erhalten, muss das Framework nur
noch um die entsprechenden Funktionen erweitert werden.
Informationen zur Entstehung von NetBeans findet man in Absatz 5.2.
5.2
Geschichte
5.3
Die Anfänge
Der Ursprung der Entwicklungsumgebung geht auf das Jahr 1996 zurück. Studenten aus
der Tschechischen Republik riefen das Projekt “Xelfi” ins Leben. Ziel von “Xelfi” war eine
JAVA Entwicklungsumgebung, welche über Funktionen zur einfachen Erstellung von grafischen Benutzeroberflächen (kurz GUI, Graphical User Interface) verfügen sollte. Kurze
Zeit später entstand aus dem Projekt die Firma “NetBeans”. Dabei wurde die Entwicklungsumgebung unter dem Namen “Developer” vermarktet.
5.4
Der Einstieg von Sun Microsystems
Im Oktober 1999 wurde die Firma “NetBeans” von Sun Microsystems übernommen. Kurze Zeit nach der Übernahme wurde “Forté for Java Community Edition IDE” veröffentlicht. Dies basierte zu großen Teilen auf “Developer 3.0” von NetBeans.
5.5
NetBeans wird Open Source
Einige Monate Später, im Juni 2000, wurde “Forté for Java Community Edition IDE” unter
dem Namen “NetBeans” der Open Source Community zur Verfügung gestellt. Heute hat
die Community von “NetBeans” weltweit über 100 Partner, darunter Firmen wie ebay,
Nokia, und Hewlett-Packard[19].
Abbildung 17: Logo von NetBeans
5.6
Funktionen von NetBeans
NetBeans bietet eine Fülle von Funktionen, die den Programmierer bei seiner Tätigkeit
unterstützen. Einige davon werden in den folgenden Absätzen näher erläutert.
5.7
GUI Builder – Matisse
Matisse, der GUI Builder von NetBeans erlaubt das einfache und schnelle Erstellen von
grafischen Benutzeroberflächen. Dabei sind keine tiefgreifenden Java-Kenntnisse zur GUI
Erstellung erforderlich. Der GUI-Builder bringt einen eigenen Layoutmanager (“GroupLayout”) mit. Abbildung 18 zeigt einen Screenshot des GUI-Builders.
Abbildung 18: Matisse – der NetBeans GUI-Builder
Grafische Benutzeroberflächen werden mit Matisse einfach per Drag & Drop erstellt. Hierzu werden einfach die Bestandteile der GUI von der Palette (Bereich 2) auf ein leeres Panel
oder Frame (Bereich 1) gezogen. Bei der Anordnung der Komponenten wird der Anwender von dynamischen Hilfslinien unterstützt. Die Eigenschaften einer Komponente, wie
beispielsweise die Beschriftung eines Buttons, können im Bereich 3 geändert werden.
Hierzu muss man die entsprechende Komponente einfach mit der Maus auf dem Panel
oder Frame auswählen. Es ist auch möglich, die Eigenschaften mehrerer Komponenten
gleichzeitig zu bearbeiten. Hierzu müssen einfach mehrere Komponenten ausgewählt bzw.
markiert werden. In Bereich 4 wird die hierarchische Aufbau der GUI in einem Baum
dargestellt. Aus ihm kann man beispielsweise entnehmen welcher Button welchem Panel zugeordnet ist, außerdem kann hier auch eine Komponente selektiert werden um ihre
Eigenschaften zu bearbeiten.
5.8
Funktionen des Quelltexteditors
Der Quelltexteditor einer Entwicklungsumgebung bietet dem Programmierer, im Gegensatz zu einem herkömmlichen Texteditor, viele Funktionen welche die Codeeingabe deutlich erleichtern. Was der Quelltexteditor von NetBeans bietet wird in den folgenden Absätzen
erläutert.
Syntaxhervorhebung Wörter im Quelltext werden abhängig von ihrer Bedeutung in unterschiedlichen Farben dargestellt. Dadurch wird die Lesbarkeit des Sourcecode deutlich
gesteigert. Abbildung 5.8 zeigt die Syntaxhervorhebung von NetBeans.
Abbildung 19: NetBeans – Syntaxhervorhebung
Codevervollständigung Die Codevervollständigung in NetBeans unterstützt den Programmierer bei der Eingabe des Quellcodes, und kann diese deutlich beschleunigen. Sie
tritt an mehreren Stellen auf. Gibt man den Name eines Pakets ein, werden die im Paket
enthaltenen Klassen und Methoden in einem Auswahlfenster (Abbildung 5.8) angezeigt.
Das selbe Verhalten tritt auch bei der Eingabe eines Objektnamen auf, hier werden jedoch
die zugehörigen sichtbaren Methoden, bzw. Variablen angezeigt. Daneben bietet die Co-
devervollständigung aber auch andere Funktionen, wie das automatische generieren der
Getter- und Setter-Methoden einer Klasse.
Abbildung 20: NetBeans – Syntaxvervollständigung
Refactoring Refactoring bezeichnet die Umgestaltung des Quelltextes eines Computerprogramms. NetBeans stellt hierzu mehrere Funktionen zur Verfügung. In den folgenden
Zeilen werden einige der wichtigsten beschrieben.
Umbenennen Mit dieser Funktion können Klassen, Variablen und Methoden umbenannt
werden. Dabei wird aber deren Gültigkeitsbereich beachtet. Soll beispielsweise ein
Klassenvariable umbenannt werden, und es existiert eine gleichnamige lokale Variable, bleibt letztere unverändert.
Methode extrahieren Diese Funktion verschiebt ein markiertes Stück Quelltext in eine
Methode. Dabei wird falls erforderlich die Parameterliste automatisch generiert.
Methodenparameter ändern Diese Funktion erlaubt das ändern der Parameterliste einer Methode. Es können Parameter hinzugefügt und ungenutzte Parameter entfernt
werden.
In Superklasse/Subklasse verschieben Mit dieser Funktion können Methoden und Variablen in eine abgeleitete bzw. übergeordnete Klasse verschoben werden.
Klasse verschieben Damit kann eine Klasse in ein anderes Paket verschoben werden.
5.9
CVS Unterstützung
CVS (Concurrent Versions System) ist ein weit verbreitetes System zur Versionsverwaltung von Softwareprojekten, an denen auch mehrere Entwickler beteiligt sein können.
Dabei wird der Quellcode zentral auf einem Server gespeichert und vom Entwickler vor
dem bearbeiten “ausgecheckt”. NetBeans unterstützt den Entwickler beim Umgang mit
CVS-Projekten.
5.10
Debugger
NetBeans stellt dem Entwickler auch einen Debugger zur Verfügung. Damit kann er das
Programm zur Laufzeit auf Fehler untersuchen. Mit dem Debugger kann das Programm
zeilenweise durchlaufen werden. Dabei können Objekte und Variablen überwacht, also
ihre Werte beobachtet werden. Abbildung 5.10 zeigt einen Screenshot des Debuggers.
Steuerung des Debuggers Die wichtigsten Funktionen des Debuggers, also die zeilenweise Ausführung eines Programms, können gänzlich über die Tastatur gesteuert werden.
Alternativ stehen in der Debuggersymbolleiste auch Buttons zur Verfügung. In den folgenden Zeilen sind die einzelnen Funktionen aufgeführt, und kurz beschrieben.
Debugger starten (F5) Um die im Folgenden beschriebenen Funktionen nutzen zu können
muss man den Debugger starten. Nachdem Start des Debuggers wird das Programm
normal ausgeführt, bis es auf einen Haltepunkt trifft. Enthält das Programm keine
Haltepunkte, oder ist keiner erreichbar, wird das Programm normal ausgeführt.
Weiterlaufen (Strg + F5) Durch Betätigung der Tastenkombination oder des entsprechenden Buttons wird der Debugger beendet, und das Programm wieder normal
ausgeführt, bis es erneut auf einen Haltepunkt trifft, oder zu Ende ist.
In Methode hineingehen (F7) Diese Funktion führt die nächste Anweisung im Sourcecode aus. Handelt es sich dabei um einen Methodenaufruf, wird der Methodenrumpf
zeilenweise durchlaufen.
Methode verlassen (Strg + F7) Wird durch die vorhergehend beschriebene Funktion
eine Methode zeilenweise durchlaufen, kann mit dieser Funktion zum Ende der Methode gesprungen werden.
Abbildung 21: NetBeans – Debugger
Methode überspringen (F8) Mit dieser Funktion wird der Quelltext ebenfalls zeilenweise durchlaufen. Wird in der aktuellen Zeilen jedoch eine Methode aufgerufen, wird
nicht in diese hineingegangen, sondern das Debugging in der Folgezeile fortgesetzt.
Während dem Debugging ist der Quelltexteditor nicht gesperrt, es können also Änderungen am Quelltext vorgenommen werden. Damit Änderungen jedoch wirksam werden,
muss das debuggen beendet und neu gestartet werden.
Variablen Überwachen In Bereich 2 werden die lokalen Variablen und ihre Werte angezeigt. Zusätzlich kann man auch beliebige Variablen überwachen. Hierzu markiert man die
entsprechende Variable und wählt im Kontextmenü “Variable überwachen” aus oder fügt
sie mit Shift + Strg + F7 zu den überwachten Variablen in Bereich 3 hinzu. Mit
der Überwachungsfunktion können nicht nur Variablen eines primitiven Datentyps überwacht werden, sondern auch Objekte. Letztere werden in einer Baumstruktur hierarchisch
dargestellt (Siehe Abbildung 5.10 Bereich 2, Vector<Double> numbers).
5.11
Erweiterungskonzept von NetBeans
Aufgrund der starken Beliebtheit und großen Verbreitung von NetBeans sind viele Erweiterungen verfügbar. Bei Erweiterungen für NetBeans unterscheidet man zwischen Packs
und Plugins. In den Absätzen 5.11.1 und 5.11.2 wird auf die beiden Erweiterungstyps
ausführlicher eingegangen, und interessante Erweiterungen des jeweiligen Typs vorgestellt.
5.11.1
NetBeans Packs
Packs sind in der Regel größere Erweiterungen, die der IDE zu vielen neuen Funktionen
verhelfen. Beispiele[20] Für Packs sind:
Mobility Pack Diese Erweiterung unterstützt den Programmierer bei der Entwicklung
von Anwendungen für mobile Endgeräte, wie Handys, PDAs und sonstige Geräte,
die die Java Micro Edition unterstützen.
Visual Web Pack Dieses Pack bietet dem Entwickler die Möglichkeit, einfach und intuitiv Benutzerschnittstellen für Webanwendungen per Drag & Drop zu erstellen.
Enterprise Pack Mit dieser Erweiterung erhält der Programmierer Unterstützung bei der
Entwicklung von Java Enterprise-Anwendungen.
Profiler Mit dem NetBeans Profiler kann der Entwickler das Laufzeitverhalten seiner Anwendung untersuchen und verbessern. So können zum Beispiel durch überwachen
der CPU-Last oder der Speicherausnutzung Flaschenhälse entdeckt werden.
C/C++ Pack Durch das C/C++ Pack können mit NetBeans auch Programme in den Sprachen C oder C++ entwickelt werden. Die C/C++ Funktionen beziehen sich nicht nur
auf den Quelltexteditor, sondern auch auf den Debugger.
5.11.2
NetBeans Plugins
Durch Plugins wird der Funktionsumfang von NetBeans erweitert. Es sind freie und kommerzielle Plugins verfügbar. Jeder kann mit NetBeans eigene neue Plugins entwickeln, und
im Internet auf der NetBeans Seite1 anderen zum Download anbieten. In der folgenden
Liste sind einige interessante Plugins[21] für NetBeans aufgeführt und kurz beschrieben.
Plugin Portal Update Center Nach erfolgreicher Installation dieses Plugins, sucht das
NetBeans Updatezentrum auch nach Updates für andere, vom NetBeans Plugin Portal installierte Plugins.
Spellchecker Dieses Plugin überprüft Javadoc Kommentare auf korrekte Rechtschreibung.
1 NetBeans
Plugins im Internet: http://plugins.netbeans.org/
Regular Expression Highlighter Dieses Plugin stellt in der Hauptsymbolleiste von NetBeans ein Textfeld zur Verfügung, in welches reguläre Ausdrücke eingegeben werden können. Zeichenketten im Quelltexteditor, welche den regulären Ausdruck erfüllen,
werden farblich hervorgehoben.
Plugins werden in NetBeans mit Hilfe des Updatezentrums installiert, welches man im
Menü Extras findet. Dabei handelt es sich um einen Assistenten, der einem durch den
Installationsvorgang führt.
6
Eclipse
Abbildung 22: Eclipse Logo [22]
6.1
Eclipse Allgemein
Eclipse ist eine javabasierte, erweiterbare Open Source Plattform für alles Mögliche und
”
nichts im Besonderen“. Es dient zum Einen hauptsächlich als Integrierte Entwicklungsumgebung, aber auch als Basis für Werkzeugintegration und andere Anwendungen. Eclipse selbst ist in JAVA implementiert und ist eine betriebssystemübergreifende Plattform
die zum Beisiel auf Windows, Linux, Solaris, Mac OSX und weiteren Systemen eingesetzt werden kann. Zudem ist das Produkt Open Source“ und steht jedem kostenlos zur
”
Verfügung.
6.2
Die Entstehung
Die Eclipse Plattform entstand als Nachfolger der kommerziellen Entwicklungsumgebung
Visual Age von IBM[24]. Ziel war es, eine leicht erweiterbare Entwicklungsumgebung
für jede erdenkliche Anwendung zu schaffen. Der Gedanke dahinter war, dass es eine offene Plattform ermöglicht, sämtliche Werkzeuge auf einer Plattform zu integrieren, um
den Aufwand für Portierung und Kommunikation bei der Entwicklung zu minimieren.
Eclipse wurde hauptsächlich durch die 1996 von IBM gekauften OTI Labs entwickelt, die
vorher bereits an Visual Age for Java“ und anderen IBM Entwicklungswerkzeugen gear”
beitet hatten. Parallel zum Erscheinen von Version 1.0 und der Freigabe als Open Source“
”
im November 2001 gründete IBM die Eclipse Community, die eine breite Unterstützung
der Plattform sichern und die Anzahl der verfügbaren Plugins schnell vergrößern sollte.
Neben IBM waren bei der Gründung Borland, Merant, QNX, Rational, Red Hat, SuSE,
TogetherSoft und Webgain beteiligt (3, S. 5). Hier zeigt sich eine Besonderheit im Gegensatz zu anderen Open-Source-Projekten: Von Anfang an war es das erklärte Ziel, neben einer Open-Source-Entwicklergemeinde auch ein ”funktionierendes Ökosystem” von
kommerziellen Anbietern zu etablieren. Im März 2003 erschien die Version 2.1 von Eclipse, die den endgültigen Durchbruch als Java IDE bringen sollte. Im Februar 2004 wurde
die Eclipse Community schließlich in eine gemeinnützige Organisation umgewandelt. Dahinter stehen mehrere Unternehmen, u.a. IBM, Hewlett Packard, Intel, SAP AG, Borland,
Rational Software, Red Hat, Suse, OMG, TogetherSoft.
Im Juni 2004 wurde schließlich die Version 3.0 freigegeben. Diese brachte grundlegende
Änderungen in der Architektur der Plattform. Die interne Plugin-Verwaltung wurde komplett auf eine eigene OSGi-Implementierung aufgebaut, so dass Plugins nun zur Laufzeit
ge- und entladen werden können. Zusammen mit einer neuen Aufteilung der verschieden
Komponenten, die den IDE-spezifischen Teil sauber von der Funktionalität als Plattform
trennt, eröffnet die überarbeitete Archtektur völlig neue Möglichkeiten für Eclipse als Basis von Rich-Client- Anwendungen. Aktuell ist Eclipse (Stand 29.11.2007) in der Version
3.3. erhältlich.[23]
6.3
Die Eclipse Architektur
Seit der ersten Version verfolgt Eclipse das Konzept einer reinen Plugin-Architektur. Das
bedeutet, dass nicht nur eine bestimmte Funktionalität über Plugins erweitert werden kann,
sondern praktisch jeder Teil von Eclipse ein Plugin darstellt. Dieser streng komponentenbasierte Ansatz bietet größtmögliche Flexibilität für den Ausbau der Plattform und die
Erweiterung um einzelne Features, sei es durch das Entwicklungsteam von Eclipse oder
durch die Anwender selbst.
Wie in Abbildung 23 zu sehen ist, wird Eclipse wird als Software Development Kit mit
zwei Plugins ausgeliefert, dem Java Development Tooling (JDT), das Eclipse zur Java
IDE erweitert und dem Plugin Developer Environment (PDE), mit dem man neue Plugins für Eclipse entwickeln kann. Damit ist Eclipse nach der Installation eine vollständige
Entwicklungsumgebung und liefert bereits alles, was man braucht um eigene Erweiterungen vorzunehmen. Die beiden mitgelieferten Komponenten sollen neben der Funktionalität, die sie bereitstellen auch als Beispiel und Vorlage für eigene Plugins dienen.
Plugins werden über Extension Points verschachtelt. Ein Plugin baut eine Menge von Erweiterungen (extensions) auf einen oder mehrere Extension Points auf. Die erweiterten
Plugins befinden sich dabei auf derselben oder einer untergeordneten Ebene der PluginHierarchie, normalerweise können mehrere Plugins an einen Extension Point angeschlossen werden. Die Extension Points, die ein Plugin zur Verfügung stellt, werden in einem
Manifest beschrieben.[25] Auf diese Weise ist das Laufzeitsystem in der Lage, sämtliche
Verbindungen zwischen den verschiedenen Komponenten nachzuvollziehen, ohne Exemplare von ihnen erzeugen zu müssen - Plugins werden erst in den Speicher geladen, wenn
ihre Funktionalität benötigt wird. Dieses verzögerte Laden ermöglicht es, Eclipse-basierte
Anwendungen mit einer nahezu unbegrenzten Anzahl von Plugins zu erweitern, da eine
installiertes Erweiterung zunächst so gut wie keine Ressourcen benötigt. Da Plugins über
Abbildung 23: Eclipse Plugin Konzept [26]
die OSGi-Registry auch wieder entladen werden können, lassen sich Anwendugen auf eine
hochgradig flexible Weise mit Plugin-Funktionalität ausstatten.
Konzeptionelle Sicht auf Eclipse:
6.4
Platform Runtime
Die Platform Runtime ist der Kernel von Eclipse, der selbst kein Plugin ist, da er nicht
auf Extension Points anderer Plugins aufsetzt. Die Runtime Verwaltet jedoch Plug-ins und
bietet Extension Points an. Die Runtime Erkennt dynamisch Plug-ins und verwaltet die
Plug-in Registry. Seit der Version 3 verwendet die Platform Runtime das OSGi Framework
(Open Sevice Gateway Initiative).
6.4.1
OSGi-Framework
Die Open Services Gateway Initiative ist ein Industriekonsortium, das eine Softwareplattform für die Verwaltung von Diensten auf Komponentenbasis standardisiert. [29]
Das ursprüngliche Einsatzgebiet von OSGi ist die Automatisierung von elektronischen
Geräten in Haushalten und Fahrzeugen, das Modell passt aber so gut für Eclipse, dass
man sich entschloss, das proprietäre Komponentenmanagement von Eclipse 2 durch eine
eigene OSGi- Implementierung zu ersetzen. Abb. 2: Zustandsdiagramm OSGi-Bundles
Abbildung 24: Konzeptionelle Sicht [27]
OSGi-Komponenten (sog. Bundles) sind, wie Eclipse, in Java geschrieben und bieten
Dienste an, die ¨uber einen OSGi-Server geliefert werden. Dieser hält Informationen über
sämtliche verfügbaren Dienste vor und ¨ubernimmt die Verwaltung des Lebenszyklus. In
Eclipse erfüllt die Laufzeitumgebung die Aufgabe des OSGi-Servers, genauer das Plugin org.eclipse.osgi, das Teil der Laufzeitumgebung ist. Die Eclipse-Plugins bilden das
Äquivalent zu den Bundles von OSGi und bekommen vom Laufzeitsystem mit der Plugin
Registry eine Anlaufstelle für das Auffinden und Registrieren von Diensten zur Verfügung
gestellt.
6.5
Die Eclipse Platform
Die Eclipse Plattform bietet auf verschiedenen Ebenen Möglichkeiten zur Erweiterung und
Nutzung der gelieferten Funktionalität. Eclipse selbst kann über Plugins erweitert werden,
um speziellen Bedürfnissen als Entwicklungswerkzeug zu genügen. Ebenfalls möglich ist
die Nutzung von Eclipse als Plugin-Verwaltung, um beliebige Programme komponentenbasiert erweiterbar zu gestalten. Des weiteren können, aufbauend auf die neue Rich Client
Platform, Eclipse-basierte Anwendungen erstellt werden, die die verschiedenen Elemente
der Plattform nutzen. Und nicht zuletzt bieten die Bibliothek des SWT und das Framework
JFace die Option, losgelöst von der Eclipse Plattform bei der Erstellung von Benutzeroberflächen eingesetzt zu werden.
6.5.1
SWT (Standard Widget Toolkit)
Eclipse ist in Java geschrieben, nutzt aber mit dem Standard Widget Toolkit (SWT) ein
eigenes Framework für das User Interface, das - anders als Java Swing - auf die GUIElemente des Betriebssystemwidgets zurückgreift, wodurch auch die komplex verschach-
telte Eclipse GUI noch relativ performant läuft. Allerdings bedingt diese Tatsache auch,
dass Eclipse nicht der Java-Doktrin ”Code once, run everywhere” folgt, da das SWT nicht
für sämtliche Plattformen portiert wird, auf denen Java läuft. In der Praxis stellt dies allerdings nur eine geringe Einschränkung dar, da die ”drei Großen” im Desktopbereich
(Windows, Linux und OS X) unterst¨utzt werden. Die foglende Abbildung zeigt SWT
Kompinenten auf verschiedenen Platformen.
Abbildung 25: Eclipse SWT [30]
Das SWT bildet eine dünne Schicht, die GUI-Aufrufe über das Java Native Interface direkt an das Betriebssystem weiterleitet. Dies bedingt, dass man - für Java- Programmierer
ungewohnt - Speicherplatz manuell freigeben muss, wenn Widgets nicht mehr benötigt
werden. Allerdings verwaltet das SWT die Elemente in einer Baumstruktur: Wird ein Elternknoten gelöscht, wird auch der Speicher der untergeordneten Elemente freigegeben.
Im Gegensatz zum Java-eigenen Abstract Windowing Toolkit muss man sich beim SWT
nicht mit dem kleinsten gemeinsamen Nenner von Widgets für sämtliche unterstützten
Plattformen begnügen. Elemente, die auf einer Plattform nicht existieren, werden entweder emuliert oder sind schlicht nicht benutzbar. Auch hier ist SWT deutlich von ”Code
once, run everywhere” entfernt, die Zielplattform sollte zum Zeitpunkt der Programmierung bekannt sein.
6.5.2
JFace
Da die Programmierung von SWT (ähnlich wie bei Swing) die Trennung von Modell und
Darstellung stark erschwert, gibt es die Erweiterung JFace. JFace ist ein Framework, das
Viewer als Abstraktion von komplexen SWT-Komponenten wie Dialogen und Wizards bereitstellt. Außerdem verfügt JFace über ein eigenes Ereignismodell für Viewer, mit dem
verschiedene Viewer nach dem MVC-Prinzip verwendet werden können: Viewer sind keine reinen Repräsentationsobjekte der GUI, sondern verwalten auch ihre Dateninhalte wie
z.B. Tabelleneinträge, aber eben streng getrennt in Model und View. Das hat zum Beispiel
den Vorteil, dass verschiedene Viewer auf ein Modell angewendet werden können. Mit
Hilfe von JFace l¨asst sich das SWT auch gut f¨ur komplexe Benutzeroberflächen einsetzen.
6.5.3
Workbench
Die Workbench bedient sich der Elemente aus JFace und SWT und bildet das Eclipse
Plattform User Interface. Es definiert das Zusammenspiel von Editoren, Sichten und Perspektiven. Standartmäßig definiert sind Editoren für Java un XML. Eine Sicht stellet Informationen über andere Objekte zur Verfügung (Task-View, Outline-View) und Perspektiven
fassen Editoren und Views zu einer thematisch bezogenen Einheit zusammen (Java, CVS)
und ist schnell anpassbar und wechselbar für den Benutzer.
Abbildung 26: Workbench von Eclipse
6.5.4
Help / Team / Debug
Help Einbindung in das Online Hilfe System in Form von HTML Online Books
Team Basis für Versions- und Konfigurationsmanagement und gleichzeitige Nutzung von
Ressourcen innerhalb des Teams Konkrete Implementierung: CVS Extension Points
und Repository Provider API ermöglichen Nutzung von Team Repositories
Debug Darauf basiert Java-Debugger-Implementierung
6.5.5
Eclipse RichClient Platform
Seit Version 3.0 (2004) bietet Eclipse eine Rich Client Platform, d.h. es lässt sich ohne IDE-spezifische Funktionen starten und bietet einen extrem flexiblen und portierbaren
Rahmen für beliebige Anwendungen.
Eine der bekanntesten, auf der Eclipse Rich Client Platform basierten Anwendungen ist
der Lotus Notes Client, der in Abbildung 27 dargestellt wird.
Abbildung 27: Lotus Notes Client auf Rich Client Basis [31]
6.6
JDT - Eclipse IDE
Das JDT (JAVA Development Toolkit ist ein Plugin der Eclipse Platform, welches die eigentliche Entwicklungsumgebung darstellt. Dieses Plugin gehört standartmäßig zu Eclipse
und enthält folgende Komponenten:
• JDT-Core: nicht grafischer Teil des JDT (Java-Compieler)
• JDT-UI: Java-Editor + GUIs
• JDT Debug : Debug-User-Interface
• JDT Launching: Start von Anwendungen
• JUnit: TestFramework
6.6.1
JDT - Features
• Java-Editor mit umfangreichen Programmierhilfen
– Projektverwalung
– Syntax-Highlighting
– Content Assist
– Quickfix
– Unterstützung mehrerer installierter Java-Versionen
• Refactoring
• Support von Javadoc
• Generieren von jar-Dateien
• Debugger
• Teamentwicklung
• Ant
• JUnit-Tests
• Verschiedene Perspektiven
– Java
– Java Browsing
– Debug
6.7 Übersicht über Eclips Plugins
Im folgenden sind einige wichtige Plugins aufgelistet. Eine Beschreibung aller bekannter
Plugins wäre kaum möglich, da allein auf der officiellen Homepage www.eclipseplugincentral.com
knapp 1000 Plugins zum Download bereitstehen.[32] (Stand 1.12.2007)
Eclipse Web Tools Platform (WTP) Das WTP ist ein Plug-in von der Eclipse Foundation und bietet Erweiterung von Eclipse für J2EE- und Webentwicklung und eine API
für herstellerspezifische Erweiterungen. Außerdem enthält es Quelltexteditoren für
HTML, Javascript, CSS, JSP und SQL.
WSDL enthält Graphische Editoren für XSD und WSDL, Assistenten und Wizards für
die J2EE Entwicklung und Datenbank Tools
Checkclipse Integriert den Coding Guideline Checker Checkstyle“ in Eclipse und über”
prüft QuellCode auf:
– JavaDoc Kommentare
– Namenskonventionen
– Imports
– Coding Probleme
– Class Design
– Doppelten Code
MyEclipse kommerzielle Eclipse Version – Preis: $30 Standard Edition, $50 Professional Edition Features – J2EE Development Tools – Visual Web Designer – Struts
Designer und Java Server Faces Designer – Database Explorer – EJB, XDoclet, Hibernate und JSTL Support – Application Server Connectors – Tapestry und Spring
IDE Integration – Prof. Edition: MyEclipse UML und Enhanced Oracle Connecto
PMD Plug-in zur statischen Code Analyse Features – Logging – Migrating – JUnit Tests
XMLBuddy Wizards, Validation, Codeassist, Generation für XML, XSD, DTD, XSLT,
XPATH
Sonstige DBEdit, JDBC Client, SQL Editor, Eclipse Profiler, Sysedo Tomcat Launcher,
Omondo Eclipse UML, Together Community Edition for Eclipse, JBossIDE
Abbildungsverzeichnis
1
Top 4 IDE’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2
Full Life Cycle Support (Quelle: [8]) . . . . . . . . . . . . . . . . . . . .
10
3
Code-Editor (Quelle: [8]) . . . . . . . . . . . . . . . . . . . . . . . . . .
11
4
XML-Modeler (Quelle: [8]) . . . . . . . . . . . . . . . . . . . . . . . .
12
5
Application Development Framework (Quelle: [8]) . . . . . . . . . . . .
14
6
UML Use-Case (Quelle: [8]) . . . . . . . . . . . . . . . . . . . . . . . .
15
7
Beispeil einer Codevervollständigung . . . . . . . . . . . . . . . . . . .
18
8
Popup Fenster bei Eingabe einer Methode . . . . . . . . . . . . . . . . .
18
9
alle Refactoringfunktionen im Überblick . . . . . . . . . . . . . . . . . .
19
10
CVS File Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
11
Feherlmarkierung in IntelliJ IDEA . . . . . . . . . . . . . . . . . . . . .
22
12
Verbesserungsvorschläge . . . . . . . . . . . . . . . . . . . . . . . . . .
23
13
Logo Xinox JCreator . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
14
JCreator Start Bildschirm . . . . . . . . . . . . . . . . . . . . . . . . . .
27
15
JCreator User Interface . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
16
NetBeans 5.5.1 – Willkommensbildschirm . . . . . . . . . . . . . . . . .
31
17
Logo von NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
18
Matisse – der NetBeans GUI-Builder . . . . . . . . . . . . . . . . . . . .
33
19
NetBeans – Syntaxhervorhebung . . . . . . . . . . . . . . . . . . . . . .
34
20
NetBeans – Syntaxvervollständigung . . . . . . . . . . . . . . . . . . . .
35
21
NetBeans – Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
22
Eclipse Logo [22] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
23
Eclipse Plugin Konzept [26] . . . . . . . . . . . . . . . . . . . . . . . .
42
24
Konzeptionelle Sicht [27] . . . . . . . . . . . . . . . . . . . . . . . . . .
43
25
Eclipse SWT [30] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
26
Workbench von Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
27
Lotus Notes Client auf Rich Client Basis [31] . . . . . . . . . . . . . . .
46
7
Abkürzungen
IDE
GUI
PDA
CVS
FTP
VI
JDBC
JUint
Integrated Development Environment
Graphical User Interface
Personal Digital Assistant
GNU Concurrent Versions System
File Transfer Protocol
Unix Editor
Java Database Connectivity
Java Testframework
Literatur
[1] Blog Jughh http://blog.jughh.org/?m=200709
[2] Homepage JetBrains, http://www.jetbrains.com/idea/
[3] Documentations, http://www.jetbrains.com/idea/documentation/documentation.html
[4] Wikipedia, http://de.wikipedia.org
[5] Plugin Center, http://plugins.intellij.net/
[6] Wiki Freitagsrunde, https://wiki.freitagsrunde.org
[7] ORDIX News, http://www.ordix.de
[8] Homepage Oracle, http://www.oracle.com
[9] Oracle
Technology
Network
Developer
License
http://www.oracle.com/technology/software/popup-license/jdev-license.html
Terms,
[10] Oracle Application Development Framework FAQ, http://www.oracle.com/technology/products/jdev/htdocs/905/adffaq otn.html
[11] Versionsgeschichte Oracle JDeveloper,
http://radio.weblogs.com/0118231/stories/2005/02/25/historyOfJdeveloperReleases.html
[12] Oracle JDeveloper, http://www.oracle.com/technology/products/jdev/index.html
[13] Oracle JDeveloper Overview,
http://www.oracle.com/technology/products/jdev/collateral/papers/1013/jdev1013 overview.pdf
[14] Oracle JDeveloper Demo Servlet,
http://www.oracle.com/technology/products/jdev/viewlets/1013/JDev complete viewlet swf.html
[15] Homepage JCreator, http://www.jcreator.com/
[16] JCreator Funktionsbeschreibung, http://www.jcreator.com/features.htm
[17] Wikipedia, http://de.wikipedia.org/wiki/JCreator
[18] Artikel zu NetBeans“ bei Wikipedia, http://de.wikipedia.org/wiki/Netbeans
”
[19] NetBeans
Community-Partner,
http://www.netbeans.org/community/partners/listcommunity.html
[20] NetBeans Packs, http://www.netbeans.org/
[21] NetBeans Plugins, http://plugins.netbeans.org/PluginPortal/
[22] Eclipse Logo auf piksu.com, http://www.piksu.com/utils/ohjelmat ammattikayttoon/logo eclipse.jpg
[23] Eclipse Download Portal, http://www.eclipse.org/downloads
[24] Wikipedia, http://de.wikipedia.org/wiki/Eclipse
[25] Eclipse
Plugin
Architektur,
architecture/plugin architecture.html
http://www.eclipse.org/articles/Article-Plug-in-
[26] Hilfeseite auf Eclipse.org,
http://help.eclipse.org/help32/index.jsp?topic=/org.eclipse.platform.doc.user/tips/platform tips.html
[27] FHM Softwarearchitektur Axel Böttcher, http://www.cs.fhm.edu/ boettcha/swa/plugin-dev.pdf
[28] Eclipse Homepage Help, http://help.eclipse.org/help32/index.jsp
[29] OSGi HP, http://www.osgi.org
[30] Eclipse Homepage, http://www.eclipse.org/swt/
[31] Cargal.org Gallerie, http://www.cargal.org/images/gallery/albums/album31/Notes75.jpg
[32] Plugin Central, http://www.eclipseplugincentral.com/