© istockphoto.com/serazetdinov, © S&S Media
Anhebung einer Eclipse-RCP-Anwendung auf die Eclipse-4-Plattform

Der Weg in die neue Welt


Seit 2012 ist die Eclipse-4-Plattform als Grundlage für Eclipse-basierte Anwendungen verfügbar. Seitdem werden neue Anwendungen auf dieser Plattform gebaut. Die modernen Techniken, auf denen die Plattform aufsetzt, machen sie attraktiv für neue RCP-Anwendungen, beispielsweise der modellbasierte deklarative Ansatz des Application Models, die Verwendung von Dependency Injection und ein globaler Event Bus. Während neue Anwendungen bereits häufig die 4.x-Plattform als Basis verwenden, gibt es noch viele ältere Anwendungen, die auf der 3.x-Plattform entwickelt und noch nicht umgestellt wurden. Begründet wird dies meist mit dem Aufwand und den fehlenden Beschreibungen, wie eine solche Migration angegangen werden soll. Diese Lücke soll durch das folgende Tutorial, das eine Schritt-für-Schritt-Anleitung für eine 3.x-zu-4.x-Migration darstellt, geschlossen werden.

Welche Komponenten müssen migriert werden? Generell müssen alle Elemente migriert werden, die bisher via Extension Points in der plugin.xml definiert wurden. Dazu gehören zum Beispiel:

  • org.eclipse.ui.perspectives

  • org.eclipse.ui.perspectiveExtensions

  • org.eclipse.ui.views

  • org.eclipse.ui.editors

  • org.eclipse.ui.menus

  • org.eclipse.ui.actionSets

  • org.eclipse.ui.commands

  • org.eclipse.ui.handlers

  • org.eclipse.ui.preferencePages

Ein guter Indikator für Elemente, die migriert werden müssen, ist die Verbindung zum Plug-in org.eclipse.ui. Um einen Überblick über die zu migrierenden Komponenten zu erhalten, ist das E34MigrationTooling von Olivier Prouvost [3] sehr hilfreich (siehe Artikel „Aus Alt mach Neu“, S. 32 in dieser Ausgabe). Es gibt Aufschluss darüber, welche Elemente konkret innerhalb eines Plug-ins migriert werden müssen. Nach dem Installieren des E34MigrationTool­ings ist die Migration Stats View in der IDE verfügbar. Diese View reagiert auf die Selektion von Plug-in-Projekten und zeigt alle verwendeten Eclipse 3.x Extension Points und zu migrierenden Elemente auf.

Werkzeuge und Beispielanwendung

Für das Migrationstutorial werden folgende Werkzeuge benötigt:

  • Java 8 (mit aktuellem Update) [1]

  • Eclipse Mars [2]

  • Eclipse 4 Migration Tooling [3]

  • Eclipse Model Spy [4]

Als Basis für diese Migrationsbeschreibung wird die auf GitHub gehostete Beispielanwendung unter [5] verwendet. Es handelt sich dabei um eine kleine RCP-Anwendung, um personenbezogene Daten zu verwalten (Abb. 1).

fauth_1.tif_fmt2.jpg Abb. 1: Beispielanwendung

Unter Verwendung von EGit lassen sich die Projekte der Beispielanwendung einfach importieren:

Abbildung 2 zeigt die Migration Stats View für das Plug-in-Projekt org.fipro.eclipse.migration.ui aus der Beispielanwendung. Die rot hervorgehobenen Exten­sion Points, die auch im oberen rechten Bereich unter Deprecated Extension points gelistet sind, werden im Compatibility Layer nicht mehr unterstützt und müssen migriert werden, um zu funktionieren. Die Usual Extension Points hingegen können im Compatibility Layer weiterhin genutzt werden, da sie durch das ­Eclipse Framework zu e4-Elementen transformiert werden.

fauth_2.tif_fmt1.jpgAbb. 2: Migration Stats View des E34MigrationTooling von Olivier Prouvost

Softmigration (Compatibility Layer)

