Minimales Plug-in

Aussehen und Funktionsweise von "Hello World" in herkömmlichen unformatierten Java-Code ohne die Verwendung einer Benutzerschnittstelle oder eines anderen Gerüsts sind relativ bekannt.

   public class HelloWorld {
      public static void main(String[] args) {
         System.out.println("Hello World");
      }
   }

Wie verhält sich dieser Klassiker jetzt im Kontext der Eclipse-Plattform? In diesem Fall darf man sich "Hello World" nicht als in sich selbst enthaltenes Programm vorstellen, sondern muss es als eine Erweiterung der Plattform begreifen. Da mit diesem Plug-in eine Begrüßung ("Hello World!") erfolgen soll, muss ein Konzept entwickelt werden, wie die Workbench mit dieser Begrüßung erweitert werden kann.

Indem die Benutzerschnittstellenkomponenten der Plattform in diesem Zusammenhang intensiver erläutert werden, erhalten Sie umfassende Beschreibungen der Methoden, mit denen Sie die Benutzerschnittstelle der Workbench erweitern und anpassen können. Zunächst soll eine der einfachsten Workbench-Erweiterungen vorgestellt werden: eine Sicht.

Das Workbench-Fenster kann mit einer Art Rahmen für unterschiedliche optische Bestandteile verglichen werden. Diese Bestandteile lassen sich in zwei Hauptkategorien, nämlich Sichten und Editoren (letztere werden später behandelt), untergliedern. Sichten enthalten Informationen über ein Objekt, mit dem der Benutzer in der Workbench arbeitet. Sie ändern häufig ihren Inhalt, und zwar abhängig davon, welche anderen Objekte der Benutzer in der Workbench auswählt.

Sicht "Hello World"

Für das Plug-in "Hello World" soll nun eine eigene Sicht implementiert werden, die den Benutzer mit den Worten "Hello World" begrüßt.

Das Paket org.eclipse.ui und seine Unterpakete enthalten die öffentlichen Schnittstellen, mit denen die Workbench-API für Benutzerschnittstellen definiert wird. Viele diese Schnittstellen sind mit Standardimplementierungsklassen ausgestattet, durch deren Erweiterung Sie einfache Änderungen am System vornehmen können. Im Beispiel von "Hello World" wird die Workbench-Sicht durch eine Anzeigenobjekt erweitert, das eine Begrüßung ausgibt.

Die entsprechende Schnittstelle hierbei ist die Schnittstelle IViewPart. Sie definiert die Methoden, die implementiert werden müssen, um die Workbench durch eine Sicht zu ergänzen. Die Klasse ViewPart stellt eine Standardimplementierung dieser Schnittstelle zur Verfügung. In einer Nutshell ist der Sichtabschnitt für die Erstellung der Fensterobjekte zuständig, die zum Anzeigen der Sicht erforderlich sind.

Die Standardsichten in der Workbench zeigen häufig bestimmte Informationen zu einem Objekt an, das ein Benutzer ausgewählt hat oder in dem er navigiert. Sichten aktualisieren ihren Inhalt gemäß der Aktionen, die in der Workbench stattfinden. Im vorliegenden Fall soll lediglich die Begrüßung "Hello World" ausgegeben werden, daher ist die Sicht relativ einfach strukturiert.

Plug-ins unter Verwendung von Tools schreiben

Eclipse-Plug-ins können Sie mit jeder gewünschten Java-IDE erstellen. Im Folgenden werden jedoch die Schritte für die Erstellung eines Plug-ins mit der Eclipse-Java-IDE vorgestellt.   Falls Sie noch nicht mit der Eclipse-Workbench und der Java-IDE vertraut sind, finden Sie im Benutzerhandbuch für die Java-Entwicklung weitere Erläuterungen der ausgeführten Schritte.   An dieser Stelle soll insbesondere der Code, nicht das Tool behandelt werden.  Es gibt jedoch einige IDE-Richtlinien für die ersten Schritte.

Eigene Umgebung einrichten

Wenn Sie in einer bereinigten Umgebung beginnen, müssen Sie sicherstellen, dass Ihr Code auf das Plug-in org.eclipse.ui zugreifen kann. Importieren Sie dieses Plug-in und alle von ihm benötigen Plug-ins in Ihr Laufzeitexemplar der Workbench, bevor Sie die unten beschriebenen Schritte ausführen. Falls diese Plug-ins in Ihrem Workbenchexemplar bereits vorhanden sind, fahren Sie mit dem Abschnitt "Eigenes Plug-in-Projekt erstellen" fort.

  1. Wählen Sie in der Perspektive "Ressourcen" die Optionen Datei > Importieren... > Externe Plug-ins und Fragmente aus.
  2. Klicken Sie so oft auf die Schaltfläche Weiter >, bis die Anzeige Auswahl aufgerufen wird. Diese Anzeige enthält eine Liste aller Plug-ins in Ihrem Host-Workbench-Exemplar.
  3. Wählen Sie das Plug-in "org.eclipse.ui" aus, und klicken Sie auf die Schaltfläche Erforderliche Plug-ins hinzufügen.
  4. Klicken Sie auf die Schaltfläche Fertig stellen. Die Sicht "Navigator" sollte jetzt das Plug-in "org.eclipse.ui" und alle von ihm benötigten Plug-ins (einschließlich org.eclipse.swt) enthalten.

