Dicht am Text

Inhaltsverzeichnis

Viele Entwicklungsumgebungen glänzen heute mit der automatischen Generierung von Applikationen oder Komponenten. So genannte Wizards fragen dabei den Entwickler nach Details und generieren Coderümpfe und - sofern benötigt - Ressourcen-Dateien. Diesen Code vervollständigt der Entwickler und integriert ihn in das Gesamtprojekt. Zwar sind die Vorteile dieses Vorgehens bei der Gestaltung grafischer Oberflächen unumstritten, doch kann sich die Nutzung bei großen, verteilten Anwendungen nachteilig auswirken. So sind die generierten Programmbestandteile oftmals in herstellerspezifische Frameworks integriert und auf bestimmte Anwendungsumgebungen zugeschnitten. Die Einbindung eigener Frameworks ist häufig nur schwer möglich, eigene Coding-Konventionen sind kaum konfigurierbar.

Richtig problematisch gestaltet sich die Nutzung generierter Software jedoch bei der in modernen Software-Entwicklungsprozessen üblichen Überarbeitung von Programmteilen. Ziel dieses Refactoring ist es, aktuelle Erkenntnisse im Projekt auf ältere Bestandteile anzuwenden. So werden Konventionen und Designaspekte geändert, zu aufgeblähte Klassen in Subklassen zerteilt, gemeinsame Schnittstellen herausgezogen oder die Struktur von Methoden und Attributen verändert. Bei umfangreicheren Änderungen im Design können diese Modifikationen eine Vielzahl von Klassen betreffen und mit viel Aufwand verbunden sein [1].

An dieser Stelle versagen die Tools, die ihren Schwerpunkt auf die Erzeugung neuen Codes legen. Gefragt ist vielmehr eine Entwicklungsumgebung, die hilft, den Überblick zu behalten und die Auswirkungen ihres Handelns zu verstehen. Genau diese Absicht verfolgt das Unternehmen IntelliJ aus Prag. Aus einem ursprünglich für den JBuilder von Borland entwickelten Refactoring-Werkzeug entstand die am Programmierer orientierte Entwicklungsumgebung IDEA.

Plattformunabhängige IDEs dank Java

IDEA ist eine Java-Applikation und läuft unter Windows und diversen Unix-Varianten. Die Installation muss ohne den heute üblichen Installer auskommen: Unter Windows ist ein Zip-Archiv, unter Unix eine komprimierte tar-Datei auszupacken. Auf beiden Systemen schließt sich die Anpassung des Startskripts an. Dies klingt anachronistisch, erlaubt aber das parallele Installieren mehrerer Versionen. Laut Hersteller ist ab Version 2.5.2 ein Standard-Installer vorhanden.

Nach dem Start des Programms muss der Anwender seinen bei der Registrierung angegebenen Benutzernamen und den Lizenzschlüssel eingeben. Zum Testen der Software kann er beides über die Website anfordern, sodass drei Wochen für die ersten Schritte zur Verfügung stehen. Eine weitere Möglichkeit ist die Registrierung beim bereits genannten Early Access Program, das spezielle Lizenzschlüssel bereitstellt.

Da die Lizenzdatei unterhalb des IDEA-Installationsverzeichnisses abzulegen ist, braucht der Unix-Anwender Schreibrechte für dieses. Zudem verhindert diese Vorgabe die gleichzeitige Nutzung durch mehrere Entwickler auf demselben System. Hier sollte IntelliJ noch nachbessern.

Ein Java Development Kit liefert IntelliJ nicht mit; IDEA setzt auf ein bereits installiertes auf. So kann der Entwickler zwischen verschiedenen Versionen oder Herstellern wechseln. Dies ist für Kompatibilitätstests praktisch.

Nach dem Start gibt sich die Software modern und in einem zeitgemäßen Look and Feel. Es erscheint der übliche ‘Tip of the Day’-Dialog, den man hier ruhig länger aktiviert lassen sollte. Bei der Einrichtung eines neuen Projekts hilft wie üblich ein Wizard. Unterschiedliche Pfade für Projektdateien, mehrere Quellen und die Ausgabe sind kein Problem. Mit dem Öffnen des so erstellten Projekts gleitet von links die Projektansicht, die sich am angegebenen Projektverzeichnis orientiert, ins Bild. Hier zeigt sich eine der ersten Stärken von IDEA: Nahezu die gesamte Oberfläche gehört dem Editorfenster, von den Rändern gleiten nur bei Bedarf Leisten, die verschiedene Sichten auf das Projekt, Strukturen und Werkzeuge bieten, in das Blickfeld und verkleinern oder überlagern, je nach individuellen Vorlieben, das Editorfenster.

