Difference between revisions of "Riena Getting Started with Wiring"

Revision as of 06:02, 30 April 2009

Getting Started with Wiring

Before you continue reading this please read Riena Getting Started with injecting services and extensions.

Use case

Within an Eclipse RCP based applications components often start their life cycle because they were contributed as an executable extension org.eclipse.core.runtime.IConfigurationElement.createExecutableExtension(String).

Who or what is responsible for injecting the needed services and/or extensions into these objects? And how does it know what to inject?

Wiring

The answer to this question is Wiring. With the following sentence it is possible to initiate the wiring, i.e. perform all the necessary injections of services and extensions.

Wire.instance(object).andStart(context);

Well, that looks really easy, but grübel grübel how does that work?

Wiring supports two options for telling what should be done.

Wiring through a dedicated class

This option is the most flexible but also the least convenient way. The class that needs services or extensions injected has to specify with an annotation another class which is responsible for the wiring. The target class looks like that:

@WireWith(SSLConfigurationWiring.class)
public class SSLConfiguration {
 
	public void configure(ISSLProperties properties) {
	..
	}
}

And the actual wiring is than performed by the class defined in the annotation:

public class SSLConfigurationWiring extends AbstractWiring {
	private ExtensionInjector sslInjector;
 
	@Override
	public void unwire(Object bean, BundleContext context) {
		sslInjector.stop();
	}
 
	@Override
	public void wire(Object bean, BundleContext context) {
		sslInjector = Inject.extension("org.eclipse.riena.communication.core.ssl").expectingMinMax(0, 1).into(bean).update(
				"configure").andStart(context); //$NON-NLS-1$
	}
}

This code uses the well known Inject. to perform the necessary injections. As mentioned before this the most flexible approach because within the wire and unwire methods you can do anything you like.

Since this seldom required there is another approach.

Wiring through annotations

The same wiring could be done with:

public class SSLConfiguration {
 
	@InjectExtension(id = "org.eclipse.riena.communication.core.ssl", min = 0, max = 1)
	public void configure(ISSLProperties properties) {
	..
	}
}

Oops, that´s all? Yes, it is. But as mentioned before less flexible but much more convenient. However, under the hood it will do exactly the same as shown in the less convenient approach.

Back to our use case

Executable extensions that get delivered by Riena´s extension injector will automatically be wired.

Conclusion