Verwenden von Eclipse-Plugins zum Bearbeiten, Kompilieren, Debuggen und als Basis für Ihre Anwendungen

Dieser Nachtrag zum Artikel von David Gallardo bietet neue Informationen zu Eclipse V3.3.

Was ist Eclipse?

Eclipse ist eine Java-basierte erweiterbare Open-Source-Entwicklungsplattform. Tatsächlich ist es nur eine Entwicklungsumgebung und eine Reihe von Diensten zum Erstellen von Anwendungen, die auf eingebetteten Komponenten (Plugins) basieren. Glücklicherweise wird Eclipse mit einem Standardsatz von Plug-Ins geliefert, einschließlich der bekannten Java Development Tools (JDT).

Während die meisten Benutzer, die Eclipse als Java Integrated Development Environment (IDE) verwenden, damit recht zufrieden sind, hat es noch viel mehr zu bieten. Eclipse enthält auch eine Plugin-Entwicklungsumgebung (PDE), die vor allem für diejenigen interessant sein wird, die Eclipse selbst erweitern möchten, da Sie damit Ihre eigenen Tools erstellen können, die in die Eclipse-Umgebung integriert sind. Da Eclipse vollständig Plug-in ist, haben alle Toolkit-Entwickler die Möglichkeit, Erweiterungen für Eclipse anzubieten und Benutzern eine konsistente und nahtlos integrierte Entwicklungsumgebung (IDE) bereitzustellen.

Diese Integrität und Konsistenz gibt es nicht nur bei Java-Entwicklungstools. Obwohl Eclipse in Java geschrieben ist, kann es auch mit anderen Sprachen verwendet werden. Beispielsweise existieren bereits Plugins (oder werden entwickelt), die solche Programmiersprachen wie C/C++ und COBOL unterstützen. Das Eclipse-Framework kann auch als Grundlage für andere Arten von Anwendungen verwendet werden, die nicht mit der Softwareentwicklung zu tun haben, wie z. B. Content-Management-Systeme.

Ein hervorragendes Beispiel für eine Eclipse-basierte Anwendung ist IBM® Rational® Software Architect (siehe ), das die Grundlage der IBM-Familie von Java-Entwicklungstools bildete.

Eclipse ist Open Source

Open-Source-Software wird unter einer Lizenz veröffentlicht, die den Benutzern bestimmte Rechte garantieren soll. Die offensichtlichste davon ist natürlich, dass der Quellcode den Benutzern zur Verfügung gestellt werden muss und sie jedes Recht haben, die Software selbst zu ändern und weiterzuverbreiten. Dieser Schutz der Nutzerrechte wird durch einen Mechanismus namens „Copyleft“ erreicht: Die Softwarelizenz steht für Urheberrechtsschutz (Copyright) und verbietet die Weiterverbreitung der Software, es sei denn, dem Nutzer werden solche Rechte eingeräumt. Die Copyleft-Lizenz erfordert auch, dass alle von Benutzern vertriebene Software ohne Modifikation von der Originallizenz abgedeckt wird. Damit wird die Bedeutung des Urheberrechts im Wesentlichen auf den Kopf gestellt, und eine Copyleft-Lizenz, die das Urheberrecht nutzt, um dem Benutzer Rechte zu geben, anstatt sie dem Softwareentwickler zu sichern, wird oft scherzhaft als „alle Rechte sind pervertiert“ bezeichnet ( alle Rechte rückgängig gemacht).

Ein Großteil der allgemeinen Angst, Unsicherheit und Zweifel an Open-Source-Software basiert auf der sogenannten viralen Natur einiger Copyleft-Lizenzen. Die Idee ist, dass Sie Ihr geistiges Eigentum verlieren, wenn Sie Open-Source-Software als Teil Ihres eigenen Entwicklungsprogramms verwenden, da die Lizenz Ihre privaten Teile des Programms "kontaminiert". Mit anderen Worten, die Lizenz kann verlangen, dass alle Software, die Open-Source-Software enthält, einschließlich neu erstellter Software, unter derselben Lizenz vertrieben wird. Während dies für die bekannteste Copyleft-Lizenz gilt, die GNU General Public License (unter der beispielsweise Linux® vertrieben wird), gibt es andere Lizenzen, die eine andere Balance zwischen kommerziellen und öffentlichen Interessen finden.

Die Open Software Initiative – OSI (Open Source Initiative) ist eine gemeinnützige Organisation, die klar definiert, was Open Source ausmacht, und Lizenzen zertifiziert, die ihre Kriterien erfüllen. Eclipse wird unter der EPL – Eclipse Public License (Open Eclipse License) V1.0 vertrieben, die von OSI genehmigt wurde und darauf abzielt, die kommerzielle Akzeptanz von Eclipse zu erleichtern, während die Loyalität gegenüber den Autoren des Quellcodes gewahrt bleibt.

Diejenigen, die Plug-Ins für Eclipse erstellen oder Eclipse als Basis für die Softwareentwicklung verwenden, sind verpflichtet, jeden Eclipse-Code, den sie verwenden oder ändern, unter der EPL-Lizenz zu veröffentlichen, es steht ihnen jedoch frei, ihre eigenen Add-Ons nach Belieben zu lizenzieren. Nativer Code, der mit Software von Eclipse gebündelt ist, muss nicht als Open Source lizenziert werden, und der Quellcode selbst muss nicht veröffentlicht werden.

Während die meisten Programmierer Eclipse nicht verwenden werden, um Plug-Ins zu entwickeln oder neue darauf basierende Produkte zu erstellen, ist die Open-Source-Natur von Eclipse nicht nur deshalb wichtig, weil sie Eclipse kostenlos zur Verfügung stellt (und trotz der Tatsache, dass die Lizenz kommerziell orientiert ist). dass Plugins Geld kosten können). Open Source fördert Innovationen und schafft einen Anreiz für Entwickler (auch kommerzielle), ihren Quellcode in die Community einzubringen. Dafür gibt es mehrere Gründe, aber der wichtigste ist vielleicht, dass je mehr Entwickler zum Projekt beitragen, desto wichtiger wird es für alle. Und wenn ein Projekt nützlich wird, werden es immer mehr Entwickler verwenden und eine Community darum herum aufbauen, ähnlich denen, die sich um Apache und Linux gebildet haben. (Weitere Informationen zu Lizenzen finden Sie im Abschnitt.)

Was ist Eclipse?

Eclipse ist eine Open-Source-Entwicklergemeinschaft, deren Projekte darauf abzielen, eine offene Entwicklungsplattform aufzubauen, die aus erweiterbaren Entwicklungsumgebungen, Tools und Laufzeitbibliotheken zum Erstellen, Bereitstellen und Verwalten von Software während ihres Lebenszyklus besteht. Die Eclipse Foundation ist eine gemeinnützige, von Mitgliedern unterstützte Vereinigung, die Eclipse-Projekte hostet und dabei hilft, die Open-Source-Community und das Ökosystem komplementärer Produkte und Dienstleistungen voranzubringen.

Das Eclipse-Projekt wurde im November 2001 von IBM ins Leben gerufen und von einem Konsortium von Softwareanbietern unterstützt. Die Eclipse Foundation wurde im Januar 2004 als unabhängige, gemeinnützige Organisation gegründet, die als Verwalter der Eclipse-Community fungiert. Es wurde geschaffen, um eine herstellerunabhängige, offene und transparente Community rund um Eclipse wachsen zu lassen. Die heutige Eclipse-Community besteht aus Einzelpersonen und Organisationen, die die Softwareindustrie repräsentieren.

Die Eclipse Foundation überwacht und leitet die laufende Entwicklung von Eclipse. Die Stiftung dient der Community, nennt aber Open-Source-Entwickler Committer und tatsächlich gehören diejenigen, die an Eclipse-Projekten arbeiten, nicht zu seinen Mitarbeitern. Typischerweise sind Eclipse-Committer in einer Organisation oder sind unabhängige Entwickler, die ihre Zeit freiwillig für die Arbeit an einem Open-Source-Projekt zur Verfügung stellen.

Nachdem wir uns nun die theoretischen, historischen und politischen Aspekte von Eclipse angesehen haben, werfen wir einen Blick auf das Produkt selbst.

Eclipse-Arbeitsbereich

Wenn Sie Eclipse zum ersten Mal starten, sehen Sie eine Willkommensseite im Arbeitsbereich (siehe Abbildung 1). Der Eclipse-Benutzer hat mehrere Möglichkeiten, zur Übersichtsseite zu navigieren, was ich empfehle (siehe Abbildung 2). Als Nächstes können Sie Informationen zu neuen Funktionen lesen, einige Beispiele untersuchen oder ein Tutorial absolvieren.

Abbildung 1. Eclipse-Willkommensseite

Abbildung 2. Eclipse-Übersichtsseite

Der Eclipse-Arbeitsbereich besteht aus mehreren so genannten Panels Darstellungen, wie Navigator- oder Gliederungsansichten. Die Menge solcher Darstellungen heißt Perspektive. Eine der gebräuchlichsten Perspektiven ist die Ressourcenperspektive, bei der es sich um einen grundlegenden Satz von Ansichten zum Verwalten von Projekten und zum Anzeigen und Bearbeiten von Projektdateien handelt.

Ich empfehle den meisten unerfahrenen Benutzern, mit der in Abbildung 2 gezeigten Übersichtsseite zu beginnen und mehr über Eclipse zu erfahren. Der Abschnitt Workbench-Grundlagen enthält viele nützliche Einstiegsinformationen zu den verschiedenen Eclipse-Komponenten und deren Zusammenspiel. Nehmen Sie sich ein paar Minuten Zeit, um dieses Material zu lesen, und lassen Sie uns dann in die Java Development Tools (JDT) von Eclipse eintauchen. Der beste Weg, etwas zu lernen, ist, es auszuprobieren.

In Fortsetzung dieser kurzen Tour durch Eclipse werden wir ein neues Java-Projekt erstellen. Auswählen Datei > Neu > Java-Projekt (Datei > Neu > Java-Projekt) und geben Sie Hello ein, wenn Sie nach einem Projektnamen gefragt werden, und klicken Sie dann auf Fertig.

Schauen wir uns nun die "Java"-Perspektive an (falls Sie noch nicht dort sind). Je nachdem, wie Sie Ihren Bildschirm steuern möchten, können Sie entweder die Perspektive des aktuellen Fensters ändern, indem Sie auswählen Fenster > Perspektive öffnen > Java (Fenster > Perspektive öffnen > Java), oder öffnen Sie ein neues Fenster, indem Sie auswählen Fenster> Neues Fenster (Fenster> Neues Fenster), und wählen Sie eine neue Perspektive.

Wie Sie vielleicht erwarten, verfügt die Java-Perspektive über eine Reihe von Ansichten, die für die Java-Entwicklung entwickelt wurden. Einer von ihnen, der sich in der oberen linken Ecke befindet, ist eine Hierarchie, die verschiedene Java-Pakete, Klassen, JAR-Archive und verschiedene Dateien enthält. Diese Ansicht wird Paket-Explorer genannt. Bitte beachten Sie, dass dem Hauptmenü zwei neue Elemente hinzugefügt wurden: Source und Refactor.