Eine vollständige Erläuterung für die Einrichtung der Host- und Laufzeitexemplare der Workbench können Sie im PDE-Handbuch nachlesen.

Eigenes Plug-in-Projekt erstellen

  1. Sie müssen ein Projekt erstellen, um Ihre Arbeit ausführen zu können.   Die einfachste Methode ist das Öffnen des Assistenten Neues Projekt... (Datei > Neu > Projekt...) und die Auswahl der Option Plug-in-Projekt in der Kategorie Plug-in-Entwicklung.  Hierdurch wird Ihr Projekt für das Schreiben von Java-Code definiert, und Sie erhalten eine Standardmanifestdatei für das Plug-in (dies wird an einer späteren Stelle noch erläutert).  Verwenden Sie org.eclipse.examples.helloworld als Namen für Ihr Projekt. Standardmäßig gibt Ihnen der Assistent zwar die Möglichkeit, Code für unterschiedliche Typen von Plug-ins zu generieren, aber im Folgenden soll lediglich ein einfacher Fall dargestellt werden.  Daher müssen Sie jetzt lediglich die Option Leeres Plug-in-Projekt erstellen auf der Seite Generatoren für Plug-in-Code auswählen.
  2. Sobald Sie gefragt werden, ob Sie in die Perspektive "Plug-in-Entwicklung" wechseln möchten, antworten Sie mit Ja.
  3. Erstellen Sie unterhalb des Verzeichnisses src ein Paket org.eclipse.examples.helloworld für das Projekt. Doppelklicken Sie hierzu in der Sicht "Paket-Explorer" auf das Projekt org.eclipse.examples.helloworld. Dies erweitert das Projekt und zeigt das Verzeichnis src an. Klicken Sie mit der rechten Maustaste auf das Verzeichnis src, um das Kontextmenü aufzurufen. Wählen Sie Neu > Paket aus, um ein neues Paket zu erstellen, und benennen Sie das Paket mit org.eclipse.examples.helloworld.
  4. Erstellen Sie in diesem Paket eine neue Klasse namens HelloWorldView. Klicken Sie mit der rechten Maustaste auf das Paket, das Sie gerade erstellt haben, um das Kontextmenü aufzurufen. Wählen Sie die Optionen Neu > Klasse aus, um eine neue Klasse namens HelloWorldView zu erstellen.

Code schreiben

Jetzt können Sie sich mit dem Code beschäftigen.  Das folgende Beispiel enthält alle Angaben, die Sie in HelloWorldView benötigen.  (Sie können den unten angegebenen Inhalt in die von Ihnen erstellte Klasse kopieren.) 

   package org.eclipse.examples.helloworld;

   import org.eclipse.swt.widgets.Composite;
   import org.eclipse.swt.widgets.Label;
   import org.eclipse.swt.SWT;
   import org.eclipse.ui.part.ViewPart;

   public class HelloWorldView extends ViewPart {
      Label label;
      public HelloWorldView() {
      }
      public void createPartControl(Composite parent) {
         label = new Label(parent, SWT.WRAP);
         label.setText("Hello World");
      }
      public void setFocus() {
         // Mein Widget fokussieren. Bei einem Label ist dies nicht sehr
         // sinnvoll, bei einer komplexeren Gruppe von Widgets
         // sollten Sie jedoch festlegen, welches Objekt fokussiert werden soll.
      }
   }

Der Sichtabschnitt erstellt die Fensterobjekte, durch die die Sicht dargestellt wird, in der Methode createPartControl. Im vorliegenden Beispiel wird ein SWT-Anzeigenobjekt erstellt und mit dem Text "Hello World" gefüllt. 

Jetzt können Sie die neue Klasse kompilieren. Vorher sollten Sie jedoch sicherstellen, dass die Angabe .classpath richtig konfiguriert ist, damit der Code kompiliert werden kann.  

  1. Wählen Sie das Projekt org.eclipse.examples.helloWorld aus, und öffnen Sie den Dialog Eigenschaften (klicken Sie mit der rechten Maustaste auf das Projekt org.eclipse.examples.helloWorld, und wählen Sie dann > Eigenschaften) aus.
  2. Wählen Sie unter den Eigenschaften Java-Erstellungspfad die Registerkarte Projekte aus, und aktivieren Sie die Markierungsfelder für die Projekte  org.eclipse.ui und org.eclipse.swt. Diese Projekte enthalten die importierten Klassen.
  3. Jetzt müssen Sie das Projekt erneut erstellen

