In diesem Artikel erhalten Sie Tipps, um Ecplise-3-Anwendungen vollständig oder teilweise in Eclipse-4-Anwendungen zu überführen. Zunächst werden wir uns mit einigen Grundprinzipien von Eclipse 4 beschäftigen. Danach folgt eine Schritt-für-Schritt-Anleitung, mit der sich Anwendungen erfolgreich migrieren lassen. Schließlich wollen wir die Migration eines echten kleinen Beispielprojekts demonstrieren.
Die Eclipse-3-Architektur (e3) bietet zweifellos viele nützliche Funktionalitäten. Dazu gehört die OSGi-basierte Architektur, die Definition von Extension Points und ein umfangreiches Set an Plug-ins, das wiederverwendet werden kann, um beliebige portable Anwendungen zu schreiben. Trotzdem leidet das e3-Entwicklungsmodell unter verschiedenen Problemen: So kann man kein UI ohne SWT/JFace entwickeln, es gibt keinen Injection-Mechanismus und viele der APIs wurden nicht einheitlich implementiert.
In diesem Kontext kann es interessant sein, eine Migration einer existierenden Anwendung in Erwägung zu ziehen, insbesondere dann, wenn die Anwendung noch einige Jahre genutzt werden soll. Sollte sich die Anwendung bereits dem Ende ihres Lebenszyklus nähern, kann man natürlich weiterhin das e3-Entwicklungsmodell beibehalten oder aber den Compatibility Layer einsetzen, der einige der e4-Konzepte automatisch zur Verfügung stellt.
e4-Prinzipien
Kernkonzept von e4 ist sein Anwendungsmodell, das dynamisch zur Laufzeit gerendert wird. Das funktioniert in etwa so, als ob man alle e3-UI-Extensions auf hierarchische Weise definieren würde, statt sie auf dem gleichen Level in verschiedenen plugin.xml-Files anzulegen. Eine andere interessante Eigenschaft des Anwendungsmodells ist, dass es „UI-agnostisch“ ist: UI-Code lässt sich sowohl per SWT als auch über JavaFX einbinden. Mit dem Modell verbundene Klassen sind POJOs ohne Einschränkungen in Sachen Vererbung. Veränderungen der UI-Struktur erfolgen durch das Modifizieren des Modells über ein Standard-EMF-API, was sehr dazu beiträgt, den Quellcode zu vereinheitlichen (einem Modell ein Element hinzuzufügen, erfordert nur ein get von der Liste der Elemente und ein einfaches add).
Das Eclipse-4-Entwicklungsmodell stellt außerdem einen nativen Injection-Mechanismus zur Verfügung. Ein einfaches Beispiel: Wenn Sie etwa eine neue View definieren möchten, müssen Sie sich nicht um die UI-Vererbung kümmern. Sie erstellen einfach ein POJO mit einer Reihe von Annotationen, und das UI wird mit den richtigen Parametern aufgerufen, die es vom Injector erhalten hat (Parent Composite für SWT Views und entsprechend andere Parents für JavaFX).
Eines der wichtigsten Features des e4 Injectors ist, dass Injection-Kontexte hierarchisch sind und abhängig von der Hierarchieebene des Codes verwendet werden: Eine Parent-Composite-Instanz wird auf dem View-Level verfügbar sein, während die aktuelle Selection auf Anwendungsebene oder in einem der Unterkontexte verfügbar ist.
Eine weitere Eigenschaft des e4-Injection-Mechanismus ist, dass ein in die Parameter einer Methode oder in ein Klassenfeld injizierter Wert vom System gespeichert wird, um die Methode später wieder aufrufen oder den Wert neu initialisieren zu können, wenn er sich im Kontext ändert. Dadurch lassen sich sehr einfach Methoden schreiben, um mit der aktuellen Selection umzugehen (Listing 1).
Listing 1
@Inject @Optional
public void reactOnSelection(@Named(IServiceConstants.ACTIVE_SELECTION) YourClassType selection)
{
// Work directly with your unique selection instance
}Wie Sie sehen, können Sie die Selection im erwarteten Typ erstellen, und es besteht keine Notwendigkeit, einen spezifischen Listener hinzuzufügen oder zu entfernen. Man injiziert einfach die benötigte Instanz, die automatisch aktualisiert wird, wenn sich etwas ändert.
Architekturale Belange
Wie schon beschrieben, wird eine e4-Anwendung auf Basis des Anwendungsmodells definiert. Die Frage lautet nun: Wie können wir mit Modularität umgehen? Sollten wir etwa nur ein Applikationsmodell in einem Plug-in definieren? Natürlich nicht, und es gibt Mechanismen, um genau das zu vermeiden.
Diese Mechanismen müssen eingesetzt werden, um eine Anwendung modular zu halten, und sie sind auch notwendig, um eine Anwendung in einem gemischten e3-/e4-Modus zu betreiben. Wenn Sie Ihre Lieblings-IDE Eclipse Mars ausführen, starten Sie eine e3-Anwendung, die automatisch in ein e4-Modell migriert wird. Dieses Modell steht dem Programmierer zwar nicht physisch zur Verfügung, kann aber unter Verwendung von Fragmenten oder Prozessoren verändert werden. Wir werden diese zwei Mechanismen für die Migration nutzen, um die Modularität zu erhalten und nah an der ursprünglichen e3-Architektur zu bleiben.
Ein Model-Fragment ist eine Art Submodell, das in ein existierendes Modell eingefügt werden kann. Es wird unter Verwendung einer Anchor-ID und eines Content definiert. Sie können zum Beispiel eine beliebige Perspektive dem Perspective-Stack einer Hostanwendung hinzufügen, wenn Sie die ID kennen.
Allerdings kann der Umgang mit den IDs mühsam sein: Zwei ähnliche Anwendungen könnten dieselben Fragmente verwenden, aber unterschiedliche IDs aufweisen (siehe Bug # 437958 [1]). Seit Eclipse Mars ist es möglich, einen XPath-Ausdruck zu definieren, um auf den genauen Ort eines Modells zu zeigen. Zum Beispiel bedeutet xpath:/, dass Sie etwas auf dem Root-Level Ihres Modells hinzufügen (d. h. im Anwendungsmodell, Abb. 1).
Abb. 1: Via XPath lässt sich der Ort eines Modellfragments spezifizierenMit der folgenden XPath-Anweisung ist es möglich, eine Perspektive in den Default-Perspective-Stack einzufügen (siehe auch Bug #471305 [2]):
xpath://[@elementID='org.eclipse.ui.ide.perspectivestack']
Ein Model Processor ist ein Stück Code, mit dem sich das Modell direkt manipulieren lässt. Das Anwendungsmodell wird über eine Inject-Anweisung empfangen (@Inject MApplication appli;), der Code verändert es dann. Um in diesem Modell ein neues Element zu erzeugen, kann man einfach die EModelService-Instanz verwenden (natürlich wieder über inject) und die createModelElement-Methode aufrufen. Listing 2 zeigt, wie dabei zu verfahren ist.
Listing 2
import javax.inject.Inject;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.model.application.MAddon;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
public class SampleProcessor {
@Inject MApplication application; // Inject current application
@Inject EModelService modelService; // Inject model service to create instances
@Execute
public void processTheModel() {
// Create an add-on instance using the model service
MAddon addon = modelService.createModelElement(MAddon.class);
addon.setElementId("com.opcoach.eclipsemag.eap.addon");
String curi = "bundleclass://com.opcoach.eclipsemag.eap/com.opcoach.eclipsemag.eap.TestAddon";
addon.setContributionURI(curi);
// Add the add-on in current application model
application.getAddons().add(addon);
}
}Überprüfen Sie die e4-Kompatiblität Ihrer Anwendung
Die Entscheidung, ob Sie ihre Anwendung migrieren sollen oder nicht, hängt sicherlich von strategischen Überlegungen ab. Vorab müssen Sie allerdings prüfen, ob eine Migration technisch überhaupt möglich ist. Wenn Ihr Code beispielsweise viele interne Packages enthält, wird eine Migration nicht einfach machbar sein.
Die e4 Spies sind ein Toolset, das Entwicklern dabei hilft, e4-Konzepte zu visualisieren. Es gibt etwa einen Spy, um das Modell zur Laufzeit anzuzeigen, einen anderen, um Injection-Kontexte zu untersuchen etc. Zur Überprüfung der e4-Kompatibilität Ihrer Anwendung ist es eine gute Idee, diese Tools zu installieren, bevor Sie die Anwendung starten.
Sie können die Spies von der e4-Updateseite herunterladen [3]. Um das Tool zu öffnen, verwenden Sie einen der Shortcuts...

