Vous êtes sur la page 1sur 20

Programmation par composant

avec la technologie OSGi (Partie 1)

Par Thierry Templier (co-auteur du livre Spring par la pratique)

Date de publication : 10 janvier 2008

Dernire mise jour : 1 fvrier 2008

Cette srie d'articles dcrit la mise en oeuvre de la programmation oriente composant et


d'architectures orientes service en se fondant sur la technologie OSGi. Nous y dtaillerons
les diffrents concepts de cette technologie afin de permettre sa prise en main.

Un grand merci Jrme Benois, Hikage, Baptiste Wicht, djo.mos, keulkeul, azerr et
woodwai pour leurs relectures techniques de l'article ainsi qu' elitost pour ses corrections
quant l'orthographe.
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

1 - Introduction.............................................................................................................................................................3
2 - Programmation oriente composant et architecture oriente service avec OSGi................................................. 4
3 - Architecture OSGi.................................................................................................................................................. 6
3.1 - Gestion des composants OSGi..................................................................................................................... 6
3.2 - Cycle de vie des bundles..............................................................................................................................7
3.3 - Services......................................................................................................................................................... 9
3.4 - Conclusion..................................................................................................................................................... 9
4 - Bundle OSGi........................................................................................................................................................ 10
4.1 - Caractristiques d'un bundle....................................................................................................................... 10
4.2 - en-ttes OSGi du fichier MANIFEST.MF.....................................................................................................10
5 - Interactions entre bundles....................................................................................................................................12
5.1 - Mise disposition de packages.................................................................................................................. 12
5.2 - Importation de packages............................................................................................................................. 13
6 - Principales API OSGi...........................................................................................................................................14
6.1 - BundleActivator - Entit d'activation............................................................................................................ 14
6.2 - BundleContext - Contexte de composant................................................................................................... 15
7 - Mise en oeuvre de services................................................................................................................................ 18
8 - Conclusion............................................................................................................................................................19
9 - Bibliographie.........................................................................................................................................................20

-2-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

1 - Introduction

Ce premier article a pour objectif de fournir une introduction la technologie OSGi (Open Service Gateway Initiative),
technologie qui aprs avoir t longtemps utilise dans le monde de l'embarqu est de plus en plus mise en oeuvre
dans les applications classiques et serveurs.

Nous verrons dans un premier temps les diffrents concepts relatifs OSGi et dtaillerons quelles problmatiques
cette technologie s'adresse tout en soulignant ses apports en terme d'architecture et de structuration des applications.

Nous rentrerons par la suite dans les aspects techniques d'OSGi afin de dtailler ses caractristiques et de voir
concrtement comment mettre en oeuvre cette technologie au sein d'applications Java. Nous laisserons le soin
un prochain article de dcrire la manire d'utiliser OSGi dans des applications Java EE tout en se fondant sur des
bibliothques et frameworks Java EE.

-3-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

2 - Programmation oriente composant et architecture oriente service avec OSGi

Avant d'entrer dans le coeur de la technologie, nous allons dtailler les caractristiques de la programmation oriente
composant et des architectures oriente service afin d'identifier les problmatiques qu'elles visent rsoudre. Nous
verrons alors que la technologie OSGi adresse ces deux types de technologies.

Tout d'abord, la programmation oriente composant [1] vise adresser les limitations de la programmation oriente
objet [2]. Cette dernire offre d'intressants mcanismes afin de modulariser les traitements et les rendre rutilisables
mais n'apporte aucun support afin de mettre en relation les classes. De plus, plus les traitements de l'application
augmentent et se complexifient, plus ces limitations sont visibles et pnalisantes au niveau de la maintenabilit et
de l'volutivit de l'application.

Ainsi, cet aspect peut devenir trs problmatique lors de la mise en oeuvre de rseaux complexes d'objets. En effet,
cela se traduit trs souvent par des couplages forts entre objets, ce point nuisant normment la rutilisabilit des
traitements. Chaque dveloppeur a alors le choix des outils afin d'adresser au mieux au sein de ses applications ces
aspects. L'approche la plus adapte consiste en la mise en oeuvre du patron de conception injection de dpendance
par l'intermdiaire de frameworks tels que Spring [3] utiliss conjointement avec la programmation par interface.

Nous retrouvons ce problme notamment au niveau des instanciations des objets, directement ou par l'intermdiaire
de l'introspection. En effet, mme avec la programmation par interface, la classe appelante est lie la classe
appele. Les patrons de conception tels que les fabriques [4] et l'injection de dpendance [5] permettent d'adresser
cette problmatique en dlguant les traitements d'instanciation une entit autonome (respectivement la fabrique
et le conteneur).

