• Ressources
• Langages
  • Java
    • Les collections
    • Conversion & Casting
    • Dates
    • Tableau
    • Bytes
    • Formatage
    • Traitement de fichiers
    • Erreurs
    • Le fichier Manifest
    • Servlet
    • EJB 2.x
    • EJB 3.x
    • JNDI
    • Les méthodes
    • Les Threads
    • Les Opérateurs
    • Les Mots clés
    • MOM - JMS
    • Class loader
    • Garbage Collector
    • Les transactions
    • Les primitives
    • Les expressions régulières
    • Les annotations
    • Les génériques
    • CDI

JNDI (Java Naming and Directory Interface)

Présentation

Java Naming and Directory Interface (JNDI) est une API (Application Programming Interface) qui fournie les fonctionnalités de nommage et d'annuaire aux applications écrites en Java. Elle est définie pour être indépendante du service d'annuaire. Ainsi une variété d'annuaires -- nouveaux, émergeant, et déjà déployé -- peuvent être consulté de manière commune.

Architecture

L'architecture de JNDI se compose d’une API et d’un Service Provider Interface (SPI). Les applications de Java emploient l’API JNDI pour accéder à une variété de services de nommage et d'annuaire. Le SPI permet de brancher, de manière transparente, une variété de services de nommage et d'annuaire ; permettant ainsi à l'application Java d’accéder à ces services en utilisant l’API JNDI.

J2EE

JNDI est très utilisée dans l'univers des serveurs d'applications Java et fait partie de l'ensemble des APIs J2EE où il permet de lier un nom (par exemple 'base/sql/login') à une information. Il sert de référentiel de configuration aux applications et au serveur d'applications lui même.

Initialisation du contexte JNDI

La première étape pour accéder à un annuaire JNDI consiste à instancier un objet contexte. Utiliser le constructeur sans paramètres de la classe javax.naming.InitialContext permet d'accéder au contexte par défaut du serveur d'applications.

javax.naming.InitialContext ctx = new javax.naming.InitialContext();

Il existe deux manières d'accéder à un autre annuaire.

Changer les propriétés systèmes

• java.naming.factory.initial: Indique la classe java du fournisseur JNDI
• java.naming.provider.url: adresse de l'annuaire, cette propriété est nulle dans le cas des annuaires locaux, et contient sinon l'URL de l'annuaire

C:\java>java -Djava.naming.factory.initial=com.sun.jndi.ldap.LdapCtxFactory
             -Djava.naming.provider.url=ldap://localhost

Fournir une table de paramètres

S'il n'est pas possible de modifier les paramètres par défaut de la machine virtuelle (cas de l'accès à un annuaire externe à l'intérieur d'un serveur d'applications), il faut construire une table contenant les valeurs des paramètres JNDI.

java.util.Hashtable env = new java.util.Hashtable();

env.put(javax.naming.Context.INITIAL_CONTEXT_FACTORY, 
                                            "com.sun.jndi.ldap.LdapCtxFactory");
env.put(javax.naming.Context.PROVIDER_URL, "ldap://localhost"); 

Accéder à l'annuaire

La méthode listBindings() permet de lister les entrées JNDI d'un contexte. Elle retourne une NamingEnumeration d'objets Binding.

NamingEnumeration enum = ctx.listBindings(name);

while (enum.hasMoreElements()) {
  Binding currentElement = (Binding)enum.next();
  Object currentObject = currentElement.getObject();
  System.out.print(currentElement.getName());
  System.out.print(" : ");
  System.out.println(currentObject);
}

La méthode lookup() permet de rechercher une entrée dans l'annuaire JNDI.

DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/masource");

Références

Les objets sont stockés dans les services de nommage et d'annuaire de plusieurs manières. Un service qui supporte le stockage des objets Java peut les stocker sous sa forme sérialisée. Cependant, certain service de nommage et d'annuaire ne peuvent stocker d'objets Java. Une référence doit être une représentation très compacte de l’objet, alors que sa forme sérialisée peut contenir beaucoup plus d’information.

JNDI définit la classe Reference pour représenter une référence. Une référence contient les informations sur la manière de construire une copie de l'objet. JNDI essayera de transformer les références, recherchées dans l'annuaire, en l’objet Java qu'elles représentent ; de sorte que les clients JNDI aient l'illusion que ce qui est stocké dans l'annuaire sont les objets Java eux-mêmes.

java:comp/env/

This servlet displays all its J2EE environment entries, using the JNDI API to browse the java:comp/env context. All entries are placed by the server into the java:comp/env context. If you’re new to JNDI, you can think of this as a URL base or filesystem directory. The java:comp/env context is read-only and unique per web application, so if two different web applications define the same environment entry, the entries do not collide. This feature is only available to servers supporting J2EE.

JNDI et application web

Vous pouvez facilement mapper une valeur à une clé et donc spécifier la classe à utiliser pour tel ou tel service sans avoir à l’intégrer à votre code directement. Voici un exemple de configuration JNDI pour une application web (dans le web.xml)

<env-entry>
 <env-entry-name>contactDaoImpl/env-entry-name>
 <env-entry-value>com.society.contact.dao.impl.ContactDaoXml</env-entry-value>
 <env-entry-type>java.lang.String</env-entry-type>
</env-entry>

Ces lignes définissent une entrée "contactDaoImpl" dans l’environnement de l’application contenant la valeur "com.society.contact.dao.impl.ContactDaoXml", c'est-à-dire le nom absolue de la classe DAO à utiliser pour l’implémentation du DAO lié au Contact.

Vous pouvez alors récupérer facilement la valeur dans votre Fabrique

Context ctx = new InitialContext();
String contactDaoImpl = (String) ctx.lookup("java:comp/env/contactDaoImpl");
IContactDao dao = (IContactDao) Class.forName(contactDaoImpl).newInstance();

Ces quelques lignes permettent d’instancier de façon dynamiquement la classe indiquée dans l’entrée d’environnement : "contactDaoImpl".

L’avantage de cette méthode est évidente : on peut changer la classe d’implémentation de "contactDao" sans avoir à recompiler l’ensemble de l’application!

JNDI et application standalone

La distribution 5.5 de Tomcat, contient les 2 jars naming-factory.jar et naming-resources.jar dans le dossier TOMCAT_HOME/common/lib dossier. Ceux-ci permettent de créer un annuaire JNDI pour une application standalone. Il vous suffit de créer un fichier jndi.properties à la racine de votre classpath. Il doit contenir cette ligne:

java.naming.factory.initial = org.apache.naming.java.javaURLContextFactory

Cela permet de configurer Tomcat comme serveur JNDI par défaut. Il s'agit en fait d'un simple serveur interne à la VM qui met en oeuvre les plus importantes caractéristiques JNDI. Il suffit en suite de créer un InitialContext sans argument pour avoir accès à celui-ci.