Gleitende Ansichten und großer Editor

Die Schaltflächen - und damit auch die Kante, von der die Fenster in die Oberfläche gleiten - sind pro Fenster konfigurierbar. Standardmäßig finden sich links die Projektansicht, die Strukturansicht der aktuellen Klasse, der Pfad zu den Quellen und der Classpath. Von rechts lassen sich ein einfacher Dateimanager, Javas make-Äquivalent Ant und der Hierarchie-Browser erreichen.

Am unteren Rand sind Fenster für Nachrichten, Suchergebnisse, die Ausgabe von Programmläufen, das Debugging und das CVS zu finden. Allen ist gemein, dass sie erst bei Bedarf oder Klick in den Vordergrund rücken. Nahezu jedes Fenster ist so konfigurierbar, dass es automatisch oder auf Klick wieder verschwindet und andere Fenster überlagert oder verdrängt.

Schnelles Suchen überall

Leisten mit Baumansichten, beispielsweise Projekt oder der Classpath, bieten schnelles Suchen. Durch einfaches Tippen des Elementnamens - und das funktioniert bei den Ansichten von Klassen bis auf Attributebene - kann zu diesem Element navigiert werden. Leider geht das nur, wenn der Baum an der richtigen Stelle aufgeklappt ist. So springt IDEA bei eingeklappten Klassen die eingetippten Attribute nicht an.

Im Editorfenster können mehrere Dateien parallel geöffnet bleiben, sie sind durch oben liegende Tabs aktivierbar. Der Editor entspricht aktuellen Standards, sowohl hinsichtlich der Navigation als der Syntax-Einfärbung. Letztere ist für alle unterstützten Dateitypen (Java, JSP, XML und HTML) getrennt konfigurierbar.

Seine Stärken zeigt der Editor allerdings eindeutig beim Java-Code. Ihn analysiert er im Hintergrund, sodass er Funktionen anbieten kann, die auf der Kenntnis des unterliegenden Codes beruhen. So ist am linken Rand ein blauer Rahmen für den Umfang eines Blocks sichtbar, wenn sich der Cursor auf einer geschweiften Klammer befindet. Am rechten Rand zeigt hingegen ein schmaler Balken, ob der Code syntaktisch korrekt ist. Kleine rote Linien weisen auf Nachbearbeitungsbedarf hin, ein Klick auf eine von ihnen lässt den Cursor sofort an die entsprechende Stelle springen.

Für neue Klassen und Interfaces bietet IDEA Vorlagen, die es mit Variablen versehen gleich ausfüllen kann. Die Vervollständigung neuen Codes mit Ctrl-Leer ist heute Standard. Allerdings bietet IDEA eine besonders ausgereifte Variante an, bei der neben dem Hinzufügen mit Enter ein Überschreiben nach rechts mit Tab möglich ist. Die zulässigen Methoden und Attribute sind mit ihren Rückgabetypen und Parametern übersichtlich dargestellt. Letztere lassen sich bei der weiteren Bearbeitung des Codes mit Ctrl-P in einer kurzen Liste aller Signaturen anzeigen. Weiter kann die Codevervollständigung für die Erzeugung der Variablennamen genutzt werden. Hier schlägt IDEA auf Basis des Typs und individueller Einstellungen Verschiedenes vor - für eine HashMap beispielsweise hashMap und map.

Automatische Vervollständigung mit Komfort

Weitere Hilfen bei der Erzeugung neuen Codes sind die automatische Generierung von Konstruktoren, get- und set-Funktionen, der Dialog zur Implementierung von deklarierten oder abstrakten Methoden oder der für das Überladen von Methoden. Ctrl-Alt-T umrundet den markierten Block mit verschiedenen Konstrukten, zum Beispiel if oder try/catch. Gerade Letzteres ist hilfreich, da IDEA analysiert, welche Exceptions eine Klasse werfen kann und so für jede einen passenden catch-Block erzeugt.