En parallle de la programmation oriente composant, les architectures orientes service peuvent tre mises en
oeuvre afin de mettre disposition des traitements tout en diminuant les couplages entre les briques techniques.
La SOA (Service Oriented Architecture) [6] n'implique pas ncessairement l'utilisation des services Web avec les
technologies SOAP [7] et WSDL [8] et peut tre mise en oeuvre au sein d'un mme processus Java notamment
avec des conteneurs lgers (entits mettant en oeuvre l'injection de dpendances) tels que Spring[3] ou Hivemind
[9]. Dans ce contexte, nous parlons de fournisseur de services et de consommateurs de services, les fournisseurs
mettant disposition des composants. La programmation oriente composant [1] et les architectures orientes
service peuvent donc tre mises en oeuvre de manire complmentaire afin de bnficier des avantages des deux
types de technologies.

La figure suivante illustre diffrents composants exposant des services par l'intermdiaire d'interfaces et relis entre
eux par des services:

-4-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

Il est noter que des composants OSGi peuvent tre galement relis entre eux par l'intermdiaire des packages,
packages qu'ils exportent et importent. Dans ce cas, les services ne sont donc pas l'unique manire de les relier.

Dans ce contexte, la technologie OSGi vise adresser les diffrentes problmatiques vues prcdemment,
problmatiques rcapitules ci-dessous:

Adresser les limitations de la programmation oriente objet;


Permettre la gestion des applications complexes et de taille importante;
Amliorer la qualit de service des applications en permettant une administration chaud;
Permettre la mise en oeuvre d'architectures orientes service lgres.

Une des autres caractristiques de la technologie OSGi est sa portabilit puisqu'elle peut tre mise en oeuvre aussi
bien dans des terminaux de manire embarque que dans des applications classiques ou serveurs. Le premier aspect
a t la base d'OSGi, les seconds types d'application s'tant dvelopps ces dernires annes par l'intermdiaire
d'outils tels qu'Eclipse [10]. Le fait qu'OSGi repose sur la technologie Java pour son excution a t galement un
important facteur de portabilit.

-5-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

3 - Architecture OSGi

Dans cette section, nous allons dcrire les caractristiques des conteneurs et composants OSGi. Le composant
correspond l'entit centrale de la technologie et dsigne par le terme bundle avec la terminologie de cette dernire.
Nous verrons galement les spcificits du cycle de vie des bundles, la manire de les grer au niveau du conteneur
ainsi que la faon de les configurer par l'intermdiaire de leur descripteur de dploiement.

La figure suivante dcrit les diffrentes briques de l'architecture de la technologie OSGi, briques que nous allons
dtailles conceptuellement tout au long de cette section puis techniquement dans le reste de l'article:

La couche Module adresse la gestion des bundles, aussi bien au niveau du chargement des classes (classloading)
que de la gestion de leurs visibilits et de leurs versions. La couche Cycle de vie (life cycle) prend quant elle en
charge les tats des bundles supports par le conteneur ainsi que les API correspondantes. Pour finir, la couche
Services offre la possibilit de mettre disposition des services au sein d'une mme machine virtuelle tout en
masquant leurs implmentations leurs utilisateurs. Les applications OSGi peuvent se fonder et tirer parti de ces
diffrentes couches afin de mettre en oeuvre des composants et des services.

3.1 - Gestion des composants OSGi

La couche module permet la mise en oeuvre des bundles dans le conteneur. Elle a la responsabilit de la gestion
des diffrents chargeurs de classes et des versions des dpendances.

En effet, une des caractristiques de la technologie consiste en l'isolation des classloaders des composants. En
effet, chaque composant ou bundle OSGi dispose d'un classloader indpendant pour ses traitements. Cet aspect
permet par exemple la mise en oeuvre dans deux bundles diffrents d'une mme bibliothque avec deux versions
diffrentes et incompatibles.

Cet aspect offre la possibilit OSGi de compltement matriser les classes et packages du composant visibles
depuis l'extrieur et visibles par les autres composants. Par dfaut, la stratgie est la plus restrictive possible,
savoir que rien n'est visible. Par contre, lors de la mise disposition d'un package d'un composant, un numro de
version spcifique peut tre spcifi. Ainsi, deux versions de packages peuvent coexister dans le conteneur OSGi
sans aucun problme.

-6-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

3.2 - Cycle de vie des bundles

Comme dans tout conteneur, les lments contenus dans ce dernier possdent un cycle de vie bien particulier puisque
le conteneur OSGi a la responsabilit de les grer. Nous pouvons distinguer deux grandes parties dans les diffrents
tats supports:

Non oprationnel. Les tats correspondent la prsence du bundle dans le conteneur, mais ce dernier n'est
pas utilisable par les autres bundles pour leurs traitements;
Oprationnel. Les tats de ce type correspondent aux moments o le bundle est utilisable ou en phase de
l'tre ou de ne plus l'tre.

La figure suivante illustre les diffrents tats de gestion des bundles par le conteneur ainsi que leurs enchanements
possibles:

Nous verrons par la suite que le conteneur OSGi offre une API standardise afin de grer le cycle de vie des
composants. Veuillez vous reporter la section 5.2 BundleContext pour plus de prcisions. De plus, ces diffrents
tats sont mis en oeuvre par le bundle manager du conteneur qui a la responsabilit de grer la plateforme.

Le tableau suivant rcapitule les diffrents tats supports par le bundle manager des conteneurs OSGi ainsi que
leurs principales caractristiques:

Etat Descriptif
Install (installed) Etat dans lequel se trouve un bundle juste
aprs avoir t install, la rsolution des
dpendances n'ayant pas encore t
ralise.
Rsolu (resolved) Etat dans lequel se trouve un bundle
aprs avoir t install, la rsolution des
dpendances ayant juste t ralise.
En train de dmarrer (starting) Etat dans lequel se trouve un bundle
lorsqu'il est en train d'tre dmarr. Cet tat

-7-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

correspond un tat transitoire entre les


vnements Rsolu et Actif.
Actif (active) Etat dans lequel se trouve un bundle lorsqu'il
a t dmarr avec succs. Le bundle
ainsi que les services qu'il expose sont
disponibles pour les autres bundles.
En train de s'arrter (stopping) Etat dans lequel se trouve un bundle lorsqu'il
est en train d'tre arrt. Cet tat correspond
un tat transitoire entre les vnements
Actif et Rsolu.
Dsinstall (uninstalled) Etat dans lequel se trouve un bundle une fois
qu'il a t dsinstall.

Nous pouvons noter qu'une entit peut tre associe au cycle de vie des bundles et correspond l'entit d'activation,
entit appele lors du dmarrage et de l'arrt d'un bundle. Cette entit peut tre mise en oeuvre par l'intermdiaire
de l'interface BundleActivator et configure avec l'en-tte Bundle-Activtator. Nous reviendrons plus en dtail sur ce
mcanisme dans la section 5.1 BundleActivator.

Nous pouvons noter que la plupart des conteneurs OSGi fournissent des outils afin de grer le cycle de vie des
bundles et de visualiser leurs tats. Dans cette optique, le conteneur OSGi
Felix [11] offre une console d'administration en ligne de commande possdant les commandes suivantes:

Commande Descriptif
install Installation de bundle(s).
ps Affichage de la liste des bundles installs.
refresh Rafraichissment des packages des bundles.
resolve Tentative de rsolution des bundles
spcifis.
services Affichage de la liste des services enregistrs
ou utiliss.
start Dmarrage de bundle(s).
stop Arrt de bundle(s).
uninstall Dsinstallation de bundle(s).
update Mise jour d'un bundle.

Avec la console de cet outil, le conteneur peut tre compltement administr chaud en ligne de commandes. Le
scnario suivant peut tre mis en oeuvre afin d'installer un bundle, de le dmarrer, puis l'arrter avec les commandes
respectives install, start et stop. Le code suivant illustre concrtement l'enchanement de ces diffrentes commandes:

-> ps
START LEVEL 1
ID State Level Name
[ 0] [Active ] [ 0] System Bundle (1.0.0)
[ 1] [Active ] [ 1] Apache Felix Shell Service (1.0.0)
[ 2] [Active ] [ 1] Apache Felix Shell TUI (1.0.0)
-> install /home/templth/developpez/OSGi/simplebundle.jar
Bundle ID: 3
-> ps
START LEVEL 1
ID State Level Name
[ 0] [Active ] [ 0] System Bundle (1.0.0)
[ 1] [Active ] [ 1] Apache Felix Shell Service (1.0.0)
[ 2] [Active ] [ 1] Apache Felix Shell TUI (1.0.0)
[ 3] [Installed ] [ 1] Simple Bundle (1.0.1)
-> start 3
-> ps
START LEVEL 1
ID State Level Name
[ 0] [Active ] [ 0] System Bundle (1.0.0)
[ 1] [Active ] [ 1] Apache Felix Shell Service (1.0.0)

-8-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

[ 2] [Active ] [ 1] Apache Felix Shell TUI (1.0.0)


[ 3] [Active ] [ 1] Simple Bundle (1.0.1)
-> stop 3
-> ps
START LEVEL 1
ID State Level Name
[ 0] [Active ] [ 0] System Bundle (1.0.0)
[ 1] [Active ] [ 1] Apache Felix Shell Service (1.0.0)
[ 2] [Active ] [ 1] Apache Felix Shell TUI (1.0.0)
[ 3] [Resolved ] [ 1] Simple Bundle (1.0.1)

3.3 - Services

La couche Services offre la possibilit de mettre disposition certains traitements des composants par l'intermdiaire
de services. Nous dsignons par le terme service des traitements structurs de la manire suivante. Il s'agit d'une
entit dont le contrat est clairement dfini par l'intermdiaire d'une interface Java. Seule cette interface est connue
par les consommateurs du service. La ou les implmentations du service doivent rester internes aux composants et
implmenter la prcdente interface.

Le mcanisme de gestion des services est compltement dynamique. En effet, ds qu'un service est enregistr, il est
automatiquement utilisable par tous les composants disponibles dans le conteneur OSGi. Comme nous le verrons
par la suite, une API est disponible afin d'enregistrer des implmentations de services. De plus, par convention, il
convient de faire correspondre le nom du service au nom de l'interface implmente.

Dans le cadre de la technologie OSGi, l'architecture oriente services a la caractristique d'tre trs "lgre" et de
pouvoir fonctionner de manire autonome dans un seul processus Java. Elle correspond un modle de services
dans une unique machine virtuelle (in-VM).

Nous verrons dans la section 5.1 comment mettre en oeuvre concrtement des services dans le cadre de la
technologie OSGi.

3.4 - Conclusion

L'architecture de la technologie OSGi permet de mettre en oeuvre des composants et de mettre disposition des
services applicatifs. Elle offre galement un cycle de dploiement de services trs rapides par l'intermdiaire du cycle
de vie des bundles tout en offrant une meilleure structuration des fondations des applicatifs.

Nous pouvons remarquer que la scurit est prvue en standard puisqu'elle fait partie intgrante de la spcification
OSGi. Elle offre la possibilit de spcifier des permissions d'accs aux entits gres par le conteneur. Une de ses
principales caractristiques consiste dans le fait que sa configuration est compltement dynamique et ne ncessite
aucun redmarrage aprs une modification.

Rentrons maintenant dans le dtail technique de la technologie OSGi et voyons concrtement comment la mettre
en oeuvre.

-9-
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

4 - Bundle OSGi

Dans cette section, nous allons dtailler les diffrentes caractristiques de l'entit centrale d'OSGi, le composant ou
bundle. Nous verrons comment le mettre en oeuvre par l'intermdiaire d'un simple fichier JAR de Java.

4.1 - Caractristiques d'un bundle

Avec la technologie OSGi, le concept de composant est mis en oeuvre par l'intermdiaire des bundles, un bundle
correspondant un composant. Ces derniers permettent de mettre en oeuvre les diffrents concepts des composants
et ce sont eux qui sont dploys dans les conteneurs OSGi.

Avec OSGi, un composant (bundle) est simplement stock dans un fichier JAR de Java. Les informations de
dploiement sont spcifies par l'intermdiaire du fichier standard MANIFEST.MF prsent dans le rpertoire META-
INF. En effet, OSGi reprend ce fichier en y ajoutant diffrents en-ttes afin de configurer le composant.

Il n'est pas ncessaire d'ajouter d'autres lments au fichier JAR si ce n'est les classes bien sr et les ventuelles
bibliothques utilises, uniquement les bibliothques n'tant pas dfinies en tant que dpendances. Nous pouvons
constater que cet aspect favorise de manire importante la simplicit de mise en oeuvre de composants dans des
conteneurs de ce type. Les conteneurs OSGi sont de ce fait trs lgers. N'oublions pas qu'OSGi tait l'origine utilis
dans des systmes embarqus donc trs soucieux de la consommation mmoire.

Les conteneurs possdent diverses caractristiques quant la gestion des composants. Tout d'abord, ils ont
la particularit de permettre la gestion des dpendances entre composants. En effet, comme nous l'avons vu
prcdemment, un composant s'appuie la plupart du temps sur d'autres afin de raliser ses traitements et de
fonctionner correctement. Pour ce faire, OSGi offre la possibilit de rendre visible dans le conteneur les packages de
composants de manire trs fine. La gestion des versions des dpendances est galement supporte.

4.2 - en-ttes OSGi du fichier MANIFEST.MF

Comme nous l'avons prcis dans la prcdente section, le fichier MANIFEST.MF correspond au descripteur de
dploiement du bundle. Ce fichier est lu par le conteneur OSGi afin de configurer le bundle.

La spcification OSGi dfinit un ensemble d'en-ttes standards pour un composant, en-ttes utilisables dans le fichier
MANIFEST.MF et dont la liste des principales est rcapitule dans le tableau suivant:

En-tte Descriptif
Bundle-ManifestVersion Correspond la version de fichier
MANIFEST du bundle
Bundle-SymbolicName Spcifie l'identifiant symbolique du bundle
Bundle-Name Spcifie le nom du bundle
Bundle-Version Spcifie la version du bundle
Bundle-DocURL Permet de prciser l'adresse de la
documentation du bundle.
Bundle-Category Spcifie la catgorie du bundle.
Import-Package Spcifie les noms et les versions des
packages utiliss par le bundle.
Export-Package Spcifie les noms et les versions des
packages mis disposition par le bundle.
DynamicImport-Package Spcifie les noms et les versions des
packages utiliss par le bundle. Cet en-
tte se diffrencie de Import-Package
par le fait qu'il ne soit pas ncessaire que
les dpendances soient prsentes au

- 10 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

dmarrage du bundle. Il suffit qu'elles le


soient au moment de l'excution.
Bundle-NativeCode Spcifie la liste des bibliothques natives
prsentes dans le bundle.
Require-Bundle Spcifie les identifiants symboliques des
bundles ncessaires au bon fonctionnement
du bundle.
Bundle-Activator Spcifie le nom de la classe dont les
traitements sont excuts lors du dmarrage
et de l'arrt du bundle. Cette classe doit
tre prsente dans le bundle et implmenter
l'interface BundleActivator.
Bundle-Classpath Spcifie le classpath du bundle. Par dfaut,
la valeur implicite correspond . et il
faut veiller ne pas l'oublier lorsque des
bibliothques sont spcifies explicitement.

Le code suivant illustre la configuration d'un composant OSGi simple dans le fichier MANIFEST.MF. Ce bundle est
identifi par simple.bundle, possde le nom "Simple Bundle", exporte le package org.developpez.osgi.service et
utilise l'entit d'activation org.developpez.osgi.SimpleActivator.

Manifest-Version = 1
Bundle-Activator = org.developpez.osgi.SimpleActivator
Bundle-SymbolicName = simple-bundle
Bundle-Name = Simple Bundle
Bundle-Description = Simple Bundle.
Import-Package = org.osgi.framework;version=1.3
Export-Package = org.developpez.osgi.services
Bundle-Version = 1.0.1
Bundle-License = http://www.apache.org/licenses/LICENSE-2.0.txt

- 11 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

5 - Interactions entre bundles

Comme nous l'voquions dans la section prcdente, un conteneur OSGi offre la possibilit de grer la visibilit
des ressources en composant. Par dfaut, un composant est compltement opaque depuis l'extrieur et rien n'est
accessible. Cet aspect implique de prciser toutes les dpendances utilises par un composant et tous les packages
mis disposition.

La spcification OSGi offre la possibilit de jouer sur cet aspect par l'intermdiaire d'en-ttes dans le fichier
MANIFEST.MF, fichier contenant les donnes relatives au dploiement et dcrit dans la prcdente section.
Dtaillons maintenant les spcificits de ces en-ttes et la manire de les mettre en oeuvre.

Notons qu'il existe une manire complmentaire de faire interagir les bundles entre eux par l'intermdiaire des
services. Nous dcrirons cet aspect dans une prochaine section.

5.1 - Mise disposition de packages

Afin de mettre des dispositions des packages (ou exporter) d'un bundle, l'en-tte Export-Package doit tre mise
en oeuvre dans le fichier MANIFEST.MF du composant. Cet en-tte contiendra la liste des packages pour lesquels
l'accs est possible.

Il est noter que la spcification d'un package dans ce cadre autorise l'accs toutes les classes du package tout
en gardant inaccessible les classes contenues dans les sous packages du package.

Lors de l'exportation d'un package, OSGi offre la possibilit d'ajouter des informations complmentaires telles que la
version et dont la liste est rcapitule dans le tableau ci-dessous:

Paramtre Descriptif
uses Spcifie la liste des packages utiliss par le
package export.
mandatory Spcifie une liste de paramtres obligatoires
spcifier lors de l'importation du package
export.
include Spcifie une liste de packages devant tre
visibles par le bundle important le package.
exclude Spcifie une liste de packages devant tre
invisibles par le bundle important le package.
version Spcifie la version avec laquelle est mis
disposition le package.

La syntaxe complte d'une valeur pour la proprit Export-Package est donc la suivante:

Export-Package: nom-package;parametre:=valeur,nom-package;parametre:=valeur,...

Notons que, si la valeur d'un paramtre est une liste, les lments doivent tre spars par des virgules et la valeur
globale doit tre entoure par des guillemets.

Le code suivant correspond un extrait de la valeur de l'en-tte Export-Package du fichier MANIFEST.MF d'un
bundle OSGi pour Hibernate 3 [12]. Nous remarquons la prsence des paramtres uses et version pour le
packageorg.hibernate.stat.

Export-Package: org.hibernate.stat;uses:="org.hibernate.util,org.hibernate.cache,
org.apache.commons.logging,org.hibernate.engine";version=3.1.3,

- 12 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

org.hibernate.cache;uses:="org.hibernate.util,net.sf.swarmcache,
org.hibernate.cfg,org.hibernate,net.sf.ehcache,org.hibernate.impl,...

5.2 - Importation de packages

La technologie OSGi offre la possibilit de spcifier les packages utiliss afin qu'ils soient visibles dans le bundle.
Une fois spcifies, les classes sont utilisables dans les classes implmentes par le bundle. Cet aspect se configure
dans le fichier MANIFEST.MF par l'intermdiaire des en-ttes Import-Package et DynamicImport-Package. Dtaillons
tout d'abord l'usage du premier en-tte.

Lors de l'importation d'un package, OSGi offre la possibilit d'ajouter des informations complmentaires telles que la
version et le mode de rsolution dont la liste simplifie est rcapitule dans le tableau ci-dessous:

Paramtre Descriptif
resolution Spcifie le type de rsolution du package. La
valeur par dfaut est mandatory.
version Spcifie la version du package utiliser. Une
plage de versions peut tre spcifie.

La syntaxe complte d'une valeur pour la proprit Import-Package est donc la suivante:

Import-Package: nom-package;parametre:=valeur,nom-package;parametre:=valeur,...

Notons que, si la valeur d'un paramtre est une liste, les lments doivent tre spars par des virgules et la valeur
globale doit tre entoure par des guillemets.

Le code suivant correspond un extrait de la valeur de l'en-tte Import-Package du fichier MANIFEST.MF du bundle
OSGi de Spring AOP 2.0.5. Nous remarquons la prsence des paramtres resolution pour le package com.jamonapi
et version pour le package org.springframework.aop.

Import-Package: com.jamonapi;resolution:=optional,net.sf.cglib.core;resolution:=optional,
net.sf.cglib.proxy;resolution:=optional,net.sf.cglib.transform.impl;resolution:=optional,
...
org.springframework.aop;version=2.0.5,org.springframework.aop.aspectj;version=2.0.5,...

Dans le cas de l'importation de packages, l'en-tte DynamicImport-Package est galement disponible. Il se diffrencie
de la prcdente par le fait que la rsolution des dpendances spcifies ce niveau n'est ralise qu'au moment
du chargement des classes et non lors du passage du bundle de l'tat Install Rsolu.

L'en-tte fonctionne sinon de la mme manire que l'en-tte Import-Package, si ce n'est qu'il ne supporte logiquement
pas le paramtre resolution.

- 13 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

6 - Principales API OSGi

Par cette section, nous allons introduire deux interfaces des APIs de la technologie OSGi relatives respectivement
l'entit d'activation et au contexte des bundles. Elles permettent notamment d'initialiser et de finaliser les ressources
des bundles et d'interagir avec le conteneur OSGi.

L'entit relative au contexte OSGi nous sera utile dans la section relative aux services puisque cette interface met
disposition des mthodes afin de manipuler et d'avoir accs aux services prsents dans le conteneur OSGi.

6.1 - BundleActivator - Entit d'activation

La technologie OSGi offre la possibilit de spcifier une entit appele lors de l'activation (tat Dmarrage) et de
la dsactivation (tat En cours d'arrt) d'un composant, c'est--dire lorsque ce dernier est dmarr ou arrt. La
classe implmentant cette entit doit ncessairement possder l'interface BundleActivator et tre configure par
l'intermdiaire de l'en-tte Bundle-Activator dans le fichier MANIFEST.MF.

L'interface BundleActivator dfinit la structure d'une classe d'activation en dfinissant les signatures des mthodes
appeles lors des diffrents vnements prcdemment cits:

Mthode start, appele lors le dmarrage du composant (tat Dmarrage);


Mthode stop, appele quant elle lors de l'arrt du composant (tat En cours d'arrt).

Ces deux mthodes prennent en paramtre le contexte OSGi du composant par l'intermdiaire de l'interface
BundleContext, interface permettant d'interagir aussi bien avec le conteneur qu'avec le composant. Le contenu de
l'interface BundleActivator est dcrit ci-dessous:

public interface BundleActivator {


void start(BundleContext context);
void stop(BundleContext context);
}

Le code suivant illustre la mise en oeuvre d'une entit d'activation pour un bundle par l'intermdiaire d'une
implmentation simple appele ici SimpleActivator:

public class SimpleActivator implements BundleActivator {


private ServiceRegistration serviceRegistration;

public void start(BundleContext context) {


// Enregistrement d'un service
SimpleService service = new SimpleServiceImpl();
this.serviceRegistration = context.registerService(
SimpleService.class.getName(), service, null);
}

public void stop(BundleContext context) {


// Dsenregistrement d'un service
if( this.serviceRegistration!=null ) {
this.serviceRegistration.unregister();
}
}
}

Le code suivant dcrit la configuration de cette entit par l'intermdiaire de l'en-tte Bundle-Activator dans le fichier
MANIFEST.MF du bundle:

Manifest-Version = 1
Bundle-Activator = org.developpez.OSGi.SimpleActivator
Bundle-SymbolicName = simple-bundle

- 14 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

Bundle-Name = Simple Bundle


Bundle-Description = Simple Bundle.
Import-package = org.OSGi.framework;version=1.3
Bundle-Version = 1.0.1
Bundle-License = http://www.apache.org/licenses/LICENSE-2.0.txt

6.2 - BundleContext - Contexte de composant

Nous avons vu dans la prcdente section que l'entit d'activation s'appuie sur le contexte du composant. Dtaillons
maintenant les spcificits de l'interface BundleContext, interface relative au contexte du composant. Cette dernire
permet d'interagir aussi bien au niveau du conteneur OSGi lui-mme que du bundle dans lequel il est utilis. Elle
offre la possibilit de raliser les diffrentes oprations suivantes:

Opration Descriptif
Manipulation des bundles Permet de rcuprer les instances de
bundles du conteneur et d'installer de
nouvelles instances.
Manipulation des services Permet de rcuprer les instances de
services du conteneur et d'installer de
nouveaux. Nous dtaillerons cet aspect dans
la section suivante.
Observateurs Permet de spcifier et de supprimer des
observateurs diffrents niveaux.

Le contenu de l'interface BundleContext est dcrit dans le code ci-dessous:

public interface BundleContext {


void addBundleListener(BundleListener listener);
void addFrameworkListener(FrameworkListener listener);
void addServiceListener(ServiceListener listener);
void addServiceListener(ServiceListener listener,
Java.lang.String filter);
Filter createFilter(Java.lang.String filter);
ServiceReference[] getAllServiceReferences(Java.lang.String clazz,
Java.lang.String filter);
Bundle getBundle();
Bundle getBundle(long id);
Bundle[] getBundles();
Java.io.File getDataFile(Java.lang.String filename);
Java.lang.String getProperty(Java.lang.String key);
Java.lang.Object getService(ServiceReference reference);
ServiceReference getServiceReference(Java.lang.String clazz);
ServiceReference[] getServiceReferences(Java.lang.String clazz,
Java.lang.String filter);
Bundle installBundle(Java.lang.String location);
Bundle installBundle(Java.lang.String location,
Java.io.InputStream input);
ServiceRegistration registerService(Java.lang.String[] clazzes,
Java.lang.Object service,
Java.util.Dictionary properties);
ServiceRegistration registerService(Java.lang.String clazz,
Java.lang.Object service,
Java.util.Dictionary properties);
void removeBundleListener(BundleListener listener);
void removeFrameworkListener(FrameworkListener listener);
void removeServiceListener(ServiceListener listener);
boolean ungetService(ServiceReference reference);
}

Dtaillons maintenant les spcificits relatives aux bundles et aux observateurs. Cette interface offre tout d'abord
la possibilit de grer et rcuprer les instances des bundles prsents dans le conteneur. Tout d'abord, l'installation
de bundles se ralise par l'intermdiaire des mthodes installBundle, mthode prenant en paramtre le chemin du
fichier JAR du bundle. Les mthodes getBundle et getBundles retournent quant elle une ou plusieurs instances de

- 15 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

bundles. Sont supportes les rcuprations du bundle courant, d'un bundle en se fondant sur son identifiant dans
le conteneur ou de tous les bundles du conteneur.

Le code suivant illustre la mise en oeuvre de ces mthodes dans une entit ayant accs au contexte OSGi:

// Installation d'un nouveau bundle


Bundle bundleInstalle = contexte.installBundle(
"file:///home/templth/developpez/OSGi/simplebundle.jar");
long idBundle = bundleInstalle.getBundleId();

// Rcupration d'une instance d'un bundle prsent dans le conteneur


Bundle bundle = contexte.getBundle(idBundle);
int etatBundle = bundle.getState();

Comme vous pouvez le constater, le code prcdent repose sur l'interface Bundle correspondant l'entit relative
un composant OSGi. Cette dernire permet de rcuprer des informations sur le bundle mais galement de grer
son tat. Le code suivant dcrit le contenu de l'interface Bundle:

public interface Bundle {


public static final int UNINSTALLED = 0x00000001;
public static final int INSTALLED = 0x00000002;
public static final int RESOLVED = 0x00000004;
public static final int STARTING = 0x00000008;
public static final int STOPPING = 0x00000010;
public static final int ACTIVE = 0x00000020;

Enumeration findEntries(String path, String filePattern, boolean recurse)


BundleContext getBundleContext()
long getBundleId()
URL getEntry(String path)
Enumeration getEntryPaths(String path)
Dictionary getHeaders()
Dictionary getHeaders(String locale)
long getLastModified()
String getLocation()
ServiceReference[] getRegisteredServices()
URL getResource(String name)
Enumeration getResources(String name)
ServiceReference[] getServicesInUse()
int getState()
String getSymbolicName()
boolean hasPermission(Object permission)
Class loadClass(String name)
void start()
void start(int options)
void stop()
void stop(int options)
void uninstall()
void update()
void update(InputStream in)
}

Il est ainsi possible par la programmation, aprs l'installation d'un bundle, de raliser le dmarrage du bundle et de
rcuprer les diffrents services mis disposition par le bundle puis de l'arrter, comme l'illustre le code suivant:

// Installation d'un nouveau bundle


Bundle bundleInstalle = contexte.installBundle(
"file:///home/templth/developpez/OSGi/simplebundle.jar");

// Dmarrage du bundle (tat installed vers active)


bundle.start();

// Rcupration des services mis disposition


ServiceReference[] serviceReferences = bundle.getRegisteredServices();

// Arrt du bundle (tat active vers resolved)


bundle.stop();

- 16 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

Pour finir, le contexte offre la possibilit de spcifier des observateurs d'vnements sur le conteneur OSGi lui-mme,
sur les bundles et sur les services. Cet aspect est couramment utilis dans les bonnes pratiques de mise en oeuvre
de la technologie OSGi, notamment par l'intermdiaire du patron de conception Extender [13] au niveau des bundles.

Le principe consiste en la mise en oeuvre d'un observateur utilisant les donnes des bundles afin de raliser des
traitements. Ce patron permet de mieux grer les tats des bundles lors de traitements gnraux, traitements pouvant
tre raliss de manire paresseuse. Cette approche est mise en oeuvre dans des outils tels que Declarative Services
[14], iPOJO[15], Spring Dynamic Modules [16].

Un observateur de bundles peut tre mis en oeuvre par l'intermdiaire des interfaces BundleListener et
SynchronousBundleListener, respectivement dclenches de manire asynchrone et synchrone. Les deux interfaces
mettent en oeuvre la mthode bundleChanged afin de notifier un changement pour un bundle. Cette mthode prend
en paramtre un objet de type BundleEvent, objet permettant d'avoir accs au bundle impact et l'vnement
dclencheur dans le cycle vie. Le code suivant illustre le contenu de l'interface BundleListener:

public interface BundleListener extends EventListener {


void bundleChanged(BundleEvent event);
}

La mise en oeuvre d'un observateur de bundles se ralise de la manire suivante:

// Enregistrement de l'observateur
BundleListener observateur = new BundleListener() {
public void bundleChanged(BundleEvent evenement) {
// Rcupration du bundle impact
Bundle bundle = evenement.getBundle();
int etat = evenement.getType();
(...)
}
};

context.addBundleListener(observateur);

- 17 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

7 - Mise en oeuvre de services

Comme nous l'avons voqu prcdemment, la technologie OSGi offre la possibilit de mettre des services au niveau
des composants. Elle permet de bien sparer le contrat du service (interface) de la ou des implmentations fournies
par les composants. Les consommateurs du service n'ont connaissance que de son interface. De plus, les services
mis en oeuvre avec OSGi n'ont aucune adhrence avec les API de conteneurs et consistent en de simples POJOs
[17].

La technologie OSGi, par l'intermdiaire de l'interface BundleContext, offre la possibilit un composant de mettre
disposition des services par l'intermdiaire de la mthode registerService. Le premier paramtre de cette mthode
correspond au nom du service, nom visible au niveau du conteneur. Un usage courant consiste spcifier le nom
de l'interface du service comme nom du service.

Le code suivant dcrit la manire d'enregistrer un service dans un conteneur OSGi par l'intermdiaire du contexte
OSGi:

SimpleService service = new SimpleServiceImpl();


ServiceRegistration serviceRegistration = context.registerService(
SimpleService.class.getName(), service, null);

Le dsenregistrement d'un service OSGi se ralise par l'intermdiaire de la mthode unregister de l'instance de
ServiceRegistration renvoye prcdemment par la mthode register. Une bonne pratique consiste donc le garder
en variable d'instance (de l'activateur par exemple). Le code suivant illustre la mise en oeuvre d'un dsenregistrement
de service:

ServiceRegistration serviceRegistration = (...)


serviceRegistration.unregister();

Diffrentes mthodes sont galement fournies afin d'avoir accs aux services afin de les utiliser. La rcupration d'une
instance de service se ralise en deux tapes. La premire consiste en la rcupration d'une instance de l'interface
ServiceReference pour le service par l'intermdiaire de la mthode getServiceReference ou getServiceReferences.
L'utilisation de la mthode getService avec en paramtre l'instance prcdente permet d'avoir accs l'instance du
service et de l'utiliser.

Le code suivant dcrit la manire d'avoir accs une instance d'un service partir de son nom et par l'intermdiaire
du contexte OSGi:

// Rcupration de la rfrence du service


ServiceReference reference = context.getServiceReference(
SimpleService.class.getName());

// Rcupration de l'instance du service


SimpleService service = context.getService(reference);
(...)

Il est noter que, dans le cas d'une utilisation d'un service en dehors du conteneur, le transtypage dans le type du
service ne fonctionnera pas. En effet, les classes et interfaces gres par le conteneur ne sont visibles et utilisables
qu'en son sein. Un service OSGi reste nanmoins utilisable en se fondant sur l'introspection.

Nous pouvons galement noter la prsence d'une mthode ungetService au niveau du contexte afin de librer
l'instance du service rfrence par l'instance de ServiceReference correspondante.

