Java desktop applicaties blijven een beetje achter qua populariteit in verhouding tot web gebaseerde applicaties. Toch heeft het Java platform alles in huis om heel mooie client side projecten te bouwen. De meeste programmeurs zullen de combinatie Java en client applicatie associëren met een Swing UI. Er zijn echter heel goede alternatieven! In een serie van drie blog artikelen wil ik de mogelijkheden van het Eclipse Rich Client Platform demonstreren. Dankzij RCP kan je razendsnel een professioneel ogende desktop applicatie bouwen. Dit zal ik laten zien aan de hand van een demo applicatie.

Dit eerste deel is bedoeld om bekend te raken met het ontwikkel- en bouwproces. Ook wordt er een simpel model gedefinieerd en een start gemaakt met de gebruikers interface. In het volgende deel zal de mogelijkheid worden toegevoegd om het model te bewerken. Hiervoor zullen concepten als wizards en editors worden geïmplementeerd. Tot slot zal een help functie, internationalisatie en een automatische update functie toevoegen worden. Wil je actief meebouwen, dan heb je Eclipse 3.3 nodig. De broncode van de demo applicatie is ook hier* (zie opmerking onderaan) te downloaden.

De plug-in definitie
De kleinste bouwsteen van elke RCP applicatie is een plug-in. Die kan je aanmaken door de New Plug-in Project wizard te doorlopen. Kies als naam com.finalist.rcp en als target platform Eclipse 3.3. Vul het volgende veld in zoals te zien is op afbeelding 1 en klik op finish. Er wordt nu een nieuw Java project gemaakt worden met een speciale manifest. Dit bestand wordt automatisch geopend in de manifest editor. Deze editor bestaat uit een aantal tabbladen, waarin instellingen als afhankelijkheden, extensies en het bouwproces gedefinieerd kan worden. De demo plug-in vereist twee dependencies naar standaard Eclipse plug-ins. Voeg aan de lijst van vereiste plug-ins toe (onder het tabblad Dependencies):

• org.eclipse.core.runtime
• org.eclipse.ui

Afbeelding 1: De nieuwe plug-in wizard

Een Eclipse plug-in is een bundel van code, plaatjes en property files met een eigen life-cycle. Plug-ins kunnen apart geactiveerd en gestopt worden. Eclipse gebruikt hiervoor een implementatie van de OSGi specificatie genaamd Equinox. Een bundel kan een speciale klasse definiëren, de activator, die gebruikt wordt om acties uit te voeren wanneer je plug-in start of stopt. Op het tabblad Overview van de manifest editor activeer je de optie Activate this plug-in when one of its classes is loaded en klik je op de Activator link om een nieuwe activator te maken. Maak de klasse com.finalist.rcp.RcpDemoPlugin aan. Equinox garandeert dat er maar een instantie van je plug-in tegelijk geactiveerd is. Vaak is het handig om deze instantie op te kunnen vragen, daarom maken we de RcpDemoPlugin als singleton beschikbaar voor de rest van de code. Override de functies start(BundleContext) en stop(BundleContext) en implementeer ze als volgt:

public class RcpDemoPlugin extends AbstractUIPlugin {
   private static RcpDemoPlugin plugin;
 
   public static RcpDemoPlugin getDefault() { return plugin; }
 
   public void start(BundleContext context) throws Exception {
      super.start(context);
      plugin = this;
   }
 
   public void stop(BundleContext context) throws Exception {
      plugin = null;
      super.stop(context);
   }
}

Het model
De demo applicatie zal het bijhouden van boeken in een bibliotheek modelleren. Voor nu hebben we aan twee klassen genoeg:

public class Library {
   private final Set<Book> books = new HashSet<Book>();
 
   public Set<Book> getBooks() { return books; }
}
 
public class Book {
   private String title;
 
   public String getTitle() { return title; }
   public void setTitle(String title) { this.title = title; }
}

