THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
...
| Code Block |
|---|
@Component(factorySet="MyComponentFactory", factoryConfigure="configure")
class X implements Z {
void configure(Dictionary conf) {
// Configure or reconfigure our component. The conf is provided by the factory,
// and all public properties (which don't start with a dot) are propagated with the
// Service properties eventually specified in the properties annotation attribute.
}
@ServiceDependency
void bindOtherService(OtherService other) {
// store this require dependency
}
@Start
void start() {
// Our component is starting and is about to be registered in the OSGi registry as a Z service.
}
public void doService() {
// ... part of Z interface
}
}
/**
* This class will instantiate some X component instances
*/
@Component
class Y {
@ServiceDependency(filter="(dm.factory.name=MyComponentFactory)")
Set<Dictionary> _XFactory; // This Set acts as a Factory API for creating X component instances.
@Start
void start() {
// Instantiate a X component instance
Dictionary x1 = new Hashtable() {{ put("foo", "bar1"); }};
_XFactory.add(x1);
// Instantiate another X component instance
Dictionary x2 = new Hashtable() {{ put("foo", "bar2"); }};
_XFactory.add(x2);
// Update the first X component instance
x1.put("foo", "bar1_modified");
_XFactory.add(x1);
// Destroy all components (Notice that invoking _XFactory.clear() also destroys every X instances)
_XFactory.remove(x1);
_XFactory.remove(x2);
}
}
|
@AspectService
Aspects allow you to define an interceptor, or chain of interceptors for a service (to add features like caching or logging, etc ...). The dependency manager intercepts the original service, and allows you to execute some code before invoking the original service ... The aspect will be applied to any service that matches the specified interface and filter and will be registered with the same interface and properties as the original service, plus any extra properties you supply here. It will also inherit all dependencies, and if you declare the original service as a member it will be injected.
Annotation attributes:
- ranking: Sets the ranking of this aspect. Since aspects are chained, the ranking defines the order in which they are chained. Chain ranking is implemented as a service ranking so service lookups automatically retrieve the top of the chain.
- service: Sets the service interface to apply the aspect to. By default, the directly implemented interface is used.
- filter: Sets the filter condition to use with the service interface this aspect is applying to.
- properties: Sets Additional properties to use with the aspect service registration.
- field: Sets the field name where to inject the original service. By default, the original service is injected in any attributes in the aspect implementation that are of the same type as the aspect interface.
- factoryMethod: Sets the static method used to create the AspectService implementation instance. The default constructor of the annotated class is used. The factoryMethod can be used to provide a specific aspect implements, like a DynamicProxy.
Usage example:
| Code Block |
|---|
@AspectService(ranking=10), properties={@Property(name="param", value="value")})
class AspectService implements InterceptedService {
// The service we are intercepting (injected by reflection)
protected InterceptedService intercepted;
public void doWork() {
intercepted.doWork();
}
}
|
@AdapterService
@BundleAdapterService
...