Bei der Entwicklung der Eclipse-­4.x-Plattform wurde besonderes Augenmerk darauf gelegt, dass auf ­Eclipse 3.x basierende Anwendungen noch immer lauffähig sind. Gelöst wurde dies über den Einbau des Compatibility Layers, der ­Eclipse-3.x-basierte Komponenten in das Eclipse-4.x-­Modell transferiert. Der Compatibility Layer er­mög­licht auch einen hybriden Ansatz, sodass eine Eclipse-3.x-­­Anwendung mit Eclipse-4.x-Komponenten erweitert werden kann. Die Eclipse IDE selbst nutzt diesen hybriden Ansatz, da noch viele IDE-Plug-ins und Third-Party-Plug-ins nicht auf das neue Programmiermodell umgestellt wurden.

Die Unterstützung dieses hybriden Modus erlaubt es außerdem, eine Softmigration durchzuführen, in der Komponenten Schritt für Schritt vom Eclipse-3.x- zum ­Eclipse-4.x-Programmiermodell umgestellt werden können. Dabei ist die Anwendung nach jedem Schritt immer noch lauffähig, und es ist nicht erforderlich, über eine sofortige vollständige Migration „den Schalter umzulegen“.

Target Platform

Als erster Schritt der Migration muss die Target Platform angepasst werden. Damit werden die für Eclipse 4 notwendigen Plug-ins als Basis zur Verfügung gestellt, sodass das Eclipse-4.x-Programmiermodell genutzt werden kann.

Die diesem Tutorial zugrunde liegende Target Definition ist im Projekt org.fipro.eclipse.migration.target in der Datei org.fipro.eclipse.migration.target.target hinterlegt. Nach dem Öffnen dieser Datei mit dem Target Definition Editor muss zuerst die eingetragene Softwaresite http://download.eclipse.org/releases/indigo/ entfernt werden. Anschließend wird die Eclipse Mars Platform der Target Platform über folgende Schritte hinzugefügt:

  • Add… → Software Site

  • Auswählen der Softwaresite mit dem URL http://download.eclipse.org/releases/mars/

  • Auswählen der erforderlichen FeaturesHinweis:Die folgenden Features lassen sich am besten finden, wenn man Group by Category deaktiviert und nach Eclipse filtert.

    • Eclipse RCP SDK

    • Eclipse Platform Launcher Executables

    • Eclipse Java Development Tools (nur notwendig für JUnit Testing)

Nachdem die Target Platform aufgelöst und heruntergeladen wurde, sollte der Target Definition Editor ähnlich Abbildung 3 dargestellt werden. Die Target Platform muss anschließend über Set as Target Platform in der rechten oberen Ecke des Target Definition Editors aktiviert werden.

fauth_3.tif_fmt1.jpgAbb. 3: Laden und Setzen der neuen Eclipse 4 Target Platform

Product Configuration

Nachdem die Target Platform umgestellt wurde, muss die Product Configuration angepasst werden, sodass diese die notwendigen Eclipse-4-Features enthält.

  • Die Datei org.fipro.eclipse.migration.product im Projekt org.fipro.eclipse.migration.product öffnen

    • Zum Reiter Dependencies wechseln
      Hinweis: Ab Eclipse 4.5.1 Mars SR1 wird der Reiter Content heißen [7]

      • Die folgenden Features hinzufügen:

        • org.eclipse.e4.rcp

        • org.eclipse.emf.ecore

        • org.eclipse.emf.common

      • Die Versionsangabe des Features org.eclipse.rcp über Properties entfernen
        Hinweis: Dieses Feature wird nach der vollständigen Migration auf Eclipse 4 entfernt und wird nur für die Softmigration über den Compatibility Layer benötigt.

    • Zum Reiter Launching wechseln

      • -clearPersistedState zu den Program ­Arguments hinzufügen
        Hinweis: Dieses Argument ist nur für den Entwicklungszeitraum erforderlich, um Änderungen im Application Model sofort darzustellen. Er sollte in einer Produktivumgebung wieder entfernt werden.

Migration von ViewParts