De activator is een goed punt om het model ‘op te slaan’. Daarom krijgt de RcpDemoPlugin klasse een referentie naar een (de) bibliotheek.

public class RcpDemoPlugin extends AbstractUIPlugin {
   // ...
 
   private final Library library = new Library();
 
   public Library getLibrary() { return library; }
}

De gebruikers interface
Je hebt nu een werkende plug-in met model gemaakt. Wat nog ontbreekt is een gebruikers interface. Drie concepten spelen een centrale rol in de RCP gebruikers interface:

• Views – componenten die (een deel van) het model op een bepaalde manier presenteren.
• Editors – componenten die model elementen, of datastructuren kunnen bewerken.
• Perspectives – een verzameling views en een locatie om editors in te openen.

Een view is een klasse die de org.eclipse.ui.IViewPart interface implementeert. De demo applicatie krijgt een view die de bibliotheek in een boomstructuur toont. Maak daarom de klasse com.finalist.rcp.internal.ui.views.explorer.Explorer:

public class Explorer extends ViewPart {
   public static final String VIEW_ID = "com.finalist.rcp.views.explorer";
   private TreeViewer viewer;
 
   public void createPartControl(Composite parent) {
      viewer = new TreeViewer(parent);
      viewer.setComparator(new ViewerComparator()); // Lexicografisch
      viewer.setContentProvider(new ExplorerContentProvider());
      viewer.setLabelProvider(new ExplorerLabelProvider());
      viewer.setInput(RcpDemoPlugin.getDefault().getLibrary());
 
      // ...
   }
}
 
public class ExplorerContentProvider implements ITreeContentProvider {
   public Object[] getElements(Object inputElement) {
      if (inputElement instanceof Library) {
         return Library.class.cast(inputElement).getBooks().toArray();
      }
      return new Object[] {};
   }
 
   // ...
}
 
public class ExplorerLabelProvider extends LabelProvider {
   public Image getImage(Object element) {
      if (element instanceof Book) {
         return RcpDemoPlugin.getDefault().getImageRegistry().get(BOOK_ICON);
      }
      return super.getImage(element);
   }
 
   public String getText(Object element) {
      if (element instanceof Book) {
         return Book.class.cast(element).getTitle();
      }
      return super.getText(element);
   }
}

Het demo perspectief zal voorlopig alleen de Explorer view bevatten. Implementeer de klasse com.finalist.rcp.internal.perspectives.DemoPersective als volgt:

public class DemoPerspective implements IPerspectiveFactory {
   public static final String PERSPECTIVE_ID = "com.finalist.rcp.perspectives.demo";
 
   public void createInitialLayout(IPageLayout layout) {
      layout.addView(Explorer.VIEW_ID, IPageLayout.LEFT, 0.3f, IPageLayout.ID_EDITOR_AREA);
   }
}

De view en het perspectief zullen ook nog aan de plug-in definitie toegevoegd moeten worden. Dat doe je door terug te gaan naar de manifest editor en het tabblad Extensions te openen. Voeg beide definities toe zoals beschreven in afbeelding 2.

Afbeelding 2: De extensie definities

Test de plug-in
Je plug-in kan nu getest worden. In Eclipse kan dit heel makkelijk door de manifest editor te openen op het tabblad Overview en in de rechter kolom op de Launch an Eclipse application te klikken. Eclipse zal nu nog een keer gestart worden, maar wel met alle plug-ins in je workspace geactiveerd. Je zal zien dat de view en het perspectief terug te vinden in het Window menu.

Afbeelding 3: Eclipse met het demo perspectief geactiveerd

De product definitie
Het is natuurlijk niet de bedoeling dat de klant Eclipse op zijn computer moet installeren alleen om je applicatie te draaien. We gaan daarom een eigen applicatie maken om de plug-in in te draaien. De applicatie wordt geïmplementeerd in de klasse com.finalist.rcp.internal.product.DemoApplication:

public class DemoApplication implements IApplication {
   public Object start(IApplicationContext context) throws Exception {
      Display display = PlatformUI.createDisplay();
      try {
         WorkbenchAdvisor advisor = new DemoWorkbenchAdvisor();
         return PlatformUI.createAndRunWorkbench(display, advisor) == PlatformUI.RETURN_RESTART
               ? IApplication.EXIT_RESTART
               : IApplication.EXIT_OK;
      } finally {
         display.dispose();
      }
   }
 
   public void stop() {
      final IWorkbench workbench = PlatformUI.getWorkbench();
      if (workbench != null) {
         final Display display = workbench.getDisplay();
         display.syncExec(new Runnable() {
            public void run() {
               if (!display.isDisposed()) workbench.close();
            }
         });
      }
   }
}

In de DemoWorkbenchAdvisor kan je de Eclipse workbench naar eigen wens configureren. Hierbij moet je bijvoorbeeld denken aan de knoppen in de menu’s en het standaard perspectief. Deze code is vrij triviaal, daarom verwijs ik naar de broncode* (zie opmerking onderaan) en de API documentatie.

De applicatie moet ook aan de manifest worden toegevoegd. Open de manifest editor en ga naar het tabblad plugin.xml. Copy-paste de volgende XML om de applicatie toe te definiëren. Dit is in feite een shortcut voor het gebruik van de Extension editor die we gebruikt hebben om de view en het perspectief te definiëren.

   <extension id="application" point="org.eclipse.core.runtime.applications">
      <application>
         <run class="com.finalist.rcp.internal.product.DemoApplication" />
      </application>
   </extension>
   <extension id="product" point="org.eclipse.core.runtime.products">
      <product application="com.finalist.rcp.application" name="RCP Demo">
         <property name="appName" value="RCP Demo" />
      </product>
   </extension>

Als laatste maken we de product definitie. Hierin kan je bijvoorbeeld de naam van de executable definieren of een splash screen maken. Je maakt de product definitie door met de rechtermuisknop op het project te klikken en een nieuwe Product Configuration te selecteren. Kies voor Create a configuration file with basic settings en noem hem demo. Vul de editor naar het voorbeeld in afbeelding 4.

Afbeelding 4: De product definitie

Vervolgens open je het tweede tabblad Configuration en voeg je de com.finalist.rcp plug-in toe. Hierna kan je op Add required Plug-ins klikken om automatisch alle afhankelijkheden toe te voegen. Als laatste moet op het derde tabblad Launching de launcher naam ingevuld worden; kies demo. De demo applicatie is nu gereed!

Je kan de applicatie nu starten, bijvoorbeeld via de link op het tabblad Overview. Ook vind je hier de optie om een distributie van het product te maken.

Conclusie
Eclipse RCP is erg krachtig. Het platform is vooral bekend van Eclipse zelf natuurlijk, maar wordt in veel meer open source en commerciële producten gebruikt. Dankzij het uitgebreide framework hoef je maar een minimale hoeveelheid code te schrijven om een rich client te bouwen. Ter indicatie: de broncode van de demo applicatie is in minder dan twee uur geschreven. Heel veel concepten zoals model viewers, formulier geörienteerde editors en wizards zitten als abstract concept in het framework. Je kan je als programmeur volledig concentreren op de inhoud van de applicatie.

In deel twee zal ik een formulier geörienteerde editor toevoegen om de boeken in te bewerken. Deze editor zal qua functionaliteit vergelijkbaar zijn met de manifest en product editor die we gebruikt hebben om de demo applicatie te maken.

* De broncode
De broncode van de demo applicatie is hier te downloaden. De interface van Eclipse maakt gebruik van de Standard Widget Toolkit (SWT) dat deels platform afhankelijk is. De product configuratie (demo.product) in de download is geconfigureerd voor Mac OSX. Als je gebruik maakt van een ander operating system moet je alle plug-ins behalve com.finalist.rcp verwijderen en vervolgens op Add Required Plug-ins klikken.

—————————————————————————————
Meer weten over Java-specialist Finalist IT Group?