Häufig vorkommende Statements lassen sich gut über die Live-Templates einfügen. Dies sind einfache Makros, die über eine Tastenfolge plus Tab ausgeführt werden. So fügt itit+Tab an der aktuellen Stelle eine Iterator-Schleife ein und bietet in der Codevervollständigung den dazu passenden Iterator an, sofern im aktuellen Block verfügbar. IDEA liefert über 20 Beispiele mit, eigene Templates lassen sich hinzufügen. Hat man das Kürzel des gerade benötigten Live-Templates vergessen, kann eine Art Codeergänzung helfen. Da die Kürzel für Iteratoren jeder Art mit ‘it’ anfangen, genügt ‘it’+Ctrl-J und man ist wieder im Bilde.

Viele Parameter für Codekonventionen

Per Cut and Paste in die aktuelle Datei kopierte Blöcke oder ein komplettierter Klassenname erzeugen automatisch vollständige import-Statements im Dateikopf. Dabei ist die Reihenfolge konfigurierbar - zum Beispiel erst die eigenen, dann alle anderen, schließlich javax.* und zum Schluss java.*, auf Wunsch immer fein mit einer Leerzeile zwischen den Blöcken. Diese Konfiguration wird auch während der Codeformatierung herangezogen, die ebenfalls viele Parameter beeinflussen: Einrückung, Positionen von Klammern, Leerzeilen und vieles mehr. So fällt es leicht, den eigenen Code den Sun Coding Conventions entsprechen zu lassen.

Nun kann IDEA allerdings nicht nur mit Java, sondern auch mit JavaServer Pages (JSPs), HTML und XML umgehen. Die Bearbeitung der letzten beiden ist weniger spektakulär. Ein Live-Template für korrekt schließende Tags steht zur Verfügung, Syntaxeinfärbung ebenfalls, aber das war es bereits. Codevervollständigung auf Basis einer DTD oder eines XML-Schemas kommen erst im nächsten Release. Bei JSPs sieht es besser aus. Java-Statements in ihnen erkennt IDEA in jeder Form richtig. Damit stehen ihnen alle Funktionen des Java-Editors zur Verfügung.

Niemand schreibt laufend neue Software. Oftmals hat es der Programmierer mit altem Code zu tun, womöglich mit solchem, den er nicht selbst entwickelt hat. Beim Refactoring zur regelmäßigen Verbesserung des Codes unterstützt IDEA den Entwickler mit aktiven Refactoring-Methoden und mit vielen Kleinigkeiten, die den Umgang mit bestehendem Code in großen Projekten erleichtert.

Dies beginnt mit der praktischen Suche nach dem Gebrauch einer Klasse, Methode, Variablen oder eines Attributs. Je nach Typ lässt sie sich eingrenzen, zum Beispiel auf den Gebrauch von Methoden, auf die Implementierung oder Lese- beziehungsweise Schreibzugriff. So ist schnell Überblick über das Ausmaß einer Änderung zu gewinnen. Zu solchen Modifizierungen zählt das Umbenennen, für das es im Refactoring-Menü einen eigenen Eintrag gibt. Und dieser ändert einen Bezeichner wirklich anhand seiner Nutzung projektweit, inklusive der eventuellen Anpassung des Dateinamens bei einer Klasse sowie der darauf folgenden Löschung und dem neuen Hinzufügen in ein CVS-Repository.

Sprünge durch unbekanntes Terrain

So kurz sich diese zwei Funktionen auch beschreiben lassen, Suchen und Ersetzen im Kontext der gesamten Anwendung sind nicht trivial und gehören dennoch zum täglichen Brot. Weitere Möglichkeiten zur Navigation durch das unbekannte Terrain stehen mit den umfangreichen Such- und Informationsmöglichkeiten zur Verfügung. Schnelle Sprünge zur Deklaration einer Klasse, zur Klasse einer Variablen oder zur Supermethode erleichtern die tägliche Arbeit. Die Anzeige einer Klassenhierarchie ist dann die letzte für den Einblick in fremde (Code-)Welten nötige Stufe.

Braucht der Entwickler weitere Informationen zu den vorgefundenen Methoden, so lässt sich kurz eine JavaDoc-Hilfe zur Methode unter dem Cursor oder eine Übersicht über die hier möglichen Parameterkombinationen aufrufen. Da lohnt es sich, von allen APIs die JavaDocs zu installieren und ordentlich eigene zu erzeugen. Schön ist zudem, dass diese schnelle Hilfe ebenso wie die ausführliche mit Shift-F1 oder die Navigation auch in der Codevervollständigung funktionieren.