- 18 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

8 - Conclusion

Dans ce premier article, nous avons introduit la technologie OSGi et les diffrentes problmatiques qu'elle vise
adresser. Nous avons galement dcrit les caractristiques de la technologie et comment mettre en oeuvre des
composants OSGi, composants dsigns par le terme bundle dans la terminologie d'OSGi. Nous avons ainsi abords
les diffrentes couches structurant les conteneurs de ce type, savoir les couches Module, Cycle de vie et Service.

Dans le prochain article, nous verrons comment mettre concrtement en oeuvre des composants OSGi dans un
conteneur embarqu dans un processus Java. Pour ce faire, nous utiliserons le conteneur OSGi libre Felix. Nous
verrons galement comment tirer partie de l'environnement Eclipse afin de dvelopper des bundles OSGi.

- 19 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/
Programmation par composant avec la technologie OSGi (Partie 1) par Thierry Templier (co-auteur du livre Spring par la pratique)

9 - Bibliographie

1 - Getting started with OSGi, de Neil Bartlett.


http://neilbartlett.name/blog/osgi-articles/
2 - Getting started with OSGi, de Neil Bartlett.
http://www.eclipse.org/resources/?author=Neil%20Bartlett
3 - Cours et Tutoriel sur OSGi, de Didier Donsez.
http://www-adele.imag.fr/users/Didier.Donsez/cours/exemplesosgi/