Java-Entwicklungstools (JDT)

Um die Java-Entwicklungsumgebung auszuprobieren, werden wir eine Anwendung namens „Hello World“ erstellen und ausführen. Klicken Sie aus der Java-Perspektive mit der rechten Maustaste auf den Quelltestordner des Projekts „Hello“ (src) und wählen Sie ihn aus Neu> Klasse (Neu> Klasse), wie in Abbildung 3 gezeigt. Geben Sie im angezeigten Dialogfeld Hello als Klassennamen ein. Unterhalb der Inschrift Welche Methoden-Stubs möchten Sie erstellen? (Welche Methoden-Stubs möchten Sie erstellen?) Hinweis public static void main(Stringargs) und drücke Fertig.

Abbildung 3. Erstellen einer neuen Klasse in der Java-Perspektive

Dadurch wird eine .java-Datei mit der Hello-Klasse und einer leeren main()-Methode im Editorbereich erstellt, wie in Abbildung 4 gezeigt. Fügen Sie der Methode den folgenden Code hinzu (beachten Sie, dass die Beschreibung für ich bewusst weggelassen).

Abbildung 4. Die Hello-Klasse im Java-Editor

Während Sie tippen, werden Sie einige der Funktionen des Eclipse-Editors bemerken, einschließlich Syntaxprüfung und Codevervollständigung. Wenn Sie außerdem eine öffnende Klammer oder doppelte Anführungszeichen eingeben, fügt Eclipse automatisch ein schließendes Paar dafür ein und platziert den Cursor in der Mitte.

In anderen Fällen können Sie mithilfe der Kombination eine automatische Codevervollständigung auslösen Strg+1. Die Codevervollständigungsfunktion erzeugt eine kontextsensitive Liste von Optionen, aus denen Sie mit der Tastatur oder der Maus auswählen können. Varianten können eine Liste von Methoden sein, die für ein bestimmtes Objekt spezifisch sind, oder ein Stück Code, das auf verschiedenen Schlüsselwörtern wie for oder while basiert.

Die Syntaxprüfung hängt von der inkrementellen Kompilierung ab. Während Sie Code speichern, wird er im Hintergrund kompiliert und auf Syntaxfehler überprüft. Standardmäßig werden Syntaxfehler rot unterstrichen und am linken Rand erscheint ein roter Punkt mit einem weißen X. Andere Fehler sind am Rand des Editors mit einem Glühbirnensymbol gekennzeichnet; Dies sind Probleme, die der Editor für Sie beheben könnte (eine Funktion namens Quick Fix).

Im obigen Code befindet sich das Glühbirnenzeichen neben der for-Anweisung, da die Beschreibung für i weggelassen wurde. Wenn Sie auf eine Glühbirne doppelklicken, wird eine Liste mit vorgeschlagenen Korrekturen angezeigt. In unserem Fall wird vorgeschlagen, ein Klassenfeld i , eine lokale Variable i oder einen Parameter i für die Methode zu erstellen; Wenn Sie eine dieser Optionen mit der Maus auswählen, wird der Code angezeigt, der generiert wird. Abbildung 5 zeigt die Liste der vorgeschlagenen Optionen und den vorgeschlagenen Code im Fall einer lokalen Variablen.

Abbildung 5. Optionen, die von der Quick Fix-Funktion angeboten werden

Ein Doppelklick auf einen Satz fügt den Code an der richtigen Stelle im Programm ein.

Wenn das Programm ohne Fehler kompiliert wird, können Sie es ausführen, indem Sie auswählen Laufen im Eclipse-Menü. (Beachten Sie, dass es keinen separaten Kompilierungsschritt gibt, da die Kompilierung beim Speichern des Codes erfolgt. Wenn Ihr Code keine Syntaxfehler aufweist, kann er ausgeführt werden.) Das Dialogfeld "Launch Configurations" wird mit den richtigen Standardwerten angezeigt. klicken Laufen unten rechts. Im unteren Bereich wird ein neues Registerfeld (Konsole) angezeigt, in dem die Ausgabe des Programms angezeigt wird, wie unten gezeigt.

Abbildung 6. Das Ergebnis des Programms

Sie können das Programm auch im Java-Debugger ausführen. Zuerst müssen Sie einen Haltepunkt in main() System.out.println() setzen, indem Sie auf das graue Feld auf der linken Seite des Bearbeitungsfelds neben dem Aufruf von System.out.println() doppelklicken. Es erscheint ein blauer Punkt. Auf der Speisekarte Laufen eine Mannschaft auswählen Debuggen. Wie zuvor beschrieben, wird das Dialogfeld "Launch Configurations" angezeigt. Wähle ein Team Laufen. Die Perspektive wechselt automatisch zur Debug-Perspektive, die eine Reihe interessanter neuer Ansichten enthält, wie unten gezeigt.

Abbildung 7. Debug-Perspektive

Beachten Sie die Debug-Ansicht in der oberen linken Ecke der Perspektive. Diese Ansicht zeigt den Aufrufstapel und enthält eine Symbolleiste in der Titelleiste, mit der Sie die Programmausführung steuern können. Das Bedienfeld verfügt über Schaltflächen zum Fortsetzen, Anhalten oder Beenden des Programms, zum Wechseln zur nächsten Anweisung, zum Überspringen der nächsten Anweisung oder zum Zurückkehren von einer Methode. Das Bedienfeld oben rechts enthält eine Reihe von Registerkartenansichten, darunter Variablen (Variablen), Haltepunkte (Kontrollpunkte), Ausdrücke (Ausdrücke) und Anzeige (Anzeige). Die Registerkarte Variablen ist jetzt ausgewählt, sodass wir den aktuellen Wert der Variablen i sehen können.

Ausführlichere Informationen zu den Ansichten erhalten Sie über die Kontexthilfe; Klicken Sie dazu auf den Titel der Ansicht und klicken Sie auf F1.

Zusätzliche Plugins

Neben Plugins wie JDT zum Bearbeiten, Kompilieren und Debuggen von Anwendungen gibt es Plugins, die den gesamten Entwicklungsprozess unterstützen: Modellierung, Build-Automatisierung, Komponententests, Leistungstests, Versionierung und Konfiguration.

Eclipse enthält ein Concurrent Versions System (CVS)-Plugin für die Quellcodeverwaltung. Das Team-Plug-in stellt eine Verbindung zu einem CVS-Server her, sodass Mitglieder eines Entwicklungsteams an einer Reihe von Quelldateien arbeiten können, ohne die von anderen vorgenommenen Änderungen zu beeinträchtigen. Auf das Source-Management von Eclipse gehen wir hier nicht näher ein, da hierfür die Installation eines CVS-Servers erforderlich ist, obwohl die Unterstützung eines Entwicklungsteams, nicht nur die Eigenentwicklung, ein wichtiger und fester Bestandteil von Eclipse ist.

Plug-ins, die von der Eclipse Foundation verwaltet und vertrieben werden, finden Sie auf der Eclipse-Website. Die vollständigste Liste der verfügbaren Plug-ins ist auf der Eclipse Plug-in Central-Seite verfügbar, die als Verzeichnis der Plug-ins dient.

Architektur der Eclipse-Plattform

Die Eclipse-Plattform enthält eine Reihe leistungsstarker Plugins (siehe Abbildung 8), die Projekte wie JDT und PDE unterstützen.

Abbildung 8. Vereinfachte Architektur der Eclipse-Plattform

Die dunkelblauen Kästchen stellen die Komponenten dar, die den zentralen Teil der Rich Client Platform (RCP) in Eclipse bilden. Das Konzept von RCP selbst geht über den Rahmen dieses Artikels hinaus, aber stellen Sie sich RCP einfach als eine Reihe von Plug-Ins von Eclipse vor, die Benutzer bei der Anwendungsentwicklung verwenden können, z. B. Lotus Notes® 8. Die hellblauen Kästchen stehen für optionale ( obwohl empfohlen) Komponenten in RCP-basierte Anwendungen zu aktivieren. Und die grauen Blöcke sind komplett optional. Die Plattform besteht aus mehreren Komponenten, wir werden uns einige davon ansehen:

Laufzeit Die Laufzeit ist der Code, der das Eclipse-Plug-In-Modell basierend auf der OSGi-Spezifikation und dem Konzept von Erweiterungen und Erweiterungspunkten definiert. Runtime bietet auch zusätzliche Dienste wie Syslog und Parallelität. JFace/SWT Das Standard Widget Toolkit (SWT) ist eine Reihe von Widgets, die für die Benutzeroberfläche und Funktionalität von Eclipse verantwortlich sind. JFace ist einfach ein Add-On zu SWT, das mehrere Model-View-Controller (MVC)-Klassen bereitstellt, um die Entwicklung grafischer Anwendungen zu erleichtern. Werkbank (Arbeitsbereich) Der Arbeitsbereich verleiht Eclipse seine Persönlichkeit. Auf dieser Ebene wird das Konzept von Ansichten, Perspektiven und Dingen wie Bearbeitungsfenstern implementiert. Hilfe (Benutzerunterstützung) Mit dieser Eclipse-Komponente können Sie Ihren Benutzern Support leisten. Dies kann über das Hilfesystem erfolgen, das es Benutzern ermöglicht, nach Hilfedokumentation zu suchen, oder über Spickzettel, die Endbenutzern als interaktive Aufgabenlisten präsentiert werden können. Aktualisieren Die Aktualisierungskomponente bietet Eclipse die Möglichkeit, Anwendungen von einer Version auf eine andere zu aktualisieren. Mannschaft (Mannschaft) Die Team-Komponente ist ein Framework, das es Entwicklern ermöglicht, ihre eigenen Versionskontrollsysteme einzubinden. Eine beispielhafte Anbieterimplementierung ist das in Eclipse integrierte CVS-Plugin.

Fazit

Aus dem von IBM geschriebenen Originalcode hat sich Eclipse zu einem voll funktionsfähigen Open-Source-Ökosystem mit mehr als 100 teilnehmenden Unternehmen entwickelt. Ein portables, erweiterbares Open-Source-Framework ist keine neue Idee mehr, aber mit einem durchdachten, robusten und eleganten Design bekommt Eclipse eine ganz neue Dynamik.

Willkommen im Eclipse-Ökosystem. Unser Ziel war es, Ihnen beim Einstieg in die Eclipse-Plattform zu helfen. Dies haben wir mit einem Einführungstext und einer einfachen Übungsaufgabe erreicht. Nutzen Sie die Erkenntnisse aus der Lektüre dieses Artikels und werden Sie ein aktives Mitglied des Eclipse-Ökosystems.

19.04.2005 Natalia Dubowa

Die Open-Source-Community leitet mehrere Schlüsselprojekte, darunter neben dem Linux-Betriebssystem die Entwicklung der Eclipse-Entwicklungsplattform. Vor einigen Jahren von IBM eingeführt, wird diese offene Integrationsplattform für Anwendungsentwicklungstools heute kostenlos als Open Source vertrieben und von der Benutzergemeinschaft entwickelt.