Weiter ist IDEA in der Lage, Methodensignaturen global zu ändern. Bei der Reihenfolge von Argumenten ist das nicht aufregend, beim Löschen von Argumenten ebenfalls nicht. Weniger simpel stellt sich hingegen das Hinzufügen neuer Argumente dar, von der IDE gleich mit Standardwerten belegt.

Aus existierendem Code kann der Programmierer neue Methoden per Shortcut oder Menüeintrag erzeugen. Dabei entfernt IDEA markierten Code und lagert ihn in eine neue Methode aus. So lassen sich zu stark gewachsene Methoden schnell wieder verkleinern. Sind nur verkettete Ausdrücke in Variablen auszulagern, kann man dies mit ‘Introduce Variable’ ebenso komfortabel erreichen oder mit ‘Introduce Field’ zur Erzeugung eines Attributes. Möchte der Entwickler hingegen den Code, der zu einer lokalen, temporären Variablen geführt hat, in eine eigene Methode verschieben, ist hierfür der Menüpunkt ‘Replace Temp with Query’ verantwortlich. Zu dünnen Code führt ‘Inline’ wieder zusammen.

Neuen Code aus altem extrahieren

Bisher spielten sich Änderungen am Code innerhalb einer Klasse ab. Häufig ergeben sich jedoch Interfaces oder neue Superklassen aus einer Klasse, die anfangs direkt implementiert war. Ein typisches Beispiel ist die Anbindung eines externen Systems, die später durch ein Framework für die Anbindung mehrerer gleichartiger Systeme zu ersetzen ist. Dies ist entweder mühsamste Handarbeit oder nur ein paar Mausklicks mit IDEA, das sowohl Interfaces als auch Superklassen aus bestehenden Klassen herausziehen kann.

Abgerundet wird es durch eine automatische Erzeugung und Einsetzung von get- und set-Methoden für Attribute bei genauer Definition der Sichtbarkeit und der Kapselung interner Zugriffe, die Umwandlung lokaler Variablen in Attribute und letztendlich die Konvertierung anonymer in innere Klassen. So lässt sich einiges an Altlasten aufräumen.

IDEA unterstützt CVS als Versionierungssystem, unter Windows auch VisualSourceSafe. Die getestete CVS-Integration kann als gelungen gelten, ersetzt allerdings nicht immer den Umgang mit einem externen CVS-Tool - und sei es die Kommandozeile. Für den Build-Prozess ist Ant integriert. Die Einbindung ist rund und hilft beim Umgang mit den Targets.

Weitere direkt eingebundene Tools sind JUnit für das Unit Testing [2] und Jikes als schneller Java-Compiler von IBM. Damit sind die unterstützten Werkzeuge überaus preiswert, passend zur Preisgestaltung von IDEA selbst. Bedenkt man, dass andere Hersteller für die Integration eines Versionierungssystems die Enterprise-Versionen der IDE voraussetzen, ist dies ein sehr gutes Preis/Leistungsverhältnis.

Was fehlt, sind die internen Werkzeuge zur Gestaltung von GUIs oder verteilten Komponenten. Hier bietet IDEA nichts, da es sich auf den Entwickler direkt konzentriert. Befasst er sich mit der Implementierung einer serverseitigen Applikation und hat einen ausgereiften Build-Prozess, dann fällt dieses Manko kaum auf. Programmierer einer GUI-Applikation oder Einsteiger in der J2EE-Welt werden sich aber schnell mehr Unterstützung wünschen.

Beim Aufspüren ungeliebter Wanzen verhält sich IDEA unspektakulär. Der Debugger ist direkt als Tool-Fenster in die Oberfläche integriert und beherrscht das übliche Durchwandern des Codes, Setzen von Watch- und Breakpoints, die Evaluierung von Ausdrücken und die Modifikation von Variablen. Sofern die dortige JVM richtig gestartet wurde, ist auch das Entwanzen von Programmen auf entfernten Rechnern möglich. Dies erleichtert die Entwicklung verteilter Applikationen.

Bald: Schemas und DTD für XML

IntelliJ verfolgt ein freizügiges Early Access Program, das nach kurzer Registrierung die Evaluierung neuer Versionen zulässt. Über eine Mailingliste tauschen Tester und Entwickler Fehler, Fragen und Antworten aus. Die Erfahrung zeigt, dass die hier angebotenen Versionen in der Regel stabil laufen und bei größeren Fehlern IntelliJ schnell eine bereinigte Version bereitstellt. So waren auf dem Weg zur aktuellen Release 2.5.1 über 30 Builds verfügbar.