Rfrences:
[1] http://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_composant
[2] http://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet
[3] http://www.springframework.org
[4] http://fr.wikipedia.org/wiki/Fabrique_%28Motif_de_conception%29
[5] http://fr.wikipedia.org/wiki/Injection_de_d
%C3%A9pendance#Principe_de_l.27inversion_des_d.C3.A9pendances
[6] http://dico.developpez.com/html/302-Generalites-SOA-Service-Oriented-Architecture.php
[7] http://dico.developpez.com/html/1750-Internet-SOAP-Simple-Object-Access-Protocol.php
[8] http://dico.developpez.com/html/1824-Internet-WSDL-Web-Services-Description-Language.php
[9] http://hivemind.apache.org
[10] http://www.eclipse.org
[11] http://felix.apache.org
[12] http://www.hibernate.org
[13] http://www.osgi.org/blog/2007/02/osgi-extender-model.html
[14] http://www.eclipsezone.com/eclipse/forums/t96740.html
[15] http://felix.apache.org/site/ipojo.html
[16] http://www.springframework.org/osgi
[17] http://fr.wikipedia.org/wiki/POJO

- 20 -
Ce document est issu de http://www.developpez.com et reste la proprit exclusive de son auteur. La copie, modification
et/ou distribution par quelque moyen que ce soit est soumise l'obtention pralable de l'autorisation de l'auteur.
http://t-templier.developpez.com/tutoriel/java/osgi/osgi1/

Vous aimerez peut-être aussi