Ohne auf die Frage einzugehen, was Programmieren ist – eine Kunst oder ein Handwerk, geben wir zu: In beiden Fällen kommt ein Programmierer nicht ohne Werkzeuge zur Programmerstellung aus. Mit der Evolution des Programmierprozesses (von „Hexerei“ über Maschinenbefehle bis zur Verwendung von Hochsprachen) wurden auch die Möglichkeiten zur Automatisierung der harten Arbeit der Programmierer verbessert. Die ersten Entwicklungsumgebungen beschränkten sich darauf, Compiler, Linker, Loader und Debugger nacheinander über eine Befehlszeilenschnittstelle auszuführen. In den 1980er Jahren entstand zusammen mit Personal Computern ein Markt für eine neue Klasse von Softwareprodukten - integrierte Entwicklungsumgebungen (IDE) für algorithmische (Pascal usw.) und dann objektorientierte (Smalltalk, C ++) Programmiersprachen. Dieser Bereich hat seine eigentliche Blütezeit dank der aktiven Anpassung der Entwickler der Java-Sprache erreicht; Die bekanntesten integrierten Umgebungen zum Erstellen von Programmen in dieser Sprache sind Borland JBuilder, Symantec Visual Cafe, Microsoft J++, IBM VisualAge und Oracle JDeveloper.

Der Hauptzweck einer IDE besteht darin, die Produktivität der Entwickler zu steigern. Die ersten Entwicklungsumgebungen, die die Funktionalität von Programm-Texteditoren, Compilern und Debuggern vereinten, befreiten die Verbraucher vor allem von Routineoperationen. Im Laufe der Zeit ist der Funktionsumfang der IDE umfangreicher geworden. Es umfasste Schritt-für-Schritt-Compiler, Browser für eine logischere Darstellung von Programmen, Tools zur automatischen Codegenerierung und visuelle Editoren zum Erstellen grafischer Benutzeroberflächen. Dem Trend der Zeit folgend haben sich Entwicklungsumgebungen von Werkzeugen zur Steigerung der Produktivität eines Programmierers zu einem Mittel zur Unterstützung aller Phasen der Teamarbeit an einem Softwareprojekt gewandelt. Der neueste Trend ist die Transformation der IDE in ALM (Application Lifecycle Management), ein integriertes Application Lifecycle Management System – von der Anforderungsdefinition und -modellierung über die Softwarekonfiguration und das Versionsmanagement bis hin zur Bereitstellung und Wartung einer schlüsselfertigen Lösung.

Jeder neue Schritt in der Entwicklung der IDE hat komplizierte Entwicklungsumgebungen. Anwender solcher Produkte waren jedoch weiterhin gezwungen, auf Tools zurückzugreifen, die nicht in die IDE integriert waren, schon allein deshalb, weil sich die Erstellung einer Anwendung nicht auf das Schreiben und Debuggen von Programmen in einer Programmiersprache beschränkt. Die Notwendigkeit, beispielsweise HTML-Seiten, relationale Datenbankschemata oder Codeteile in anderen Sprachen (wie Cobol oder PL/1) in einem Anwendungssystem zu verwenden, zwingt Entwickler dazu, entsprechende Tools zu verwenden, die ursprünglich nicht darin enthalten waren die IDE.

Deshalb bemühen sich viele Anbieter kommerzieller Entwicklungsumgebungen, diese so offen wie möglich zu gestalten und spezielle Mechanismen zur Integration externer Tools bereitzustellen. Aber keine einzelne Umgebung ist in der Lage, alle möglichen Benutzeranforderungen zu erfüllen. Dazu muss es vollkommen programmiersprachenneutral sein und das Maximum an Funktionen unterstützen. Eclipse ist keine solche Umgebung, aber es ist eine Basis, eine Plattform, mit der Sie multifunktionale und mehrsprachige Entwicklungsumgebungen aufbauen können.

Plattform

Wie die Initiatoren des Eclipse-Projekts erklären, war seine Idee, „Apache for Development Tools“ zu schaffen – eine offene Plattform, die ein Maximum an Grundfunktionen für Entwicklungsumgebungen bereitstellt und Mechanismen zur Integration verschiedener Tools bereitstellt. Die erste Version dieser Plattform wurde von IBM entwickelt und Ende 2001 als Open Source veröffentlicht. Eclipse-basierte kommerzielle Implementierungen tauchten bald auf, Pionierarbeit leistete WebSphere Studio Application Developer 4.0. Eclipse verfügt jetzt über ein ganzes Ökosystem der Open-Source-Entwicklung, das Werkzeuganbieter und -benutzer, Forschungsorganisationen und einzelne Entwickler zusammenbringt.

In den offiziellen Dokumenten der Eclipse Foundation ( www.eclipse.org) Die Eclipse-Plattform ist als eine anbieterunabhängige offene Entwicklungsplattform definiert, die ein Framework und beispielhafte Funktionen sowie erweiterbare Tools bereitstellt. Das Toolkit innerhalb der Eclipse-Plattform ist insofern typisch, als es die Anwendbarkeit der grundlegenden Funktionen der Plattform überprüft, typische Situationen ihrer Verwendung veranschaulicht und die Entwicklung und Wartung der Eclipse-Plattform selbst unterstützt. Das Toolkit ist erweiterbar, da seine Funktionalität über dokumentierte Programmierschnittstellen verfügbar ist. Die Grundprinzipien, die die Ersteller der Eclipse-Plattform geleitet haben und nach denen sie sich ständig weiterentwickelt, lauten wie folgt:

• Unterstützung beim Erstellen von Tools für die Anwendungsentwicklung;
• Support für eine unbegrenzte Anzahl von Toolanbietern, einschließlich unabhängiger Softwareentwickler;
• Unterstützung für Tools zum Arbeiten mit beliebigen Inhaltstypen, einschließlich HTML, Java, C, JavaServer Pages, EJB, XML, GIF usw.;
• Gewährleistung einer „nahtlosen“ Integration von Tools für die Arbeit mit verschiedenen Arten von Inhalten verschiedener Hersteller;
• Unterstützung für Anwendungsentwicklungsumgebungen mit konventionellen und grafischen Benutzeroberflächen;
• Bereitstellung der Möglichkeit, eine Entwicklungsumgebung basierend auf verschiedenen Betriebssystemen auszuführen (heute werden Eclipse-basierte Tools für Linux, HP-UX, IBM AIX, Sun Solaris, QNX, Mac OS X, Windows implementiert);
• im Interesse der Plattformentwicklung die Popularität der Java-Sprache bei der Erstellung von Entwicklungswerkzeugen zu berücksichtigen.

Die Eclipse-Plattform ist eine in Java geschriebene sehr universelle Entwicklungsumgebung, deren Architektur die Integration verschiedener Tools und Programmiersprachen zur Lösung verschiedener Probleme bietet. Die Mechanismen einer solchen Integration ermöglichen die Verwendung der Eclipse-Plattform zum Erstellen fortschrittlicher Entwicklungsumgebungen, frei von der Routine, grundlegende Tools zu schreiben, zugunsten der Erstellung komplexer, spezialisierter Funktionen. Damit wird nicht nur das Problem der Unterstützung multifunktionaler und mehrsprachiger Entwicklungsumgebungen gelöst, sondern auch der Grundstein dafür gelegt, den Übergang von einem Umgebungstyp zu einem anderen im Verlauf ihrer Evolution zu vereinfachen. Die von einer Entwicklergemeinschaft entwickelte Eclipse-Plattform sammelt die neuesten Fortschritte, stellt sie Entwicklern spezifischer Produkte zur Verfügung und eliminiert die Notwendigkeit einer grundlegenden Neugestaltung ihrer Systeme.

Eclipse-Entwicklungsumgebung

Grundlage der Architektur der Eclipse-Plattform ist das Prinzip der Verwendung von Plug-Ins (Plug-In). Die Plattform implementiert Mechanismen zur Erkennung, Integration und Ausführung solcher Module (siehe Abbildung). Ein Entwickler, der die Leistungsfähigkeit der Eclipse-Plattform nutzen möchte, schreibt sein Toolkit in Java als separates Plug-in. Dieses Modul arbeitet mit Dateien im Arbeitsbereich, der mithilfe der Arbeitsbereichskomponente implementiert wird. Und seine Benutzeroberfläche basiert auf den Werkzeugen der Workbench-Komponente, die die allgemeine Struktur der Oberfläche und die Möglichkeit ihrer Erweiterung definiert.

Typischerweise implementiert ein einzelnes Plug-in die einfachste Funktionalität einer auf der Eclipse-Plattform basierenden IDE, während komplexere Tools aus mehreren Modulen aufgebaut werden. Gleichzeitig werden fast alle eingebauten Funktionen der Eclipse-Plattform auch mithilfe solcher Module implementiert – mit Ausnahme eines kleinen Platform Runtime-Kerns. Jedes Plug-in hat seine eigene Manifestdatei (manifest), die die Beziehung dieses Moduls zu anderen beschreibt. Wenn eine auf der Eclipse-Plattform basierende Entwicklungsumgebung gestartet wird, bestimmt die Plattformlaufzeit den Satz verfügbarer Plug-ins, liest ihre Manifestdateien und erstellt eine Plug-in-Registrierung. Sobald das System gestartet ist, können keine weiteren Module mehr hinzugefügt werden. Das Eclipse-Projekt implementierte eine spezielle Umgebung zum Erstellen von Plug-Ins – Plug-In Development Environment (PDE).

Mit Hilfe spezieller Module werden die Komponenten des Arbeitsbereichs (Workspace) und der Benutzeroberfläche (Workbench) der Eclipse-Plattform implementiert. Der Arbeitsbereich enthält Dateien, die von Benutzern der von den Plug-Ins implementierten Tools erstellt werden. Die Workbench-Komponente bietet ein gemeinsames Framework und Tools zur Erweiterung der Benutzerschnittstelle der auf der Eclipse-Plattform basierenden Entwicklungsumgebung und umfasst zwei Komponenten zur Implementierung der Mittel zur Bereitstellung von Informationen für den Benutzer.

• Standard Widget Toolkit (SWT) ist ein Satz von Schnittstellenelementen und einer Grafikbibliothek, die über Mechanismen zur Integration mit dem Fenstersystem einer bestimmten Betriebsplattform verfügen, aber betriebssystemunabhängige APIs implementieren. Damit können Sie Benutzeroberflächen der Entwicklungsumgebung nach denselben Prinzipien aufbauen, die der dem Konsumenten vertrauten Windows-Umgebung entsprechen, aber für eine möglichst große Bandbreite an Betriebssystemen gedacht sind;
• JFace ist ein Toolkit zur Implementierung einer Reihe allgemeiner Aufgaben im Zusammenhang mit der Programmierung von Schnittstellen mit SWT-Tools.

Basierend auf den von den SWT- und JFace-Komponenten bereitgestellten APIs wird eine personalisierte Benutzeroberfläche erstellt, die die Struktur der Interaktion des Verbrauchers mit dem Entwicklungs-Toolkit definiert. Die Benutzeroberfläche der Eclipse-Plattform ist in Editoren (Editor), Ansichten (Ansicht) und Perspektiven (Perspektive) organisiert.

