Include Page |
---|
| apache-felix-ipojo-header |
---|
| apache-felix-ipojo-header |
---|
|
HTML |
---|
<div class="content">
|
Configuration Handler
The configuration handler aims to manage component configurationThis page presents how to configure component instances. This is managed by the configuration handler. This handler allows the configuration and dynamic reconfiguration of instances. A configuration is basically a set of couple (name, value). The name can be a field name or a property name associated to a field or/and a method. iPOJO also supports complex properties composed by maps, dictionaries, lists and arrays.
...
Configurable Properties
To support configuration, the component type needs to declare which properties are configurable. These properties are not necessarily service property properties but can be internal component propertyproperties.
Examples
The following code depicts a simple configurable component. The 'm_foo' field will be injected using the 'foo' property, and will also be exposed as a service property. The updateArray
method is a 'setter' method where the 'array' property will be injected. Properties injected into field are available in the constructor, setter method are available only after the constructor.
Code Block |
---|
@Component
@Provides
public class MyComponent implements MyService {
@Property(name="foo")
@ServiceProperty
private String m_foo;
@Property(name="array")
public void updateArray(String[] array) {
//...
}
}
|
The previous component can also be described using XML:
Code Block |
---|
|
<component classname="...MyComponent
<iPOJO>
<Component className="fr.imag.adele.escoffier.hello.impl.HelloServiceImpl">
<Provides><provides>
<Property<property name="foo" field="m_foo"/>
</Provides>provides>
<Properties<properties configurablepropagation="false"/>
<Property name="foo" field="m_foo"/>
<Property name="array" method="updateArray"/>
<Properties name="hello.language" type="java.lang.String"/>
</Properties>properties>
</Component>
component>
|
The instance contains the configuration:
Code Block |
---|
|
<instance component="fr.imag.adele.escoffier.hello.impl.HelloServiceImpl" name="HelloService".MyComponent">
<property name="foo" value="bar"/>
<property name="array" value="\{1, 2, 3}"/>
<property name="hello.language" value="en"/>
</instanceinstance>
</iPOJO>
|
In the previous snippet, you can see three configurable properties. The first is a configurable property attached to the field 'foo' that is a service property too. The second is an array property attached to a method (updatArray). The third property is a static property, in the sense that neither field nor method is attached to this property. These three properties are configured by the instance configuration.
By setting the attribute configurable propagation to "true", you allow the property propagation to the service registration. It means that at each time that that the configuration of the instance is updated, ; all property properties contained in the configuration is propagate are propagated to the service registrations. For example, in the previous example, not only foo
will be published but array
and hello.lanaguage too.allows the exposition of the ManagedService service. Therefore, when a new configuration is pushed, the published service properties changes too. are also published. To enable propagation use:
Code Block |
---|
@Component(propagation=true)
|
If a property has a method, this method in invoke is invoked each time that the proeprty property value changes (the method is called to push the initial value just after the constructor). The method receive receives one argument of the type of the property (int an integer array int the example).
Dynamic Reconfiguration
in the example).
When an instance is reconfigured, an updated callback can also be called:
Code Block |
---|
@Updated
public void updated() {
// The instance was reconfigured
}
// OR
@Updated
public void updated(Dictionary conf) {
// The instance was reconfigured, conf is the new configuration.
}
|
Exposing a Managed Service
The ManagedService is a service specified in the OSGi Compendium. It allows reconfiguring an instance with the Configuration Admin. There is two way for an iPOJO instance to expose a Managed Service.
- In the
@Component
annotation the managedservice
attribute defines the managed service PID. In XML this is done using the pid
attribute in the properties element (XML) - In the instance configuration by configuring the
managed.service.pid
property
So, using annotation, you should use the managedservice
attribute as follow:
Code Block |
---|
@Component(managedservice="my.pid")
public class MyComponent {
}
|
In XML, the pid
attribute of the properties
element does the same job.
Code Block |
---|
|
<component classname="...MyComponent">
<!-- ... -->
<properties pid="my.pid"/>
<!-- ... -->
</properties>
</component>
|
Finally, instance may configure the managed service using the managed.service.pid
configuration property:
Code Block |
---|
<instance component="...MyComponent">
<property name="managed.service.pid" value="my.pid.2"/>
</instance>
|
Info |
---|
title | Type vs. Instance configuration |
---|
|
If the managed service pid is specified both in the component type and in the instance configuration, the instance configuration is used. |
The managed service pid is the identifier used by the Configuration Admin to attach configuration to Managed Services. First this pid must be unique (as any pid in OSGi). Moreover, this pid cannot be the same one that the pid used in the Managed Service Factory to create the instance (if you use this way to create your instance).
When an instance is reconfigured with the Managed Service, the configuration is propagated if the propagation is enabled.
Dynamic Reconfiguration using Factories or ManagedServiceFactories
iPOJO instances support dynamic The handler supports reconfiguration. To reconfigure an instance you can use both iPOJO Factory
and the ManagedServiceFactory
services exposed by the factory of the targetted targeted instance. By calling the method reconfigure or update (according of the service do you use), the handler receive the new configuratino configuration and apply it. If the propagation is activated, the service registratinos registrations are updated too. If there is an updated
callback, the callback is invoked.
Being notified when a reconfiguration is completed
Sometimes you need to be notified when a reconfiguration is done (all setter method called). This can be done thanks to the updated
attribute. This attribute specifies a method claeed when a configuration/reconfiguration is completed. This method receives a Dictionary
containing the properties (pair <key,value>). Properties with no value are not in the received configuration.
Updated callback are declared as follow using annotations:
Code Block |
---|
@Updated
public void updated() {
// The instance was reconfigured
}
// OR
@Updated
public void updated(Dictionary conf) {
// The instance was reconfigured, conf is the new configuration.
}
In XML, the method name is given as an attribute of the {{properties}} element.
{code:xml}
<component className="...MyComponent">
<!-- ... -->
<properties updated="updated"/>
<!-- ... -->
</properties>
</Component>
|
The callback is called AFTER the successful application of the reconfiguration.
Include Page |
---|
| apache-felix-ipojo-footer |
---|
| apache-felix-ipojo-footer |
---|
|