Skip to main content
Jump to: navigation, search

Difference between revisions of "Riena Getting Started with Wiring"

(New page: == 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 ba...)
 
(Getting Started with Wiring)
Line 12: Line 12:
 
Wire.instance(object).andStart(context);
 
Wire.instance(object).andStart(context);
 
</source>
 
</source>
 +
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:
 +
<source lang=java>
 +
@WireWith(SSLConfigurationWiring.class)
 +
public class SSLConfiguration {
 +
 +
public void configure(ISSLProperties properties) {
 +
..
 +
}
 +
}
 +
</source>
 +
And the actual wiring is than performed by the class defined in the annotation:
 +
<source lang=java>
 +
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$
 +
}
 +
}
 +
</source>
 +
This code uses the well known <code>Inject.</code> to perform the necessary injections. As mentioned before this the most flexible approach because within the <code>wire</code> and <code>unwire</code> 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:
 +
<source lang=java>
 +
public class SSLConfiguration {
 +
 +
@InjectExtension(id = "org.eclipse.riena.communication.core.ssl", min = 0, max = 1)
 +
public void configure(ISSLProperties properties) {
 +
..
 +
}
 +
}
 +
</source>
 +
Oops, that´s all? Yes, it is. But as mentioned before less flexible but much more convenient.

Revision as of 05:54, 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.

Copyright © Eclipse Foundation, Inc. All Rights Reserved.