Der Zweck von Editoren besteht darin, Arbeitsbereichsobjekte zu öffnen, zu bearbeiten und zu speichern. Die Plattform verfügt über einen integrierten Editor für Textressourcen, und andere Funktionen müssen als Plug-Ins implementiert werden. Ansichten liefern Informationen über das Objekt, mit dem der Benutzer gerade arbeitet. Schließlich können Sie mit dem Perspektivenmechanismus die gewünschten Editoren und Ansichten auswählen und organisieren, die auf dem Bildschirm angezeigt werden.

Organisation

Die Pflege von Projekten in Open Source bietet eine Reihe von Vorteilen. Eine der Aufgaben einer solchen Plattform besteht also darin, Entwicklern Werkzeuge auf einer gemeinsamen Basis bereitzustellen, die für verschiedene Entwicklungsumgebungen unveränderlich sind. Warum muss jeder Hersteller neu schreiben, was einmal geschrieben werden kann? Aber um seine Entwicklungen auf einer solchen Plattform aufzubauen, muss der Hersteller demjenigen, der sie erstellt hat, voll und ganz vertrauen. Und das ist nur möglich, wenn es ihm gelingt, alles zu testen, was darin enthalten ist, dh eine Plattform in offenen Codes zu erhalten.

Ein Produkt nach den Prinzipien von Open Source zu entwickeln, verbessert die Qualität des Codes, da dieser von vielen interessierten Entwicklern gemeinsam „poliert“ wird. Das Debuggen wird einfacher und besser – dank des Zugriffs auf den Quellcode des Programms und wiederum der Einbindung eines verteilten Teams in die Arbeit. Durch die Zusammenarbeit können Sie die Risiken bei der Entwicklung komplexer Technologien teilen. Und das kollektive Entwicklungsgremium der Plattform sichert seine Unterstützung, unabhängig von den Höhen und Tiefen, die bei den Anbietern bestimmter Entwicklungsumgebungen auftreten können. Schließlich eröffnet die Verwendung einer Open-Source-Entwicklungsplattform mit einem flexiblen Plug-in-Mechanismus zur Implementierung zusätzlicher Funktionen unbegrenzte Möglichkeiten für deren Verbesserung.

Eclipse-Plattformarchitektur

Allerdings werden die Vorteile des Open-Source-Entwicklungsmodells nicht einfach durch die Freigabe einer technischen Plattform „im Streubesitz“ realisiert werden können. Sie müssen den Prozess organisieren. Mit der Veröffentlichung der ersten Version von Eclipse im Jahr 2001 wurde dieser Konzern von einem von IBM organisierten Konsortium mit einigen führenden Marktteilnehmern übernommen, und im Februar 2004 beschloss das Eclipse Board of Directors, die Eclipse Foundation in eine zu verwandeln gemeinnützige unabhängige Körperschaft.

Die Eclipse Foundation, ein Konsortium aus mehr als 60 Unternehmen, koordiniert die Arbeit zur Verbesserung der Eclipse-Plattform und anderer Open-Source-Projekte.

Das Eclipse-Projekt ist völlig offen, jeder interessierte Entwickler, der nicht verpflichtet ist, Mitarbeiter eines Unternehmens zu sein, kann daran teilnehmen. Grundsätzlich kann sich jeder nicht nur für die Details der Entwicklung interessieren und zur Fehlersuche beitragen, sondern auch am Codeschreiben und am Gesamtdesign der nächsten Version der Plattform mitwirken. Eclipse folgt jedoch dem Prinzip, Professionalität zu priorisieren. Einen Entwickler mit nachgewiesener beruflicher Erfolgsbilanz erwartet zusätzliche Verantwortung und die Möglichkeit, seine Fähigkeiten aktiv in Eclipse-Projekten einzubringen. Einige Entwickler werden als „verantwortlich“ (Committer) definiert, da sie für die Quellcodes verantwortlich sind und nur sie das Recht haben, neue Versionen im Open-Source-Code-Repository zu erstellen. Typischerweise sind diese Entwickler Angestellte von Unternehmen, die für ihre Arbeit innerhalb der Eclipse-Projekte bezahlen.

Der Entwicklungsprozess ist iterativ und zielt darauf ab, die Beteiligung der Mitglieder der Eclipse-Community an der Arbeit am Projekt zu maximieren. Der Veröffentlichung der nächsten Version gehen mehrere Phasen mit fester Dauer (in der Größenordnung von mehreren Wochen) voraus, von denen jede einen vollständigen Zyklus darstellt, der Planung, Entwicklung, Test und Zwischenfreigabe der Version umfasst. Der Abschluss des nächsten Zyklus wird von einer offenen Veröffentlichung einer Beschreibung der neuen Funktionen des Systems begleitet, die die Community-Mitglieder ermutigt, zu diskutieren, zu verwenden und Empfehlungen für Verbesserungen abzugeben. Dadurch wird es möglich, in den nächsten Entwicklungsstufen die Reaktion der Community auf die Zwischenversion zu berücksichtigen. Dies ist ein offener Prozess der kontinuierlichen Verbesserung der Eclipse-Plattform und der Entwicklung anderer darauf basierender Initiativen.

Das Ziel des Eclipse-Technologieprojekts ist es, die Bemühungen von Entwicklern, Forschern, Mitgliedern von Wissenschafts- und Bildungsorganisationen zu koordinieren, um die Aussichten für die Eclipse-Plattform und andere Open-Source-Entwicklungen zu ermitteln. Zu den bemerkenswertesten Forschungsunterprojekten in diesem Bereich gehören die Entwicklung aspektorientierter Software (AspectJ und AJDT), die Schaffung einer Kernel-Alternative zu Eclipse Runtime (Equinox), die Schaffung einer kollaborativen Entwicklungsplattform (Koi) und das Softwarekonfigurationsmanagement (Stellation), Toolkit für XML-Schemas (XML Schema Definition) und für modellbasierte Entwicklung (Generative Model Transformer).

Gemeinschaft

Die Verwendung aller Materialien, die aus der Umsetzung von Eclipse-Projekten stammen, unterliegt den Lizenzregeln der Common Public License (CPL), die von der Open Source Initiative genehmigt wurden. Unter der CPL steht es jedem frei, Eclipse für kommerzielle und nichtkommerzielle Zwecke zu nutzen und zu verteilen. Frei verfügbar auf der Website eclipse.org sind:

• aktuelle Versionen der Eclipse-Plattform zur direkten Nutzung (in Binärform);
• Quellcode-Repository, in dem jeder den Inhalt und den Revisionsverlauf jeder Quelldatei anzeigen und Skripte zum Neukompilieren und Erstellen der Eclipse-Plattform aus Quellcodes erhalten kann;
• offene Diskussionsforen zur Diskussion der Eclipse-Plattform;
• Bug-Datenbank zum Nachverfolgen von Fehlern und Problemen in aktuellen Plattformversionen. Mit dieser Datenbank können Benutzer bekannte Fehler in ihren Eclipse-basierten Entwicklungen identifizieren und neu entdeckte Probleme öffentlich machen;
• Entwicklungspläne und Kontakte von Entwicklern, die an Eclipse-Projekten beteiligt sind.

Heute weiter eclipse.org frei verfügbar - mehr als hundert Plug-ins in Quellcodes für die Eclipse-Plattform. Die Open-Source-Projekte von Eclipse umfassen insgesamt über 2 Millionen Codezeilen.

Die Beteiligung kommerzieller Unternehmen am Eclipse-Projekt ist von zentraler Bedeutung für die Entwicklung des Marktes für Entwicklungssoftware. Mit der Eclipse-Plattform erhalten sie die Kerndienste einer sprach- und plattformneutralen Entwicklungsumgebung sofort einsatzbereit, sodass sie ihre Bemühungen und Investitionen auf die Entwicklung komplexer Funktionen konzentrieren können, die ihre Lösungen wettbewerbsfähig halten. Es gibt Beispiele für Eclipse-basierte Implementierungen sowohl von Entwicklungsumgebungen mit vollem Funktionsumfang, die die fortschrittlichsten Lösungen in diesem Bereich fördern, als auch von spezialisierten Tools, die auf eine bestimmte Reihe von Aufgaben ausgerichtet sind.

Auf der Eclipse-Plattform funktionieren also alle Produkte der IBM Rational-Familie. Borland beabsichtigt, den gesamten Anwendungslebenszyklus-Support auf Eclipse zu migrieren. Es gibt eine Eclipse-Version der eingebetteten Entwicklungstools von QNX; ein ähnliches Projekt wird von Wind River umgesetzt. Hewlett-Packard wiederum bietet eine Eclipse-basierte Komponentenentwicklungsumgebung für sein Internet Usage Manager-System an, dessen Zielgruppe Telekommunikationsbetreiber sind. Nokia hat Unterstützung für Eclipse als Entwicklungsplattform für mobile Anwendungen angekündigt. IBM hat ein spezielles Autonomic Computing Toolkit auf Basis von Eclipse implementiert, das entwickelt wurde, um autonome Computing-Technologien in entwickelten Anwendungen zu unterstützen. Von allen weltweit führenden Softwareanbietern arbeiten nur Sun Microsystems und Microsoft nicht mit der Eclipse Foundation zusammen.

Anbieter von Eclipse-basierten kommerziellen Umgebungen erlauben Drittentwicklern, Add-Ons für ihre IDE zu verkaufen, und es kommt vor, dass ein Unternehmen dasselbe proprietäre Plug-In für verschiedene Umgebungen auf der Eclipse-Plattform implementiert. Dies ist nicht nur eine Methode, um neue Märkte zu erschließen, sondern auch, um die Bedeutung des Projekts zu steigern. Anwender schätzen die Wahlfreiheit: Wenn sie mit der bestehenden Funktionalität einer Open-Source-Plattform-basierten Umgebung nicht zufrieden sind, können sie diese durch Eigenentwicklung oder den Kauf kommerzieller Lösungen im gleichen Format erweitern.

Diese Gruppen nutzen die Eclipse-Entwicklungen auf unterschiedliche Weise, tragen aber alle zu ihrer Entwicklung bei. Der Trend geht dahin, die Eclipse-Plattform zum Erstellen von Nicht-IDE-Anwendungen zu verwenden. Dies ist möglich, da die Technologielösung der Eclipse-Plattform nicht viele Elemente enthält. In der dritten Version von Eclipse vollzieht sich eine Weiterentwicklung von einer Plattform für Entwicklungsumgebungen hin zu einer Plattform zur Implementierung vollwertiger Client-Workstations (Rich Client Platform). Nicht umsonst implementiert IBM seine zukunftsträchtige Kollaborationsumgebung Workplace auf Basis von Eclipse.

Literatur

1. Marc R. Erickson, Angus McIntyre. , 2001, November.
2. J. dea Rivieres, J. Wiegand. Finsternis. Eine Plattform zur Integration von Entwicklungstools. IBM Systems Journal, 2004, Nr. 2.

Eclipse-Organisationsstruktur