Das derzeitige Early Access Program trägt den Namen Ariadna. Es zeigt, wohin die Reise geht. Neben einer erweiterten Unterstützung von J2EE-Anwendungen - es geht wohl nicht mehr ohne - gibt es komplette Unterstützung für XML und JSP im Editor. So kann in XML nun der Code auf Basis einer DTD, eines Schemas oder des zuvor eingetippten Codes mittels Komplettierung bearbeitet und validiert werden. Weiter gibt es für XML eine Strukturansicht mit auf- und zuklappbaren Elementen.

Im JSP-Bereich kommen die Codevervollständigung für Tags und die Unterstützung von Taglibs hinzu. Weitere angekündigte Verbesserungen betreffen unter anderem den Editor, das Refactoring, Produktivitätstools, JavaDoc-Support, das Übersetzen und Debugging sowie Ant.

Fazit

IntelliJ ist mit IDEA ein guter Wurf gelungen. Die Entwicklungsumgebung bringt frischen Wind in die IDE-Szene und begeistert diejenigen, die sie kennen gelernt haben. Die Entwicklung ist noch recht jung, Dokumentation und Online-Hilfe sind gleichermaßen kaum vorhanden. Ebenso wird mancher die diversen Hilfsprogramme für GUIs oder EJBs vermissen. Dafür kosten die hierfür notwendigen Enterprise-Versionen anderer Produkte oftmals das Mehrfache.

Die notwendige Hardware hält sich in Grenzen, ein für Entwicklungszwecke herkömmlicher PC mit mehr als 700 MHz und 256 MByte genügt, ein großer Bildschirm ist dafür nie verkehrt. Auf der Festplatte macht sich IDEA mit 20 MByte nicht besonders breit. Hinzu kommt jedoch der Platz des JDK. Die Performance ist für die gebotene Komplexität und die Tatsache, dass es sich selbst um ein Java-Programm handelt, in Ordnung. Unter Linux sollte man statt des Sun JDK jedoch das von IBM benutzen, da dessen Geschwindigkeit im Grafikbereich deutlich höher ist. Das neue JDK 1.4 wird zwar als Zielplattform unterstützt, nicht jedoch als Laufzeitumgebung für IDEA selbst. Dies kommt erst mit Version 2.6.

Wer viel direkt im, am und mit Code arbeitet, sollte IDEA etwas Zeit widmen. Wer hingegen fertige Enterprise Frameworks und dazu passende Generatoren benötigt, findet in IDEA nicht unbedingt das Werkzeug seiner Wahl.

Frank Müller
ist Entwicklungsleiter bei der OpenKnowledge GmbH in Oldenburg.

Literatur

[1] Oliver Fischer; Software-Entwicklung; Aus alt mach neu; Refactoring verbessert Software; iX 4/2002, S. 151

[2] Peter Fröhlich, Johannes Link; Software-Tests; Kaffeeprobe; JUnit - Entwickeln und Testen in Java; iX 3/2001, S. 108

Mehr Infos

iX-TRACT

• IDEA ist eine in Java geschriebene Entwicklungsumgebung für Java, JSP, HTML und XML.
• Sie ermöglicht ein Arbeiten dicht am Code, was vor allem beim Refactoring hilft.
• Versionierungs- und Buildwerkzeuge sind leicht anzubinden; die Dokumentation ist noch zu spärlich.

Mehr Infos

iX-WERTUNG

[+] leistungsstarker Editor
[+] umfangreiche Codenavigation
[+] Unterstützung von Refactoring
[+] CVS- und Ant-Integration
[+] Preis
[-] Dokumentation
[-] Installation
[-] Geschwindigkeit

Produktdaten
IDEA-Version 2.5.1
Hersteller	IntelliJ
Platzbedarf	Festplatte 20 MByte, RAM je nach Projekt ab 50 MByte
Hardwareanforderungen	aktuelle CPU, mindestens 750 MHz, großer Bildschirm empfohlen
Betriebssysteme	Windows, div. Unix-Varianten
Voraussetzung	JDK Version 1.3.X
Preis	473,68 EUR (Einzellizenz)

(ck)