Die Sicht ist hiermit kompiliert worden.  Die neue Sicht sieht in etwa so aus:

Einfache Sicht mit Angabe 'Hello World'

Jetzt muss der Code ausgeführt und diese Sicht zur Workbench hinzugefügt werden.

Plug-in "Hello World"

Die Plattform muss darüber informiert werden, dass sie durch eine Sicht ergänzt werden soll. Dies erfolgt durch die Erweiterung des Erweiterungspunkts org.eclipse.ui.views. Die Erweiterung wird durch die Angabe einer Manifestdatei namens plugin.xml registriert, die das Plug-in (inklusive der Position seines Codes) und die hinzugefügte Erweiterung beschreibt.

(Diese Informationen können Sie in die Datei plugin.xml kopieren, die bei der Erstellung des Projekts generiert wurde.)

   <?xml version="1.0" ?>
   <plugin
      name="Hello World Example" 
      id="org.eclipse.examples.helloworld"
version="1.0">
   <requires>
         <import plugin="org.eclipse.ui" />
   </requires>
      <runtime>
         <library name="helloworld.jar" />
      </runtime>
      <extension point="org.eclipse.ui.views">
      <category 
            id="org.eclipse.examples.helloworld.hello"
            name="Hello" />
         <view 
            id="org.eclipse.examples.helloworld.helloworldview"
            name="Hello Greetings"
            category="org.eclipse.examples.helloworld.hello"
class="org.eclipse.examples.helloworld.HelloWorldView" />
      </extension>
   </plugin>

In dieser Datei werden der Name, die ID und die Version für das Plug-in definiert.

Außerdem müssen die erforderlichen Plug-ins aufgelistet werden. Da in Ihrem Plug-in die Workbench und die SWT-API verwendet werden, muss org.eclipse.ui aufgeführt sein. Des Weiteren müssen Sie angeben, wo sich der ausführbare Code befindet. Der Code soll in ein Paket namens helloworld.jar gestellt werden. Daher wird dieser Name als Name der Bibliothek registriert.

Abschließend muss deklariert werden, welchen Erweiterungspunkt das Plug-in ergänzt. Die Erweiterung org.eclipse.ui.views umfasst mehrere unterschiedliche Konfigurationsparameter. Als Erstes wird eine Kategorie für die Sichterweiterung deklariert. Mit Hilfe von Kategorien werden verwandte Sichten im Workbench-Dialog Sicht anzeigen gruppiert. Für die Sicht wird eine eindeutige ID deklariert, und der Name der Klasse, die die Implementierung der Sicht bereitstellt, muss angegeben werden. Außerdem wird ein Name für die Sicht ("Hello Greetings") definiert, der im Dialog "Sicht anzeigen" und in der Titelleiste der Sicht angezeigt wird.

IDs von Plug-ins

In der Manifestdatei eines Plug-ins werden viele IDs verwendet. Einzelne Erweiterungspunkte definieren häufig Konfigurationsparameter, die IDs benötigen (z. B. die oben verwendete Kategorie-ID des Erweiterungspunktes für Sichten). Außerdem wird eine ID für das Plug-in definiert. Im Allgemeinen sollten Sie für alle Ihre IDs die Präfixe der Java-Paketnamen verwenden, um die Eindeutigkeit unter allen installierten Plug-ins zu gewährleisten.

Der spezifische Name, der nach dem Präfix verwendet wird, kann frei gewählt werden. Wenn das Präfix der Plug-in-ID jedoch mit dem Namen eines Ihrer Pakete identisch ist, sollten Sie die Verwendung von Klassennamen aus diesem Paket vermeiden. Andernfalls können Sie nur schwer erkennen, ob es sich bei einem angezeigten Wert um einen ID-Namen oder einen Klassennamen handelt.

Auch die Verwendung derselben ID für unterschiedliche Konfigurationsparameter des Erweiterungspunktes sollte vermieden werden. Im oben dargestellten Manifest wurde ein gemeinsames Präfix für die ID verwendet (org.eclipse.examples.helloworld), alle IDs selbst sind jedoch eindeutig. Durch diesen Benennungsansatz können Sie die Datei leichter lesen und einfacher feststellen, welche IDs zusammengehören.

Nächster Schritt

Bislang haben Sie eine Sicht implementiert und die Ergänzung im Plug-in-Manifest deklariert.   Jetzt müssen Sie das Plug-in in der Plattform installieren, damit es ausgeführt werden kann.

Copyright IBM Corporation und Andere 2000, 2003.