Das neue Programmiermodell der Eclipse-4-Plattform zeichnet sich durch die Verwendung von POJOs und Dependency Injection aus. Verglichen mit der Eclipse-3-­Plattform sind Implementierungen von Interfaces und abstrakten Klassen nicht mehr notwendig, um die Plattform zu nutzen.

Seit Luna unterstützt der Extension Point org.eclipse.ui.views zusätzlich zu view-Einträgen auch e4view-Einträge. Damit ist es möglich, Views der Anwendung hinzuzufügen, die nach dem Eclipse-4-Programmiermodell aufgebaut sind. Mit folgenden wenigen Schritten können so im Rahmen der Softmigration die ersten Teile einer Anwendung migriert werden:

  • Die Datei MANIFEST.MF im Projekt org.fipro.­eclipse.­migration.ui öffnen

  • Zum Reiter Dependencies wechseln

    • Die folgenden Bundles den REQUIRED PLUG-INS hinzufügen

      • org.eclipse.e4.core.di

      • org.eclipse.e4.ui.di

      • org.eclipse.e4.ui.model.workbench

      • org.eclipse.e4.ui.workbench

      • org.eclipse.e4.ui.services

  • Die Klasse DescriptionView migrieren
    Das Ergebnis sollte ähnlich wie in Listing 1 aussehen.

    • Die Klassenhierarchie entfernen (extends ViewPart)

    • Die Annotation der Methode createPartControl() von @Override zu @PostConstruct ändern

    • Die Methode setFocus() entfernen

    • Die Methode dispose() entfernen

  • Die Klasse OverviewView migrieren
    Das Ergebnis sollte ähnlich wie in Listing 2 aussehen.

    • Die Klassenhierarchie entfernen (extends ViewPart)

    • Die Annotation der Methode createPartControl() von @Override zu @PostConstruct ändern

    • Die Annotation der Methode setFocus() von @ Over­ride zu @Focus ändern

    • Anpassung des Codes für das Öffnen eines Editors

      • Einen IWorkbenchPage-Parameter der Methode create­PartControl() hinzufügen, sodass diese injiziert werden kann

      • openEditor() auf der injizierten IWorkbenchPage aufrufen, anstatt über getSite() nach der aktiven IWorkbenchPage zu suchen

  • Die Datei plugin.xml im Projekt org.fipro.eclipse.migration.ui öffnen

    • Zum Reiter Extensions wechseln

    • Den Extension Point org.eclipse.ui.views öffnen

      • Einen e4view-Eintrag für die OverviewView hinzufügen und die Werte aus dem view-Eintrag der OverviewView übernehmen

      • Einen e4view-Eintrag für die DescriptionView hinzufügen und die Werte aus dem view-Eintrag der DescriptionView übernehmen

      • Die alten view-Einträge für die OverviewView und die DescriptionView entfernen

Listing 1

public class DescriptionView {
 
  Text description;
  
  @PostConstruct
  public void createPartControl(Composite parent) {
    parent.setLayout(new FillLayout());
    description = new Text(parent, SWT.MULTI | SWT.WRAP | SWT.READ_ONLY);
  }
 
  ...
}

Listing 2

public class OverviewView {
 
  TableViewer viewer;
 
  @PostConstruct
  public void createPartControl(Composite parent, final IWorkbenchPage workbenchPage) {
    parent.setLayout(new GridLayout());
    IObservable list = new WritableList(PersonService.getPersons(10), Person.class);
    viewer = new TableViewer(parent, SWT.MULTI|SWT.BORDER|SWT.H_SCROLL|SWT.V_SCROLL|SWT.FULL_SELECTION);
        ...
    
    // hook double click for opening an editor
    viewer.addDoubleClickListener(new IDoubleClickListener() {
      
      @Override
      public void doubleClick(DoubleClickEvent event) {
        ISelection selection = viewer.getSelection();
        if (selection != null && selection instanceof IStructuredSelection) {
          Object obj = ((IStructuredSelection) selection).getFirstElement();
          // if we had a selection lets open the editor
          if (obj != null) {
            Person person = (Person) obj;
            person....

headline from sands settings