Une compréhension générale de JNDI:
JNDI (Java Naming and Directory Interface) Il fournit un ensemble d'interfaces qui utilisent des services de dénomination et d'annuaire. Les utilisateurs peuvent utiliser des services de dénomination et d'annuaire via l'informatique. Tout comme JDBC. JNDI comprend deux parties: Service nommé et service Directory, où le service Directory contient un objet d'objet Directory, qui contient plusieurs objets d'attribut. Fournit de nombreuses opérations sur les propriétés.
Services de dénomination et d'annuaire:
Nous utilisons des services de dénomination et d'annuaire, tels que le système de fichiers du système d'exploitation, qui nous offre des fonctions telles que les opérations, les requêtes, l'addition et la suppression de fichiers. Le service DNS lie l'URL et l'adresse IP ensemble. La fonction la plus importante des systèmes de dénomination et de répertoire est de lier le nom et l'objet. Sur la base de celui-ci, il fournit également plus de fonctions telles que la recherche et la recherche. De plus, les objets stockés ont une certaine hiérarchie. En utilisant un tel service, nous pouvons gérer et exploiter des objets plus efficacement.
Le service de dénomination mappe un nom à un objet. RMI Registry et Corba Naming Service sont tous deux des services de dénomination.
Le service d'annuaire stocke également des objets, mais le service d'annuaire reconnaît les propriétés pertinentes de ces objets. Vous pouvez utiliser les propriétés du projet pour rechercher des répertoires.
Au début des années 1990, le protocole d'accès au répertoire léger (LightweightDiretoryAccessProtocol) a été développé en tant que protocole d'annuaire standard, et JNDI a pu accéder à LDAP.
J2SE fournit 5 packages d'extension pour JNDI:
Contexte: Le contexte est un ensemble de liaisons de nom à objet, qui peuvent être comprises comme une hiérarchie ou un répertoire. Il peut également inclure la couche suivante de sous-contexte. Obtenir le contexte initial lors de l'utilisation de services de dénomination et d'annuaire est l'entrée de l'ensemble de l'opération d'espace de noms. Dans le service d'annuaire est dirContext.
JNDI (Java Naming and Directory Interface) est une API conçue par l'application qui fournit aux développeurs une interface commune et unifiée pour trouver et accéder à divers services nommés et répertoires. JDBC est construit sur la couche d'abstraction.
Les répertoires et services existants auxquels JNDI peuvent accéder sont:
DNS, XNAM, Novell Directory Service, LDAP (Protocole d'accès au répertoire léger), Corba Object Service, Système de fichiers, Windows XP / 2000 / NT / ME / 9X Registry, RMI, DSML V1 & V2, NIS.
Avantages de JNDI:
Il contient un grand nombre de services de dénomination et d'annuaire, en utilisant une interface commune pour accéder à différents types de services; Il peut être connecté à plusieurs services de dénomination ou d'annuaire en même temps; Il établit des associations logiques, permettant aux noms d'être associés à des objets ou des ressources Java sans avoir à guider l'ID physique des objets ou des ressources.
Package JNDI:
JNDI contre JDBC:
JNDI fournit un moyen unifié de trouver et d'accès aux services sur le réseau. En spécifiant un nom de ressource qui correspond à un enregistrement dans la base de données ou le service de dénomination, il renvoie les informations nécessaires à l'établissement de connexion de la base de données.
Exemple de code:
try {context cntxt = new initialContext (); dataSource ds = (dataSource) cntxt.lookup ("jdbc / dpt");} catch (namingException ne) {...} JNDI et JMS:
La communication de message est une méthode utilisée par les composants du logiciel ou les applications à communiquer. JMS est une technologie Java qui permet aux applications de créer, envoyer, recevoir et lire des messages.
Exemple de code:
try {Properties Env = new Properties (); initialContext inictxt = new InitialContext (Env); topicConnectionFactory Connfactory = (topicConnectionFactory) inictxt.lookup ("ttopicConnectionFactory"); ...} catch (namingException ne) {...} Visitez des répertoires spécifiques: par exemple, une personne est un objet, et il a plusieurs attributs, tels que le nom de la personne, le numéro de téléphone, l'adresse e-mail, le code postal et d'autres attributs. Par la méthode getAttributes ()
Attribut attR = Directory.getAttributes (PersonName) .get ("Email"); String Email = (String) att.get (); En utilisant JNDI, permettant aux clients d'utiliser le nom ou les attributs de l'objet pour trouver des objets:
Foxes = Directory.Search ("O = Wiz, C = US", "Sn = Fox", Contrôles); Exemples de recherche d'imprimantes en utilisant JNDI pour trouver des objets tels que des imprimantes et des bases de données:
Imprimante imprimante = (imprimante) namespace.lookup (printerName); imprimante.print (document);
Parcourir les espaces de noms:
NAMINGENUMERATION LISTE = NAMESSPACE.LIST ("O = Widget, C = US"); while (list.hasmore ()) {nameclasspair entrée = (nameclasspair) list.next (); display (entry.getName (), entry.getClassName ());}Exemple de code: regardez le nom, le nom de classe et l'objet lié.
NAMINGENUMERATION NAMENUMLIST = CTXT.LISTBINDING ("CNTXTNAME"); ... while (namenumList.Hasmore ()) {Binding bnd = (Binding) namenumList.next (); String sobjname = bnd.getName (); String Sclassname = BND.getClassname (); SomeObject ObjLocal = BND.getClassname (); SomeObject. bnd.getObject ();} Comprendre les concepts des services de noms et des services d'annuaire aidera à mieux utiliser JNDI. Le service de nom de service de dénomination définit comment associer un nom à un objet et comment trouver un objet via un nom. Les exemples typiques sont: DNS associe les noms de domaine avec IP, et File Systems associe les noms de fichiers avec les fichiers. Dans le service de nom, les principaux concepts:
- noms (noms), le nom de code de l'objet réel dans le système de nom, tels que les noms de fichiers, les noms de domaine, etc., il sera utilisé pour trouver l'objet associé. Différents systèmes auront des spécifications de dénomination différentes, tels que le système de fichiers utilise "/" pour représenter la hiérarchie, tandis que DNS utilise ".".
- liaisons, association des noms et des objets réels.
- Références et adresses. Lorsqu'un objet ne peut pas être stocké directement dans le système de noms, une référence doit être utilisée pour trouver l'objet réel via référence. Dans le système, le contenu de la référence enregistrée est appelé une adresse. Les citations ont une autre utilisation: dans le système de noms, le concept de clés étrangères dans les bases de données relationnelles fait défaut. En utilisant des références, il peut être utilisé comme alternative aux clés étrangères.
- Contexte, il s'agit d'une collection de noms de noms, fournissant les principales opérations pour interagir avec le système de noms, tels que la recherche, la liaison et la liaison. La relation entre le contexte de l'enfant (sous-contexte) est similaire à la relation entre les répertoires et les sous-répertoires dans un système de fichiers. Le contexte de l'enfant est contenu dans un contexte et est associé au contexte de l'enfant à travers un nom dans le contexte parent.
- Systèmes de dénomination et espaces de noms. Le système de noms est une collection du même type de contexte et fournit des services de noms. L'espace de nom est une collection de noms dans le système de noms, tels que les noms de fichiers et les répertoires du système de fichiers.
Directory Service Directory Service est une extension du service de nom. En plus d'associer les noms et objets, il permet également aux objets de contenir des attributs. Les systèmes d'annuaire organisent généralement des données dans une hiérarchie. Les principaux concepts des services d'annuaire:
- Attributs, qui appartient à un objet de répertoire, il s'agit d'une paire (nom, valeur), et l'attribut peut avoir plusieurs valeurs.
- Répertoires et services d'annuaire, les répertoires sont des collections d'objets d'annuaire; Les services d'annuaire fournissent des services liés à la répertoire pour créer, supprimer et modifier les propriétés des objets stockés dans le répertoire.
- Recherches et filtres de recherche, le fonctionnement de l'obtention d'objets de répertoire est la recherche; Les filtres sont des objets similaires aux conditions de recherche.
Utilisation de base
² Enregistrant un fournisseur JNDI Avant d'utiliser JNDI, vous devez obtenir le fournisseur JNDI et l'enregistrer auprès du système. Les propriétés système liées à JNDI sont définies dans javax.naming.context, propriétés couramment utilisées:
- java.naming.factory.Initial, le nom de classe utilisé par le fournisseur de services pour créer le InitialContext.
- java.naming.provider.url, utilisé pour configurer l'URL initiale de initialContext
- java.naming.factory.object, une classe utilisée pour créer des cartes de nom-objet, utilisées pour nameclasspair et références.
- java.naming.factory.state, la classe utilisée pour créer un état JNDI. Pour les services d'annuaire, il nécessite généralement des paramètres de sécurité et est généralement utilisé:
- java.naming.security.authentification, type de sécurité, trois valeurs: aucune, simple ou forte.
- java.naming.security.principal, informations d'authentification.
- java.naming.security.Credentials, Informations sur le certificat.
- java.naming.security.protocol, nom de protocole de sécurité.
Inscrivez-vous avec System.SetProperty. Si le programme n'affiche pas les instructions, Java recherchera le fichier jdni.properties dans le chemin de classe pour terminer l'inscription. jdni.properties Exemple:
java.naming.factory.inial = com.codeline.db.mockInitialContextFactory
Service de connexion
Après votre inscription, vous pouvez implémenter la connexion du service. Pour les services de noms, commencez par InitialContext, les services de répertoire utilisent InitialDirConText. Ils implémentent respectivement le contexte et le dirContext. Ces deux interfaces correspondent aux interfaces des services de noms et des services d'annuaire, et sont également les deux interfaces les plus importantes de JNDI.
Service de nom de connexion:
System.SetProperty (context.inial_context_factory, "com.sun.jndi.fscontext.fscontextfactory"); InitialContext ctx = new InitialContext ();
Connectez-vous aux services de répertoire:
HashTable Env = new HashTable (); Env.put (context.inial_context_factory, "com.sun.jndi.ldap.ldapctxfactory"); Env.put (context.provider_url, "ldap: //myserver.com/"); env.put (context.security_authentication, "simple"); // Le nom d'utilisateur requis pour se connecter au serveur LDAP est env.put (context.security_principal, "ldapuser"); // Connexion pour LDAP Le mot de passe requis par le serveur est Env.put (context.security_credentials, "myPassword"); InitialDirConText ctx = new InitialDirConText (Env);
Proviseur multi-services: si l'application contient plusieurs fournisseurs de services, il est légèrement différent lors de la connexion. Prenez le service de noms à titre d'exemple
HashTable Env = new HashTable (); Env.put (context.inial_context_factory, "com.sun.jndi.rmi.registry.registryContextFactory"); Env.put (context.provider_url, "rmi: //myserver.com: 1099"); // utilise différents constructeurs initialContext ctx = new InitialContext (env);
Trouver des objets
Qu'il s'agisse d'un service de nom ou d'un service d'annuaire, la recherche est utilisée pour trouver des objets. En plus d'utiliser la chaîne comme paramètre, la recherche peut également utiliser l'interface de nom comme paramètre.
Greeter greeter = (greeter) ctx.lookup ("sayhello"); Si vous souhaitez obtenir tous les noms d'objets dans le contexte, utilisez LIS pour retourner la liste NameClasspair. NameClassPair contient le nom d'objet et le nom de la classe d'objets. Si vous souhaitez obtenir la liste réelle des instances d'objet, utilisez ListBindings, qui renvoie la liste de liaison. La liaison est une sous-classe de NameClasspair, qui contient des instances d'objets.
- liste
NAMINGENUMERATION LISTE = CTX.LIST ("AWT"); while (list.hasmore ()) {nameclasspair nc = (nameclasspair) list.next (); System.out.println (NC); } - ListBindings
NAMINGENUMERATION BINDINGS = CTX.LISTBINDINGS ("AWT"); while (bindings.hasmore ()) {liaison bd = (liant) bindings.next (); System.out.println (bd.getName () + ":" + bd.getObject ()); }
Liaison d'objet
- Ajouter la liaison en utilisant Bind
Fruit fruit = nouveau fruit ("orange"); ctx.bind ("favori", fruit); - Utilisez Rebind pour modifier la liaison
Fruit fruit = nouveau fruit ("citron"); ctx.rebind ("favori", fruit); - Utilisez unbout pour supprimer les liaisons.
ctx.unbind ("favori");
Renommer l'objet
Utilisez Renommer pour renommer un objet dans le contexte
ctx.rename ("report.txt", "old_report.txt");- Les interfaces liées à l'obtention d'attributs d'attribut sont des attributs et des attributs, qui sont tous deux dans le package javax.naming.directory. Vous pouvez obtenir l'attribut de l'objet défini via la méthode GetAtTributes de DirContext, puis utilisez la méthode GET des attributs pour obtenir les attributs correspondants, et enfin vous pouvez obtenir la valeur d'attribut via la méthode GET d'attribut.
String dn = "uid = me, dc = myCompany, dc = com, ou = client, o = exampleApp"; Context User = (Context) ctx.lookup (dn); // Obtenez tous les attributs Attributs attrs = user.getAttributes (""); Attribut test = attrs .get ("test"); Objet testvalue = test.get ();Dans l'exemple ci-dessus, tous les attributs de l'utilisateur sont obtenus. Dans une utilisation réelle, compte tenu de l'impact de la bande passante du réseau, vous pouvez définir la liste des attributs à obtenir:
String reqd_attrs = new String [] {"famille", "initiales", "title", "rfc822mailalias"}; Attributs attrs = user.getAttributes ("", reqd_attrs);
Trouver et filtrer
Utilisez la méthode de recherche pour terminer.
public dirContext [] findUser (Initials de chaîne, nom de famille, pays de chaîne, téléphone de chaîne) {// Conditions de construction BasicAttributes Search_ATTRS = new BasicAttributes (); search_attrs.put ("initiales", initiales); search_attrs.put ("sn", incident); search_attrs.put ("C", pays); if (téléphone! = null) search_attrs.put ("phonenumber", téléphone); NAMINGENUMERATION RÉSULTATS = INITIAL_CTX.SEARCH ("OU = client, O = ExampleApp", Search_ATTRS); LinkedList Found = new LinkedList (); while (results.hasmore ()) {searchResults sr = (searchResults) results.Next (); String name = sr.getName (); Objet ctx = sr.getObject (); if ((ctx == null) ||! (CTX instanceof dirContext)) find.add (initial_ctx.lookup (name)); else Found.Add (CTX); } DirContext [] ret_val = new DirContext [Found.size ()]; Found.ToArray (RET_VAL); return ret_val; }
Les principales méthodes de filtrage de l'interface DirContext:
1. Utilisez des chaînes de filtre
String reqd_attrs = new String [] {"CN", "UID", "RFC822MAILALIAS"}; NAMINGENUMERATION RÉSULTATS = INITIAL_CTX.SEARCH ("Ou = client, o = exampleApp", search_attrs, reqd_attrs);
2. Utilisez SearchControls pour obtenir plus de contrôle
SearchControls ctrls = new searchControls (); ctrls.setCountLimit (20); ctrls.settimelimit (5000); Ctrls.SetSearchScope (SearchControls.SubTree_Scope); NAMINGENUMERATION RÉSULTATS = INITIAL_CTX.SEARCH ("Cat = Books, ou = Products, O = ExampleApp", "Title = * Java *", Ctrls); Modifier les propriétés
Il se fait à l'aide des méthodes ModifyAtTributes de DirContext et InitialDirConText. Le processus soi-disant modification consiste en fait à construire d'abord la liste des attributs à modifier, puis à soumettre en utilisant la méthode ci-dessus. Lorsqu'une propriété contient plusieurs valeurs, il est nécessaire d'inclure les valeurs non modifiées de la propriété, sinon le serveur supprimera ces valeurs si elles ne sont plus nécessaires.
public void updateAddress (String dn, adresse de chaîne, pays de chaîne, téléphone de chaîne) {BasicAttributes mod_attrs = new BasicAttributes (); if (adresse! = null) mod_attrs.put ("adresse", adresse); if (country! = null) mod_attrs.put ("c", country); if (téléphone! = null) mod_attrs.put ("phonenumber", téléphone); if (mod_attrs.size ()! = 0) initial_ctx.modifyAttributes (dn, dirContext.replace_attribute, mod_attrs); } En utilisant ModificationItem, vous pouvez également effectuer plusieurs opérations de modification différentes à la fois:
ModificationItem [] mod_items = new modificationItems [2]; Attribut e-mail = new BasicAttribute ("RFC822MAILALIAS", new_email); ModificationItem e-mail_mod = new modificationItem (dirContext.add_attribute, e-mail); Attribut addr = new BasicAttribute ("adresse", adresse); ModificationItem addr_mod = new modificationItem (dirContext.replace_attribute, addr); mod_items [0] = email_mod; mod_items [1] = addr_mod; initial_ctx.modifyAttributes (dn, mod_items); Créer un contexte
Utilisez la méthode CREETESUBCONText pour terminer.
BasicAttributes attrs = new BasicAttributes (); att.put ("initiales", initiales); attr.put ("sn", incident); attr.put ("RFC822MAILALIAS", e-mail); if (adresse! = null) att.put ("adresse", adresse); if (country! = null) attrs.put ("C", pays); if (téléphone! = null) attr.put ("phonenumber", téléphone); initial_ctx.createSubContext (dn, attrs);
Supprimer le contexte
Utilisez la méthode de destrucySubContext à terminer.
initial_ctx.destroyySubContext (dn);
Exemple
Voici un autre exemple.
Configurer dans conf / server.xml de Tomcat:
<
Un composant est déclaré dans Tomcat ci-dessus, et vous pouvez obtenir ce composant dans le code:
try {context initContext = new initialContext (); Context envCTX = (context) initContext.lookup ("java: comp / env"); MyBean Bean = (MyBean) EnvctX.lookup ("Bean / MyBeanFactory"); System.out.println (bean.getBar ()); } catch (exception e) {e.printStackTrace (); }Résumé: Configurez le composant JNDI dans Tomcat, puis obtenez les composants équipés dans le code.
Les classes d'implémentation JNDI de chaque conteneur Web sont différentes. Par exemple, dans JBoss, la classe de provision JNDI est org.jnp.interfaces.namingContextFactory, qui est différente de Tomcat.
De ce point de vue, le rôle de JNDI est similaire à celui de l'injection de dépendance de Spring. Cependant, via JNDI, il est possible d'obtenir des composants entre les applications et même entre les domaines. Les composants configurés sur le serveur A peuvent être obtenus via JNDI sur un autre serveur B.
Spring fournit également l'encapsulation de JNDI, qui est plus pratique à utiliser. Ce qui suit est un exemple.
<! - Jndi Template -> <bean id = "jnditemplate"> <propriété name = "Environment"> <props> <prop key = "java.naming.factory.initial"> org.jnp.interfaces.namingContex key = "java.naming.provider.url"> 10.137.96.212:18199 </prop> <prop key = "java.naming.factory.url.pkgs"> org.jnp.interfaces: org.jboss.naming </prop> </props> </premot id = "jmsconnectionfactory"> <propriété name = "jndItemplate" ref = "jnditemplate" /> <propriété name = "jndiname" value = "topicconnectionfactory" /> </ bean>
Déclarez d'abord JNDITEmplate, configurez les classes d'adresse cible et de service JNDI. Ensuite, via JNDiObjectFactoryBean, vous pouvez facilement obtenir des composants JNDI et effectuer une conversion de type.