Die Entwicklung von Eclipse und die Teilnahme an Open-Source-Projekten verschiedener Organisationen und einzelner Entwickler wird von dem gemeinnützigen unabhängigen Konsortium Eclipse Foundation koordiniert

Der Vorstand der Eclipse Foundation setzt sich aus vier Hauptkategorien von Teilnehmern zusammen:

• Strategische Entwickler (Strategische Entwickler) – Actuate, Borland, IBM, Computer Associates, Intel, QNX, Wind River, Sybase, Scapa Technologies, BEA Systems;
• Strategische Verbraucher (Strategische Verbraucher) – HP, Montavista Software, SAP, Serena Software;
• eingeschlossene Anbieter (Add-In-Anbieter);
• Open-Source-Projektleiter.

Alle Strategischen Entwickler und Strategischen Konsumenten sind im Vorstand vertreten, die beiden anderen Gruppen entsenden ihre Vertreter in ihn. Strategische Mitglieder des Konsortiums haben auch bestimmte Rechte zur Teilnahme an Projektmanagementausschüssen und Räten, die Entwicklungsprozesse koordinieren.

Das Konsortium unterhält mehrere grundlegende Open-Source-Projekte, die eine bestimmte Anzahl von Teilprojekten umfassen. Das Basisprojekt wird vom Project Management Committee (PMC) geleitet. Um die Entwicklung als Ganzes zu steuern, werden drei Hauptgremien geschaffen – zur Definition von Anforderungen (Requirements Council), zur Architektur (Architecture Council) und zur Planung (Planning Council).

Das Requirements Definition Board analysiert und strukturiert die Anforderungen an das Projekt. Sie kombinieren Anforderungen, die darauf abzielen, die Gesamtziele der Eclipse Foundation und die spezifischen Ziele des Projekts zu erreichen, die Probleme der wichtigsten Mitglieder des Konsortiums zu lösen und das Eclipse-Ökosystem zu entwickeln. Basierend auf der Analyse wird eine Liste von Themen und Prioritäten formuliert, die den Verlauf der Entwicklung bestimmen. Das Architecture Board ist dafür verantwortlich, die Architektur der Eclipse-Plattform zu entwerfen, sie klar zu beschreiben, die relevanten Informationen an die Entwicklungsteams zu übermitteln und sie vor unbeabsichtigter Manipulation zu schützen. Das Planning Board erstellt einen koordinierten Plattform-Release-Plan.

Projekte werden von Entwicklungsteams umgesetzt, die von Projektmanagern geleitet werden und Entwickler und verantwortliche Entwickler umfassen. Erstere beschäftigen sich mit dem Schreiben von Code, dem Identifizieren von Fehlern, dem Testen und Dokumentieren von Programmen und führen auch andere Aufgaben innerhalb des Projekts durch. Verantwortliche Entwickler haben das Recht, das Quellcode-Repository aufzufüllen und müssen die Entwicklung des Projekts beeinflussen. Unternehmen, die den Status eines strategischen Entwicklers bei der Eclipse Foundation haben, müssen mindestens ein Projekt leiten. Sie werden auch ermutigt, Ausschüsse zu leiten.

Wenn Sie jemals genau verfolgt haben, was in der Open-Source- oder Java-Welt vor sich geht, dann haben Sie einfach noch nie die ganze Aufregung um Eclipse gehört. Eclipse ist eine erweiterbare Open-Source-Integrated Development Environment (IDE). Dieses Projekt wurde im November 2001 gestartet, als IBM den 40 Millionen Dollar teuren Quellcode von der Websphere Studio Workbench übernahm und das Eclipse Consortium gründete, um die Entwicklung des Tools zu verwalten.

Das ursprüngliche Ziel war die „Entwicklung einer stabilen, voll funktionsfähigen Industrieplattform in kommerzieller Produktqualität für die Entwicklung integrierbarer Tools“. Das Eclipse-Konsortium konzentriert sich derzeit auf die folgenden Projekte:

1. Das Eclipse-Projekt (http://www.eclipse.org/eclipse/index.html) – verantwortlich für die Entwicklung der Eclipse-IDE (Bauplattform für andere Eclipse-Tools), der Java-Entwicklungstools (JDT) und der Plug-In-Entwicklungsumgebung (PDE) ) verwendet, um die Erweiterung der Plattform selbst zu ermöglichen.
2. Das Eclipse Tools Project (http://www.eclipse.org/tools/index.html) widmet sich der Entwicklung optimaler Tools für die Eclipse-Plattform. Zu den aktuellen Teilprojekten gehören: Cobol IDE, C/C++ IDE und das EMF-Modellierungstool.
3. Das Eclipse Technology Project (http://www.eclipse.org/technology/index.html) beschäftigt sich mit Technologieforschung, Inkubation und Ausbildung zur Nutzung der Eclipse-Plattform.

Zusammen mit dem JDT bietet das Eclipse-Framework viele verschiedene Funktionen, die Sie möglicherweise in kommerziellen IDEs sehen: Syntaxhervorhebung im Editor, Codekompilierung, einen Debugger auf Quellcodeebene mit Thread-Unterstützung, einen Klassennavigator, einen Dateimanager und einen Projektmanager , Schnittstellen zu Standard-Quellcodeverwaltungssystemen wie CVS und ClearCase.

Darüber hinaus enthält Eclipse eine Reihe einzigartiger Funktionen, wie z. B. Code-Refactoring (http://www.refactoring.com/), automatisches Aktualisieren und Erstellen von Code (über Update Manager), eine Aufgabenliste, Unterstützung für die Testfähigkeit Units mit JUnit (http://www.junit.org/) sowie die Integration mit dem Anwendungserstellungstool Jakarta Ant (http://jakarta.apache.org/ant/index.html).

Trotz einer großen Anzahl von Standardfunktionen unterscheidet sich Eclipse in einigen grundlegenden Punkten von herkömmlichen IDEs. Das vielleicht interessanteste Merkmal von Eclipse ist seine absolute Plattform- und Sprachneutralität. Zusätzlich zu den vielseitigen Programmiersprachen, die vom Eclipse Consortium (Java, C/C++, Cobol) unterstützt werden, gibt es viele Projekte von Drittanbietern, die Sie verwenden können, um Ihre Programmiersprache in Eclipse zu unterstützen. Bis heute gibt es Implementierungen der folgenden gängigen Programmiersprachen: Python, Eiffel, PHP, Ruby und C#.

Die Eclipse-Plattform wird dank des Eclipse-Konsortiums als vorkompilierte ausführbare Dateien für Windows, Linux, Solaris, HP-UX, AIX, QNX und Mac OS X bereitgestellt. Auch die "reichen" APIs (Application Programming Interface) werden mit dem Plug geliefert -in Entwicklungsumgebung für die Eclipse-Erweiterung Das Hinzufügen von Unterstützung für eine neue Art von Editor, Viewer (Panel) oder Programmiersprache ist dank der gut gestalteten APIs und Bausteine, die Eclipse bereitstellt, unglaublich einfach.

Mit etwa hundert Plug-in-Entwicklungsprojekten, Ressourcen, die von Branchenriesen wie IBM, HP und Rational (das kürzlich von IBM gekauft wurde) bereitgestellt wurden, und einem Design von Erich Gamma, das hilft, den Entwicklungsprozess schnell zu verstehen - die Zukunft von Eclipse wird sehr hell, interessant und vielversprechend sein.

Installation

Ich wette, dass Sie jetzt nur darüber nachdenken, wo Sie eine Kopie genau dieses Eclipse für Ihre Plattform bekommen und wie Sie es installieren können? :) Das erste, worum Sie sich kümmern müssen, ist sicherzustellen, dass Sie eine geeignete, funktionierende JRE (Java Runtime Evironment) haben. Obwohl Eclipse so konzipiert wurde, dass es Code für JVM (Java Virtual Machine) Version 1.3 und Version 1.4 kompilieren kann, wurden aktuelle Versionen von Eclipse für die Ausführung auf JVM Version 1.3 entwickelt. Wenn Sie sich nicht sicher sind, wo Sie eine „virtuelle“ Java-Maschine (JVM) für Ihre Plattform erhalten können, finden Sie detaillierte Anweisungen und weitere Informationen dazu unter

Nachdem Sie überprüft haben, ob Sie über die JVM verfügen oder die richtige Version davon installiert haben, können Sie Eclipse installieren. Besuchen Sie dazu den Download-Bereich der Eclipse-Projektwebsite (http://www.eclipse.org/downloads/) und laden Sie die neueste Version herunter, die speziell für Ihre Plattform entwickelt wurde. Alle Distributionen sind .zip-Archive. Entpacken Sie das heruntergeladene Archiv in ein geeignetes Verzeichnis und nehmen Sie sich etwas Zeit, um alle im Readme-Verzeichnis enthaltenen Dateien durchzusehen.

Ob Sie es glauben oder nicht, aber diese Installation ist abgeschlossen. Wenn Sie die JVM korrekt installiert und das Archiv mit Eclipse korrekt entpackt haben, können Sie den Vorgang zum erstmaligen Starten dieser IDE starten. Alle Distributionen, die eine kompilierte Version der Plattform enthalten, bieten Programme zum Ausführen an, die sich im Hauptverzeichnis befinden: eclipse. Der Name dieses Launchers variiert je nach Plattform, für die Sie die Distribution heruntergeladen haben: eclipse.exe unter Windows, eclipse unter Solaris und so weiter. Wenn Sie die Eclipse-Anwendung zum ersten Mal ausführen, führt sie einige verbleibende Installationsaufgaben aus (z. B. das Erstellen eines Arbeitsbereichsverzeichnisses zum Speichern von Projektdateien), bevor die Anwendung endlich betriebsbereit ist.

Schnittstelle

Jetzt, da Sie Eclipse installiert haben und ausführen, ist es an der Zeit, es zu verwenden. Nachdem Sie Eclipse gestartet haben, sollten Sie so etwas sehen:

Bild 1

Wie Sie sehen können, hat die Eclipse-IDE ziemlich standardmäßige Menüinhalte:

Figur 2

Neben dem Menü ist hier die Ähnlichkeit der Symbolleiste und des Lesezeichensystems mit denen in anderen Anwendungsentwicklungsumgebungen deutlich sichtbar.

Beispielanwendung

Platten Dateinavigator, Code-Gliederung und Aufgabenliste werden angezeigt, enthalten aber derzeit keine Daten. Um unsere Einführung in Eclipse fortzusetzen, erstellen wir eine einfache Swing-Rechneranwendung. Schreiben wir die Schritte auf:

1. Wählen Sie einen Menüpunkt aus Datei->Neu->Projekt..., um mit dem Erstellen Ihres ersten Java-Projekts zu beginnen. Wählen Sie im Assistentenfenster aus Java unter den vorgeschlagenen Projekttypen aus der linken Liste und Java-Projekt in der rechten Liste, und klicken Sie dann auf die Schaltfläche Nächste.

Figur 3

2. Geben Sie als Projektnamen Rechner ein und fahren Sie mit der Erstellung des Projekts fort, indem Sie auf die Schaltfläche klicken Nächste.

Figur 4

3. Und schließlich gibt Ihnen der "Assistent" zum Erstellen eines neuen Projekts in der letzten Phase die Möglichkeit, Verzeichnisse zu definieren, in denen Quellcodedateien und Klassendateien gespeichert werden, und Unterprojekte zu definieren, die vom aktuellen Projekt verwendet werden können Erstellen sowie alle Bibliotheken, die wir in unserer Anwendung verwenden möchten. Stellen Sie den Schalter auf Wert Im Projekt enthaltenen Quellordner verwenden, dann drücken Sie die Taste Neuen Ordner erstellen.... Geben Sie src als Namen des neuen Quellverzeichnisses ein. Klicken Ja, wenn Eclipse Sie fragt, ob Sie das Build-Verzeichnis in ändern möchten Rechner/Bin.

Abbildung 5

4. Drücken Sie die Taste Fertig um Eclipse die Erstellung des neuen Projekts abschließen zu lassen.

Sobald Sie ein neues Projekt erstellt haben, stellen Sie möglicherweise fest, dass sich das Erscheinungsbild von Eclipse (wie erwartet) etwas geändert hat: Gliederung verschoben auf einen anderen Teil des Fensters, Panel Navigator Platte wurde ausgetauscht Paket-Explorer usw.

So sah das Eclipse-Fenster aus, nachdem wir das neue Projekt erstellt hatten:

Abbildung 6

Dieses Layout heißt Java-Perspektive. Eine "Ansicht" in Eclipse-Begriffen definiert jede gespeicherte Anordnung einer beliebigen Anzahl verschiedener Editor- und Viewer-Panels. Eclipse wird mit einer Reihe von Standard-"Ansichten" ( Ressource, Java, debuggen und andere), die an Ihre Bedürfnisse angepasst werden können, oder Sie können Ihre eigenen Ansichten erstellen. Ansichten werden über Menüpunkte gesteuert Fenster oder eine spezielle Symbolleiste, die sich normalerweise am linken Rand des Eclipse-Fensters befindet.

Abbildung 7

Der nächste Schritt beim Erstellen unseres Java-Projekts besteht darin, Verzeichnisse zu erstellen, die unseren gesamten Quellcode enthalten. Wechseln Sie dazu in die Ansicht Ressourceüber den Menüpunkt Fenster->Perspektive öffnen->Ressource. Im Panel Navigator Erweitern Sie die Knoten der Ordnerstruktur, sodass Sie den Ordnerknoten src sehen können. Wählen Sie diesen Knoten aus und führen Sie dann den Menüpunkt aus Datei->Neu->Ordner. Vergewissern Sie sich, dass im angezeigten Dialogfeld das src-Verzeichnis ausgewählt ist, und geben Sie dann den Namen des neuen Verzeichnisses in das Feld ein Ordnernamen, Name com.

Erstellen Sie eine große Anzahl von Ordnern über einen Dialog Neuer Ordner es wäre nicht sehr bequem und ermüdend. Glücklicherweise kann Eclipse Ihnen die Möglichkeit geben, Ihre eigenen Verzeichnisse mit Ihrem bevorzugten Dateimanager zu erstellen: Befehlszeile, Windows Explorer und mehr. Erstellen Sie den Ordner mit einer der vorgeschlagenen Methoden com Mappe teuflisch, und darin einen Ordner Taschenrechner. Nachdem Sie diese Ordner erstellt haben, wählen Sie einen beliebigen Knotenordner im Navigator-Bedienfeld aus und verwenden Sie das Menüelement Datei->Aktualisieren, aktualisieren Sie den Inhalt dieses Bereichs. Auf diese Weise durchsucht Eclipse das Dateisystem und aktualisiert das Projektfenster mit den von Ihnen vorgenommenen Änderungen (erstellte neue Verzeichnisse). An diesem Punkt sollte Ihr Eclipse-Fenster etwa so aussehen:

Abbildung 8

Und noch eine Anmerkung zur Dateierstellung: In den frühen Phasen der Erstellung eines Projekts werden Sie Ihre Anwendungen höchstwahrscheinlich ziemlich oft starten, neue Dateien und Ordner erstellen, neuen Code hinzufügen, kompilieren und Ihren Code erneut testen. Denken Sie daran, dass die Position der Menüs in Eclipse von der verwendeten Ansicht abhängt. Also, wenn Sie auf den Winkel wechseln Ressource, um eine neue Datei oder einen neuen Ordner im Bedienfeld zu erstellen Navigator, finden Sie das im Menü Laufen unterscheidet sich zum Beispiel grundlegend vom Menü Laufen in Perspektive Java. Eine Lösung für dieses allgemeine Problem ist die Verwendung des Menüs Windows->Ansicht anzeigen um das Panel anzuzeigen Navigator in Perspektive Java. Wenn Sie mit der erhaltenen Ansicht vollkommen zufrieden sind, verwenden Sie den Menüpunkt Fenster->Perspektive speichern unter... können Sie Ihre Änderungen in einer neuen Ansicht speichern oder eine vorhandene Ansicht überschreiben Java.

Code hinzufügen

Nachdem wir unsere Verzeichnisstruktur eingerichtet haben, können wir damit beginnen, Quellcode zu unserem Projekt hinzuzufügen. Wir werden unser Taschenrechnerprogramm in drei Klassen (Dateien) unterteilen: CalcModel.java, CalcPanel.jav ein, und Rechner.java. Laden Sie das .zip-Archiv mit dem Quellcode für dieses Programm von http://www.onjava.com/onjava/2002/12/11/examples/calculator.zip herunter. Entpacken Sie danach dieses Archiv und legen Sie die drei oben genannten Dateien in das Verzeichnis com/devious/calculator. Lassen Sie uns den Menüpunkt erneut verwenden Datei->Aktualisieren, um den Inhalt des Bereichs Projektmanager zu aktualisieren. Folgendes sollten Sie sehen, nachdem Sie diese Schritte ausgeführt haben:

Abbildung 9

CalcPanel.java stellt die Basis der Benutzeroberfläche unseres Rechners dar. Rechner.java führt vorbereitende Initialisierungsfunktionen durch und startet die GUI (Graphical User Interface). Der wichtigste Teil unseres Programms befindet sich in der Datei CalcModel.java, die sich direkt mit der Implementierung der eigentlichen Mathematik unseres Taschenrechners befasst: Reagieren auf Ereignisse, Durchführen mathematischer Berechnungen, Aktualisieren angezeigter Informationen usw. Der einfachste Weg, den Quellcode anzuzeigen, besteht darin, die Ansicht zu wechseln Java in Java-Browsing. Verwenden Sie dazu offene Perspektive aus dem Menü Fenster oder klicken Sie auf die Schaltfläche offen, die sich auf der Symbolleiste zum Arbeiten mit Ansichten befindet.

Während Sie auf dem Panel durch den Quellcode navigieren Paket-Explorer, können Sie sehen, dass das Panel Gliederung wird für Sie in diesem Stadium unnötig. Es kann vorübergehend vom Bildschirm entfernt werden, indem Sie auf das Kreuz in der rechten Ecke dieses Bereichs klicken. Wenn Sie es brauchen, können Sie den Menüpunkt verwenden Fenster->Ansicht anzeigen->Gliederung wieder anzuzeigen.

Abbildung 10

Ausführen und Debuggen von Code

Sie haben also Eclipse heruntergeladen und installiert, ein neues Java-Projekt erstellt und die erforderlichen Dateien und Ordner für Ihre einfache Anwendung hinzugefügt. Es ist an der Zeit, diese Anwendung auf die Probe zu stellen, indem Sie sie ausführen. Dazu müssen Sie den Winkel einstellen Java So führen Sie die Schritte aus, die zum Ausführen der Anwendung erforderlich sind:

1. Aus dem Hauptmenü Laufen Menüpunkt wählen Laufen...

2. Wählen Sie im angezeigten Dialogfeld des Startassistenten „Java-Anwendung“ aus der Liste aus Konfigurationen starten und drücken Sie die Taste Neu

Abbildung 11

3. Geben Sie als Namen der neuen Konfiguration ein Taschenrechner

4. Drücken Sie die Taste Suche... und wählen Sie die Klasse als Hauptklasse aus Taschenrechner auf dem Feld Hauptklasse, oder geben Sie einfach den vollständigen Namen der Klasse in das Eingabefeld ein: com.devious.calculator.Calculator.

Abbildung 12

Abbildung 13

Nachdem Sie die Startkonfiguration Ihrer Anwendung erstellt haben, können Sie sie über das Menü erneut starten Ausführen-> Ausführungsverlauf oder Knöpfe Laufen auf der Symbolleiste. Wenn Sie genug Zeit damit verbringen, mit diesem Rechner zu "spielen", werden Sie feststellen, dass er meistens richtig funktioniert, mit nur einem "aber": er will die Subtraktionsoperation nicht richtig machen! Es ist an der Zeit, den Eclipse-Quelldebugger zu verwenden und diesen unglücklichen Fehler zu finden. Wenn Sie alle obigen Anweisungen in diesem Artikel befolgt haben, können Sie diese Anwendung mit einem Debugger mit derselben Konfiguration ausführen, die wir für den normalen Start definiert haben. Wählen Sie dazu den Menüpunkt aus Ausführen->Debug-Verlauf->Rechner.

Wenn Sie Ihre Anwendung zusammen mit dem Debugger ausführen, wechselt Eclipse automatisch zum debuggen:

Abbildung 14

Da sich das gefundene Problem auf die Subtraktionsfunktion konzentriert, setzen wir im Ereignishandler einen Haltepunkt für die Schaltflächen "-" und "=". Zuerst müssen wir zur Registerkarte des Klasseneditors wechseln CalcPanel. (Wenn Sie kein Lesezeichen mit dem Quellcode für diese Klasse haben, müssen Sie eine Datei namens öffnen CalcPanel.java, nach dem Umschalten auf den Winkel Java oder Ressource und dann zurück zum Winkel debuggen).

Verwenden Sie das Bedienfeld Gliederung um die Methode zu finden Handlung ausgeführt. Bewegen Sie sich ein wenig nach unten, bis Sie den Ausdruck finden Fall für das "-" Zeichen (Zeile 126). Wenn Sie auf den linken Rand dieser Zeile doppelklicken, setzt Eclipse dort automatisch einen Haltepunkt. Bewegen Sie sich etwas nach unten und setzen Sie einen weiteren Haltepunkt für den Methodenaufruf model.calculate() in der Event-Handler-Schaltfläche "=" (Zeile 138).

Abbildung 15

Wechseln Sie nun in das Taschenrechnerfenster und klicken Sie auf einige Schaltflächen. Zum Beispiel „2“, „4“, „6“ und „-“. Sobald der Debugger einen Haltepunkt erreicht, können Sie sehen, dass die Schaltflächen in der Symbolleiste erscheinen debuggen, die dazu dienen, den Quellcode schrittweise zu durchlaufen, und Sie können Schritte durch den Code unternehmen und, ohne in die Methoden einzusteigen, sie automatisch ausführen oder, indem Sie nach innen gehen, ihren Quellcode durchgehen.

Abbildung 16

Wenn wir in die Methode gehen setOperation(), wird deutlich, dass sie eine eher triviale Funktion erfüllen: Sie speichern den Operationscode im Feld ausstehendOp. Drücken Sie nun die Taste Zusammenfassung auf der Symbolleiste debuggen um das Programm weiter auszuführen.

Hinweis: Ein großer Fehler, den neue Eclipse-Benutzer machen, ist, dass sie manchmal klicken debuggen oder Laufen auf der Hauptsymbolleiste (wodurch eine weitere Kopie der Anwendung gestartet wird), anstatt zu klicken Zusammenfassung.

Drücken Sie nun noch ein paar Tasten (z. B. „1“, „2“, „3“) und danach die Taste „=“. Somit befinden wir uns innerhalb der Methode Berechnung(), stellte sich das Problem als offensichtlich heraus: Jemand hat den Code aus der OP_ADD-Variante kopiert, aber vergessen, das +-Zeichen durch - zu ersetzen. Das Problem ist gelöst! :)

Behebung eines Fehlers mit der HotSwap-Methode

Wenn Sie JVM Version 1.4 zum Ausführen der Anwendung verwendet haben, haben wir in unserem Beispiel nur einen letzten Schritt, um diesen Fehler zu beheben. Anstatt den Rechner zu verlassen, Änderungen am Quellcode vorzunehmen, das gesamte Projekt neu zu kompilieren und erst dann eine neue Debugger-Sitzung zu starten, können wir alles im Handumdrehen ändern. Während der Debugger noch läuft, ändern Sie die Zeile in Ihrem Quellcode von:

SetDisplay (vorheriger Wert + aktueller Wert); // zu: setDisplay (vorherigerWert - aktuellerWert);

Speichern Sie diese Datei und klicken Sie dann auf die Schaltfläche Zusammenfassung die Anwendung "loszulassen" und weiter damit zu arbeiten. Mit Taste C um es zurückzusetzen und die Schritte zu wiederholen, die wir zuvor gemacht haben. Jetzt funktioniert alles wie es soll!

Was wir jetzt demonstriert haben, ist die Unterstützung von Eclipse für ein neues Feature (namens HotSwap) der JVM-Version 1.4. Die Java Platform Debugger Architecture (JPDA) unterstützt jetzt die Möglichkeit, den Quellcode einer laufenden Anwendung zu ersetzen. Dies ist besonders nützlich, wenn sie läuft eine Anwendung zu finden oder Stellen zu finden, an denen es "zusammenbricht", nimmt viel Zeit in Anspruch.

Interessante Features in kommenden Versionen von Eclipse

Ein sehr interessantes Merkmal von Eclipse ist die Geschwindigkeit, mit der Fehler entdeckt werden und mit der Entwickler auf die verschiedenen Bedürfnisse und Wünsche der Benutzer eingehen. Das Eclipse-Konsortium veröffentlicht monatlich die neuesten Versionen, die stabile Versionen verschiedener Funktionen enthalten, an denen Benutzer interessiert sind (solche Versionen enthalten die Kennungen M1, M2, M3 usw.). Unter den in Version 2.1 M3 enthaltenen Funktionen sind die folgenden die wichtigsten:

• - Anpassbare Tastenkombinationen, einschließlich einer Reihe von Tastenkombinationen, die denen in Emacs ähneln;
• - Möglichkeit der automatischen Einfügung MACHEN, FIXME und andere Tag-Kommentare im Java-Code, in verschiedenen Elementen und Aufgabenlisten;
• - Verbesserte CVS-Unterstützung, einschließlich der Möglichkeit, "Working Sets" zu definieren, die die Anzahl der im Panel angezeigten Projekte begrenzen CVS-Repositorys;
• - neue Entwürfe im Java-Editor, die verwendet werden können, um Quellcode, Javadoc, detaillierte Fehlermeldungen für jede Codezeile oder jeden Ausdruck in einem "Dropdown"-Fenster (Tooltip) anzuzeigen;
• - Unterstützung für mehrere neue Refactorings;
• - neue Platte Threads und Monitore im Debugger, mit dem Sie feststellen können, welche der "Threads" (Threads) Ressourcen blockieren, welche von ihnen warten, und andere nützliche Informationen zum Debuggen von Multithread-Anwendungen;
• - engere Integration mit dem Build-Tool Jakarta Ant;

Dieses letzte Merkmal macht Eclipse zu einer gut zusammengesetzten Umgebung für die Entwicklung von Java-Anwendungen und insbesondere für die Entwicklung von Webanwendungen. Eclipse vereint alle Werkzeuge, die ein Entwickler benötigt, um Webanwendungen erfolgreich zu entwickeln: eine erweiterbare IDE, einen Standard-Compiler, Remote-Debugging, Ant-Unterstützung, JUnit-Tests, Plug-Ins für die Interaktion mit fast allen Anwendungsservern sowie den EJB-Container.

Ressourcen

• eclipse.org (http://www.eclipse.org/)
• Häufig gestellte Fragen zum Eclipse-Projekt (http://www.eclipse.org/eclipse/faq/eclipse-faq.html)
• Technische Übersicht der Eclipse-Plattform (

Java ist eine höhere Programmiersprache, die bereits 1995 von Sun Microsystems entwickelt wurde. Bis heute beschäftigt sich die Entwicklung dieser Technologie mit der Firma JCP (Java Community Process). Eines der Hauptmerkmale der Sprache ist die Kompilierung, die direkt beim Zusammenstellen des Programms durchgeführt wird.

Der Code wird in Bytecode umgewandelt und dann in der Java Virtual Machine ausgeführt. Die JVM fungiert als Übersetzer, der eine Programmiersprache mit den notwendigen Komponenten eines Computers verbindet. Dieses Prinzip ermöglicht es Programmen, auf allen Systemen zu funktionieren, auf denen eine virtuelle Maschine installiert ist.

Merkmale der Programmiersprache

Die objektorientierte und typisierte Java-Sprache hat viele Funktionen, die für Entwickler nützlich sind. Unter ihnen sind die folgenden:

• Leichtigkeit des Lernens. Grundkenntnisse der objektorientierten Programmierung reichen für eine komfortable Beherrschung der Sprache aus.
• Objektorientierte Methodik. Programme bestehen aus Objekten, die einfach erweitert und an Ihre Ziele angepasst werden können.
• Sicherheit. Die Verschlüsselung mit öffentlichen Schlüsseln bietet die besten Authentifizierungsmethoden.
• Plattformunabhängigkeit. In der Sprache geschriebene Programme werden in Bytecode kompiliert, der auf absolut jeder Plattform moderner Betriebssysteme ausgeführt werden kann.
• Portabilität. Eine Programmiersprache hängt in keiner Weise von den Implementierungsaspekten von Spezifikationen ab.
• Stärke. Die Java-Maschine ist in der Lage, mit vielen Fehlern fertig zu werden, da sich der Entwickler auf die ständige Überprüfung und Reduzierung der Kompilierungszeit konzentriert und betont.

Zudem ist diese Sprache sehr verbreitet, da sie sich als multithreaded, performant, interpretiert und dynamisch auszeichnet.

Funktionen von Java-Programmierplattformen

Es gibt mehrere Implementierungen dieser Plattform, unter denen Eclipse einen besonderen Platz einnimmt. Die Entwicklungsumgebung für modulare plattformübergreifende Anwendungen verfügt über eine Reihe obligatorischer Funktionen, die auch in anderen ähnlichen Produkten vorhanden sind. Darunter sind:

• Gängige Technologien zum Bereitstellen von Programmen in einer Benutzerumgebung.
• Tools zum Erstellen grafischer Schnittstellen beliebiger Komplexität.
• Bibliotheken für die Fernsteuerung von Objekten und den programmgesteuerten Zugriff auf Daten.
• Tools zum Starten, Debuggen, Kompilieren, Überwachen und für andere Aktionen mit Anwendungen.

Was ist Eclipse?

Eclipse ist eine Entwicklungsumgebung, die derzeit von der Eclipse Foundation kontrolliert wird. Es bietet Open-Source-Code, der Entwicklern neue Möglichkeiten bietet. Es ist in Java geschrieben und soll den Prozess der Softwareerstellung verbessern.

Dieses Projekt ist eine Infrastruktur, die grundlegende Dienste bereitstellt, die für Entwickler wichtig sind. Mit den verfügbaren Tools können Sie neue Technologien in Eclipse erstellen. Die Entwicklungsumgebung ist nicht nur eine Sammlung von APIs – sie kann vollwertige Aufgaben übernehmen.

Eine große Anzahl von Open-Source-Plugins bietet unbegrenzte Möglichkeiten für Toolkit-Entwickler. Dem Programm können beliebige Ergänzungen hinzugefügt werden, wodurch Sie es letztendlich individuell anpassen und an jede Aufgabe anpassen können.

Plattformfunktionen

Die Programmierumgebung hat folgende Features:

• Eine breite API-Assembly zum Hinzufügen neuer Module sowie ein Framework zum Programmieren beliebiger Erweiterungen.
• Unterstützung für alle gängigen Betriebssysteme.
• Die Programmierung in den meisten bekannten Sprachen ermöglicht genau die Eclipse - Entwicklungsumgebung. C Sharp (C#), Java, PHP, C, Python, C++ und viele andere Sprachen werden von diesem Programm unterstützt.
• Die RCP-Technologie ist verfügbar, deren Fähigkeiten ausreichen, um Client-Software beliebiger Komplexität und Größenordnung zu entwickeln.
• Die Modularität des Programms bietet unglaublichen Komfort und Flexibilität bei der Arbeit.

Das Eclipse-Projekt entwickelt sich in viele Richtungen weiter. Das Programm wird ständig verbessert und erweitert seine Funktionalität durch Hinzufügen neuer Plugins.

Plattformarchitektur

Die Programmierumgebung besteht aus mehreren Grundelementen. Das ist zum einen die Eclipse Runtime, die für den Betrieb von Modulen und Plugins zuständig ist. Diese Laufzeit umfasst grundlegende Funktionen. Dazu gehören die Verwaltung von Updates, die Interaktion mit dem System, die Konfiguration von Plugins und die Pflege des Hilfebereichs.

Zweitens ist dies die IDE selbst, die für die Verwaltung von Projekten, den führenden Elementen des Programms sowie für das Debuggen, die Teamentwicklung und das Suchen in Dateien verantwortlich ist.

Plugins wie PDE und Java Development Tools sind ebenfalls in Eclipse enthalten. Die Entwicklungsumgebung für Java-Programme und neue Add-Ons wird durch den Einsatz dieser Plug-Ins deutlich funktionaler.

Beispiele für andere spezialisierte Builds

Das obige Eclipse SDK ist eine der Plattformversionen. Mehrere weitere Builds der IDE sind mit einzigartigen Funktionen verfügbar, nämlich:

• Für Java EE-Entwickler. Die Version ist für die Programmierung von Unternehmens- oder Webanwendungen mit Java EE vorgesehen.
• Für JavaScript-Webentwickler. Ein Build zum Erstellen von Webprodukten mit CSS, XML, HTML und JavaScript.
• Für Java-Entwickler. Version zum Programmieren in Java.
• Für C/C++-Entwickler. Assembly für die Programmierung in C++ und C.

Jede Version hat einzigartige Funktionen, aber die grundlegende Funktionalität für Anfänger wird vollständig von der Standard-Eclipse (Entwicklungsumgebung) bereitgestellt. Lektionen dazu sind kostenlos im Internet verfügbar, was das Studium des Programms erheblich vereinfacht.

Konkurrenzprodukte

Diese Entwicklungsumgebung hat viele Konkurrenten, aber es ist unmöglich, den besten Vertreter endgültig auszuwählen. Eclipse kann getrost als das beliebteste angesehen werden. Fast alle Entwickler haben es dank einer Reihe unbestreitbarer Vorteile verwendet.

Bei der Entwicklung mobiler Anwendungen wird häufig Eclipse (Entwicklungsumgebung) verwendet. Die Android-Plattform entwickelt sich schnell und die Java-Sprachunterstützung der IDE zieht Entwickler an. Es ist jedoch erwähnenswert, dass seine Fähigkeiten viel größer sind.

Der Hauptkonkurrent des fraglichen Programms ist das Produkt NetBeans, und es ist völlig kostenlos. Sie müssen für die Eclipse-Lizenz bezahlen, und das schreckt einige Leute ab. Andere Konkurrenzprodukte sind IntelliJ IDEA, JDeveloper, Android Studio, DrJava und MyEclipse. Aber viele halten Eclipse für das Beste. Die Entwicklungsumgebung erfreut die Benutzer seit vielen Jahren und hört nicht damit auf!

Einführung

Zu dieser Zeit sind Informationstechnologien populär geworden, die sich in jeder Sekunde unseres Lebens rasant entwickeln. Sowohl der technologische als auch der informationelle Fortschritt, insbesondere in den letzten Jahren, hat einen großen Schritt nach vorne gemacht. Die moderne Menschheit entwickelt sich schnell zu einer Informationsgesellschaft, und dies geschieht insbesondere in sich schnell entwickelnden Ländern, die großen Wert auf die Entwicklung von Technologie und Informationstechnologie legen.

Viele Menschen haben Computer, seien es Desktop-PCs, Laptops oder Pocket-PCs, sowie Zugang zum Internet mit einer riesigen Menge an Unterhaltung und interessanten Ressourcen oder zu einem lokalen Netzwerk, das mit verschiedenen Unterhaltungsdiensten gefüllt ist. Dementsprechend lernen sich die Menschen kennen und es wird möglich, auf Distanz zu kommunizieren, um diese Aufgabe zu erleichtern, gibt es in unserer Zeit viele Lösungen, dieses Diplom widmete sich der Entwicklung eines Kommunikationsmittels zwischen Menschen in Echtzeit aus der Ferne.

Moderne Anwendungen müssen sicher, performant, verteilt und architekturneutral sein. All diese Faktoren haben dazu geführt, dass der eigentliche Prozess der Erstellung und Verteilung von Anwendungen auf einer Vielzahl von Maschinen mit unterschiedlichen Architekturen neu betrachtet werden muss. Portabilitätsanforderungen zwangen uns, die traditionelle Art der Erstellung und Bereitstellung von Binärdateien aufzugeben, die nativen Code enthalten und daher an eine bestimmte Plattform gebunden sind.

Java ist eine objektorientierte Sprache, die aufgrund ihrer Vorteile wie Multitasking, Unterstützung für Internetprotokolle und Multiplattform bequem und zuverlässig zu verwenden ist. Java ist eine interpretierte Sprache und jedes Java-Programm wird für eine hypothetische Maschine namens Java Virtual Machine kompiliert. Das Ergebnis einer solchen Kompilierung ist Java-Bytecode, der wiederum auf jedem Betriebssystem ausgeführt werden kann, vorausgesetzt, es gibt ein Java-Laufzeitsystem, das den Bytecode in den tatsächlichen Maschinencode eines bestimmten Systems interpretiert.

Die Ziele der Kursarbeit bestehen darin, die objektorientierte Programmiersprache Java zu studieren und Code in der Sprache Java zu erstellen.

Beschreibung der Entwicklungsumgebung

Eclipse integrierte Entwicklungsumgebung

Beschreibung der Eclipse-Entwicklungsumgebung

Es gibt viele IDEs für die Java-Entwicklung. Ein Beispiel sind:

3. IntelliJ-IDEE.

Für die Entwicklung der Kursarbeit wurde die integrierte Entwicklungsumgebung Eclipse gewählt.

Eclipse ist eines der besten Java-Tools, die in den letzten Jahren entwickelt wurden. Das Eclipse SDK ist eine integrierte Entwicklungsumgebung (IDE) auf Open-Source-Basis. Die Eclipse-Entwicklungsumgebung ist eine modulare Entwicklungsumgebung, die auf dem Softwarekern und Schnittstellen zum Schreiben und Verbinden zusätzlicher Module (Plugins, Plugin) basiert. Somit kann die Eclipse-Umgebung nicht nur zum Schreiben von Anwendungen in der Java-Sprache verwendet werden, sondern abhängig von den installierten Plugins auch für andere Zwecke.

Zu den wichtigsten Java-Tools von Eclipse gehören: ein Quellcode-Editor (Erstellen und Bearbeiten von Quellcode für Programme), Debugging-Tools und die Integration mit Ant.

Beim ersten Kennenlernen der Eclipse-IDE mag es für den ungeschulten Benutzer ein wenig abschreckend wirken. Um die Grundlagen der Arbeit mit dem System zu verstehen, müssen Sie die Grundkonzepte der Umgebung verstehen: Arbeitsbereich, Werkzeuge, Layouts, Editoren und Ansichten.

Im einfachsten Fall Arbeitsbereich (Arbeitsplatz) - Dies ist das Projektverzeichnis des Benutzers, in dem sich die Projektdateien befinden. Alles in diesem Verzeichnis wird als Teil des Arbeitsbereichs betrachtet.

Die Eclipse-Tools sind verfügbar, sobald die Anwendung gestartet wird. Es ist im Wesentlichen selbst eine Plattform mit einer Reihe verschiedener Hauptmenüfunktionalitäten, wobei eine Reihe von Projektmanagementvorgängen zuallererst hervorsticht. Die eigentliche Verarbeitung erfolgt in der Regel durch Add-Ons (Plugins), z. B. das Bearbeiten und Anzeigen von Projektdateien erfolgt durch JDT usw.

Die Werkzeuge (Werkbank) umfassen einen Satz entsprechender Redakteure und Darstellungen im Eclipse-Arbeitsbereich platziert (Abbildung 6). Für eine bestimmte Aufgabe wird ein bestimmter Satz von Editoren und Ansichten aufgerufen Perspektive oder Layout.

Layout ( Perspektive) ist eine Reihe von Ansichten und Editoren in der von Ihnen gewünschten Reihenfolge. Jedes Layout hat seinen eigenen Werkzeugsatz, einige Layouts können gemeinsame Werkzeugsätze haben. Es kann immer nur ein Layout aktiv sein. Das Umschalten zwischen verschiedenen Layouts erfolgt durch Drücken der Tasten „Strg+F8“.

Mithilfe von Layouts können Sie Ihren Arbeitsbereich an die jeweilige Aufgabenart anpassen, die Sie ausführen. Das Tutorial verwendet Layouts, die sich hauptsächlich auf die Java-Programmierung beziehen, wie z. B.: Debug, Java Browsing, Java.

Eclipse bietet auch die Möglichkeit, benutzerdefinierte Layouts zu erstellen.

Sie können das Layout mit dem Befehl Fenster / Perspektive öffnen öffnen.

Redakteure sind Softwaretools, mit denen Sie Operationen mit Dateien ausführen können (erstellen, öffnen, bearbeiten, speichern usw.).

Benutzer des Sprachprogrammierungsservers

Darstellung sind im Wesentlichen Ergänzungen zu den Editoren, die in der Regel begleitende oder ergänzende Informationen über die im Editor befindliche Datei anzeigen. Ansichten können mit dem Befehl Window / Show View geöffnet werden.

Projekt ( project) ist eine Sammlung von Anwendungsdateien und zugehörigen Add-Ons. Bei der Arbeit mit Java werden hauptsächlich Dateien mit folgenden Endungen verwendet: . Java. jsp. xml.

Zusatz ( Plug-in) bezieht sich auf eine Anwendung, die optional in Eclipse installiert werden kann. Ein Beispiel für ein Add-on wäre JDT.

Meister - Es handelt sich um ein Softwaretool, das dem Benutzer bei der Einrichtung und Durchführung eines komplexen Vorgangs hilft. Eclipse verfügt über viele verschiedene Assistenten, die die Arbeit des Benutzers im System bequem und effizient machen und einige der Routineoperationen übernehmen. Ein Beispiel für einen Assistenten kann ein Assistent zum Erstellen einer neuen Klasse sein, der dem Benutzer bei Vorgängen wie dem Erstellen einer neuen Datei im gewünschten Verzeichnis, dem Erstellen des anfänglichen Klassencodes, dem automatischen Platzieren von Modifikatoren usw. hilft.

System Anforderungen

Eclipse wurde für eine Vielzahl von Betriebssystemen wie Linux, Microsoft Windows und Mac OS entwickelt. Um es auszuführen, benötigen Sie JVM (Java Virtual Machine) - eine virtuelle Java-Maschine sowie JDK (Java Development Kit) - ein Set für die Java-Entwicklung.

Tabelle 1 – Systemanforderungen für die Eclipse-Entwicklungsumgebung

Installieren der Eclipse-Entwicklungsumgebung

Der erste Schritt besteht darin, die richtige Version der Java-Unterstützungsbibliotheken zu installieren. Es ist auf eclipse.org zu finden.

Fahren Sie nach der Installation von Java VM mit der Installation von Eclipse fort. Wir gehen auf die Seite zum Herunterladen von Eclipse-Dateien (http://www.eclipse.org/downloads/) und wählen dann die neueste fertige (Release-)Version für unsere Plattform aus.

Da Eclipse auf Java basiert, erfordert die Software zum Ausführen das Java Development Kit (JDK), ein kostenloses Java-Anwendungsentwicklungskit, das von der Oracle Corporation (früher Sun Microsystems) vertrieben wird und den Java-Compiler (javac), Standard-Java-Klassenbibliotheken und Beispiele enthält , Dokumentation, verschiedene Dienstprogramme und Java Executive (JRE). Das JDK enthält keine Java-IDE, daher muss ein reiner JDK-Entwickler einen externen Texteditor verwenden und seine Programme mit Befehlszeilendienstprogrammen kompilieren.

Abbildung 1 – JDK-Installationsfenster

Wenn der Eclipse-Bootloader zum ersten Mal gestartet wird, werden eine Reihe abschließender Einrichtungsschritte ausgeführt, bevor die Umgebung selbst angezeigt wird (z. B. Erstellen eines Arbeitsbereichsverzeichnisses zum Speichern von Projektdateien).

Abbildung 1.2 - Eclipse-Startfenster