In this tutorial we will create two plug-ins. The first one defines an extension point and the second one will contribute extensions.

You can include these plug-ins in your Eclipse application or you could even use them in the Eclipse IDE.

Create a new plug-in project called de.vogella.extensionpoint.definition. This example will not make contribution to the UI, select this option in the wizard. Also select "No" for the Would you like to create a rich client application? option. The option to create an Activator should be selected.

Open the MANIFEST.MF file and the Extension Points tab. Press the Add button.

On the following dialog enter "de.vogella.extensionpoint.definition.greeter" as ID and "Greeter" as name. The Extension Point Schema field will be automatically populated based on your input.

Press Finish. The definition of the extension is generated and the schema editor opens. Switch to the Definition Tab.

We want to add attributes to the extension point. Click on the New Element button. Give the new element the name "client".

Select the "client" element and press New Attribute. Give the new element the name "class" and the type "java". Enter de.vogella.extensionpoint.definition.IGreeter as interface name

This interface is not yet defined. Press on the hyperlink called Implements to create it.

package de.vogella.extensionpoint.definition;

public interface IGreeter {
  void greet();
} 

Go back to your extension point definition and add a choice to the extension point. This defines how often the extension "client" can be provided by contributing plug-ins. We will set no restrictions (unbound).

Select the MANIFEST.MF file switch to the Runtime tab and export the package which contains the IGreeter interface.

The plug-in which defines an extension point is typically also responsible for reading and using the provided extensions. It is up to you where in your coding you do this. The following shows the method for the evaluation. In Eclipse 4 the IExtensionRegistry can get injected via dependency injection .

We are using the ISafeRunnable interface. This interface protects the plug-in which defines the extension point from malfunction extensions. If an extension throws an Exception, it will be caught by ISafeRunnable and the remaining extensions will still get executed.

package de.vogella.extensionpoint.definition.handlers;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.di.annotations.Execute;

import de.vogella.extensionpoint.definition.IGreeter;

public class EvaluateContributionsHandler {
  private static final String IGREETER_ID = 
      "de.vogella.extensionpoint.definition.greeter";
  @Execute
  public void execute(IExtensionRegistry registry) {
    evaluate(registry);
  }
  
  private void evaluate(IExtensionRegistry registry) {
    IConfigurationElement[] config =
        registry.getConfigurationElementsFor(IGREETER_ID);
    try {
      for (IConfigurationElement e : config) {
        System.out.println("Evaluating extension");
        final Object o =
            e.createExecutableExtension("class");
        if (o instanceof IGreeter) {
          executeExtension(o);
        }
      }
    } catch (CoreException ex) {
      System.out.println(ex.getMessage());
    }
  }

  private void executeExtension(final Object o) {
    ISafeRunnable runnable = new ISafeRunnable() {
      @Override
      public void handleException(Throwable e) {
        System.out.println("Exception in client");
      }

      @Override
      public void run() throws Exception {
        ((IGreeter) o).greet();
      }
    };
    SafeRunner.run(runnable);
  }
} 

Review the .exsd schema file and the reference to this file in the plugin.xml file.

Run your application. It should write "Starting" to the console. Your extension point is implemented. Other plug-ins can now contribute extensions.

Create a new headless plug-in. This plug-in should be called de.vogella.extensionpoint.contribution. It should not be an RCP application. Do not use a template to create it.

Select the MANIFEST.MF file and the Dependencies tab. Add the de.vogella.extensionpoint.definition and org.eclipse.core.runtime plug-ins as a dependency. Make sure your plug-in has the singleton flag set.

Switch to the Extensions tab and select Add. Select your own extension point and press the Finish button.

Add a client to your extension point.

Create the GreeterGerman class with the following coding.

package de.vogella.extensionpoint.contribution;

import de.vogella.extensionpoint.definition.IGreeter;

public class GreeterGerman implements IGreeter {

  @Override
  public void greet() {
    System.out.println("Moin Jungs!");
  }
} 

Include these plug-ins into your Eclipse application. If you run this application you can trigger the evaluation for the extension points. This should print the text provided by the contributing plug-ins to the console.

Source Code of Examples

OSGi Tutorial Angelo Zerr describes how to use Extension points without OSGi

vogella Training Android and Eclipse Training from the vogella team

Android Tutorial Introduction to Android Programming

GWT Tutorial Program in Java and compile to JavaScript and HTML

Eclipse RCP Tutorial Create native applications in Java

JUnit Tutorial Test your application

Git Tutorial Put everything you have under distributed version control system