OSGi et les Components

Les services

Définition

De manière générale, un service est un travail réalisé par un fournisseur pour le compte d'un consommateur en respectant un contrat.

Dans le cas d'OSGi, le contrat est une interface, le fournisseur sera une implémentation de cette interface, et le consomateur sera la classe qui utilisera l'implémentation par le biais de l'interface.

Le but des services en OSGi est d'avoir un couplage faible entre fournisseurs et consommateurs. Les fournisseurs peuvent ainsi être plus facilement réutilisé auprès d'autres consommateur. Les consommateurs, ne dépendant que du contrat, peuvent changer de fournisseur plus facilement. Et avec OSGi, ce changement peut s'effectuer pendant l'exécution !

Les services en OSGi constituent un mécanisme d'injection de dépendance.

Fonctionnement

Les services fonctionne celon le principe de "publish-find-bind":

1. Un bundle fournisseur va publier un service auprès du registre de service, en signalant le contrat qu'il remplis. Le registre de service va créer et maintenir une référence pour ce service.
2. Un bundle consomateur va rechercher la référence d'un service fournissant un contrat donné.
3. Le registre de service va retourner (ou non) la références d'un fournisseur, que le consommateur va récupérer.

Création

Le contrat

Avant de créer un service il faut d'abord créer un contrat. En générale, il vaut mieux créer un bundle à part, qui contiendra uniquement le contrat. Dans le manifest du bundle, il faut également exporter le contrat, pour qu'il puisse être implémenté et utilisé par d'autres bundles.

Le fournisseur

Une fois le contrat créé, un autre bundle pourra fournir une implémentation. Ce bundle va :

1. Déclarer sa dépendance envers le contrat à l'aide de son manifest et de "Import-Package".
2. Avoir une classe qui implémente le contrat
3. Publier le service auprès du registre de service

Utilisation

Pour utiliser un service, il suffit de :

1. Importer le contrat
2. Rechercher la référence d'un service
3. Récupérer le service

Les limites

Bine qu'il paraisse simple, le mécanisme des service peut devenir beaucoup plus complexe lorsqu'il est utilisé de manière avancée.

En effet, il faut se poser la question de comment notre programme doit fonctionner lorsqu'un service n'apparâit pas au moment voulu. De ce fait il faut surveiller l'apparition. Il est également possible qu'un service disparaisse entre le moment ou on sait qu'il est là et le moment ou on l'utilise, même si les deux lignes de codes sont consécutives, car l'environement OSGi est un "multi-threaded" (au moins une thread par BundleActivator).

Ces limites peuvent être palier par l'utilisation de ServiceListener et de ServiceTracker, cependant, la simplicité du code est gravement impacté.

Mais depuis la R4 de la spécification d'OSGi, une solution beaucoup plus pratique est mise en place : les Components