Una comprensión general de JNDI:
JNDI (Interfaz Java Naming and Directorio) proporciona un conjunto de interfaces que utilizan servicios de nombres y directorio. Los usuarios pueden usar servicios de nombres y directorio a través de él. Al igual que JDBC. JNDI incluye dos partes: servicio con nombre y servicio de directorio, donde el servicio de directorio contiene objeto de directorio de objetos de directorio, que contiene varios objetos de atributo. Proporciona muchas operaciones en propiedades.
Servicios de nombres y directorio:
Hemos estado utilizando servicios de nombres y directorio, como el sistema de archivos del sistema operativo, que nos proporciona funciones como operaciones, consultas, adición y eliminación de archivos. El servicio DNS une la URL y la dirección IP juntas. La función más importante de los sistemas de nombres y directorio es unir el nombre y el objeto. Sobre la base de ello, también proporciona más funciones, como la búsqueda y la búsqueda. Además, los objetos almacenados tienen una cierta jerarquía. Usando dicho servicio, podemos administrar y operar objetos de manera más efectiva.
El servicio de nombres asigna un nombre a un objeto. RMI Registry y Corba Naming Service son servicios de nombres.
El servicio de directorio también almacena objetos, pero el servicio de directorio reconoce las propiedades relevantes de estos objetos. Puede usar propiedades del proyecto para buscar directorios.
A principios de la década de 1990, el protocolo de acceso de directorio ligero (LightweightDiretoryAccessProtocol) se desarrolló como un protocolo de directorio estándar, y JNDI pudo acceder a LDAP.
J2SE proporciona 5 paquetes de extensión para JNDI:
Contexto: el contexto es un conjunto de enlaces de nombre a objeto, que puede entenderse como una jerarquía o directorio. También puede incluir la siguiente capa de subcontexo. Obtener un contexto inicial al usar servicios de nombres y directorio es la entrada a toda la operación del espacio de nombres. En el servicio de directorio está dircontext.
JNDI (interfaz Java Naming and Directory) es una API diseñada por la aplicación que proporciona a los desarrolladores una interfaz común y unificada para encontrar y acceder a varios servicios nombrados y directorio. JDBC se basa en la capa de abstracción.
Los directorios y servicios existentes a los que JNDI puede acceder son:
DNS, XNAM, Servicio de Directorio Novell, LDAP (Protocolo de acceso de directorio liviano), servicio de objetos CORBA, sistema de archivos, Windows XP/2000/NT/ME/9X Registry, RMI, DSML V1 y V2, NIS.
Ventajas de Jndi:
Contiene una gran cantidad de servicios de nombres y directorio, utilizando una interfaz común para acceder a diferentes tipos de servicios; Se puede conectar a múltiples servicios de nombres o directorio al mismo tiempo; Establece asociaciones lógicas, lo que permite que los nombres se asocien con objetos o recursos Java sin tener que guiar la identificación física de los objetos o recursos.
Paquete JNDI:
JNDI vs. JDBC:
JNDI proporciona una forma unificada de encontrar y acceder a los servicios en la red. Al especificar un nombre de recurso que corresponde a un registro en la base de datos o el servicio de nombres, devuelve la información necesaria para el establecimiento de la conexión de la base de datos.
Ejemplo de código:
Pruebe {context cntxt = new InitialContext (); DataSource ds = (DataSource) cntxt.lookup ("jdbc/dpt");} catch (namingException ne) {...} JNDI y JMS:
La comunicación de mensajes es un método utilizado por componentes o aplicaciones de software para comunicarse. JMS es una tecnología Java que permite que las aplicaciones creen, envíen, reciban y lean mensajes.
Ejemplo de código:
Pruebe {Propiedades env = new Properties (); inicialContext inTictxt = new InitialContext (env); TopicConnectionFactory connfactory = (topicConnectionFactory) inictxt.lookup ("ttopicConnectionFactory"); ...} Catch (NamingException ne) {...} Visite directorios específicos: por ejemplo, una persona es un objeto, y tiene varios atributos, como el nombre de la persona, el número de teléfono, la dirección de correo electrónico, el código postal y otros atributos. Por el método getAttributes ()
Attribute attr = directorio.getAttributes (PersonName) .get ("Correo electrónico"); String Correo electrónico = (String) attr.get (); Al usar JNDI, dejar que los clientes usen el nombre o los atributos del objeto para encontrar objetos:
FOXES = Directory.Search ("O = Wiz, C = US", "Sn = Fox", Controls); Ejemplos de encontrar impresoras utilizando JNDI para encontrar objetos como impresoras y bases de datos:
Impresora impresora = (impresora) Space.lookup (Printername); Printer.print (documento);
Explorar espacios de nombres:
NamingeNumeration list = namespace.list ("o = widget, c = us"); while (list.hasmore ()) {nameclasspair entry = (nameClasspair) list.next (); display (entry.getName (), entry.getClassName ());}Ejemplo de código: vuelva a realizar el nombre, el nombre de la clase y el objeto vinculado.
NamingeNumeration namenumList = ctxt.listbinding ("cntxtName"); ... while (namenumList.hasmore ()) {binding bnd = (binding) namenumList.next (); string soBJND.getName (); string scLassName = bnd.getClassName (); (SomeObject) bnd.getObject ();} Comprender los conceptos de servicios de nombres y servicios de directorio ayudará a usar mejor JNDI. El servicio de nombre del servicio de nombres define cómo asociar un nombre con un objeto y cómo encontrar un objeto a través de un nombre. Los ejemplos típicos son: DNS Associates Dominio Nombres con IP, y File Systems Associates Nombres de archivos con archivos. En el servicio de nombre, los conceptos principales:
- Nombres (nombres), el nombre de código del objeto real en el sistema de nombre, como nombres de archivos, nombres de dominio, etc., se usará para encontrar el objeto asociado. Los diferentes sistemas tendrán diferentes especificaciones de nombres, como el sistema de archivos usa "/" para representar la jerarquía, mientras que DNS usa ".".
- Bindings, la asociación de nombres y objetos reales.
- Referencias y direcciones. Cuando un objeto no se puede almacenar directamente en el sistema de nombre, se debe usar una referencia para encontrar el objeto real a través de la referencia. En el sistema, el contenido de la referencia guardada se llama dirección. Las citas tienen otro uso: en el sistema de nombre, falta el concepto de claves extranjeras en bases de datos relacionales. Al usar referencias, se puede usar como una alternativa a las claves extranjeras.
-Contexto, es una colección de objetivos de nombre, que proporciona las operaciones principales para interactuar con el sistema de nombres, como la búsqueda, la vinculación y la eliminación de la vinculación. La relación entre el contexto infantil (Subcontext) es similar a la relación entre directorios y subdirectorios en un sistema de archivos. El contexto del niño está contenido en un contexto y se asocia con el contexto del niño a través de un nombre en el contexto principal.
- Sistemas de nombres y espacios de nombres. El sistema de nombre es una colección del mismo tipo de contexto y proporciona servicios de nombre. El espacio de nombre es una colección de nombres en el sistema de nombres, como nombres de archivos y directorios del sistema de archivos.
Directorio Service Directory Service es una extensión del servicio de nombre. Además de asociar nombres y objetos, también permite que los objetos contengan atributos. Los sistemas de directorio generalmente organizan datos en una jerarquía. Los conceptos principales en los servicios de directorio:
- Atributos, que pertenece a un objeto de directorio, es un par (nombre, valor), y el atributo puede tener múltiples valores.
- Directorios y servicios de directorio, los directorios son colecciones de objetos de directorio; Los servicios de directorio proporcionan servicios relacionados con el directorio para crear, eliminar y modificar las propiedades de los objetos almacenados en el directorio.
- Búsquedas y filtros de búsqueda, se busca la operación de obtener objetos de directorio; Los filtros son objetos similares a las condiciones de búsqueda.
Uso básico
² Registro de un proveedor de JNDI antes de usar JNDI, debe obtener el proveedor de JNDI y registrarlo con el sistema. Las propiedades del sistema relacionadas con JNDI se definen en Javax.naming.Context, propiedades comúnmente utilizadas:
- java.naming.factory.initial, el nombre de clase utilizado por el proveedor de servicios para crear el initialContext.
- java.naming.provider.url, utilizado para configurar la URL inicial de InitialContext
-java.naming.factory.object, una clase utilizada para crear mapas de nombre a objeto, utilizado para nameClasspair y referencias.
- java.naming.factory.state, la clase utilizada para crear el estado JNDI. Para los servicios de directorio, generalmente requiere configuración de seguridad y generalmente se usa:
- java.naming.security.authentication, tipo de seguridad, tres valores: ninguno, simple o fuerte.
- java.naming.security.principal, información de autenticación.
- Java.naming.security.Credentials, información de certificado.
- java.naming.security.protocol, nombre del protocolo de seguridad.
Regístrese con System.SetProperty. Si el programa no muestra las instrucciones, Java buscará el archivo jdni.properties en el classpath para completar el registro. JDNI.Properties Ejemplo:
java.naming.factory.initial = com.codeline.db.mockinitialContextFactory
Servicio de conexión
Después de registrarse, puede implementar la conexión de servicio. Para los servicios de nombres, comience con InitialContext, los servicios de directorio usan InitialDirTirtext. Implementan contexto y dirontext respectivamente. Estas dos interfaces corresponden a las interfaces de servicios de nombres y servicios de directorio, y también son las dos interfaces más importantes en JNDI.
Servicio de nombre de conexión:
System.SetProperty (context.initial_context_factory, "com.sun.jndi.fscontext.fscontextFactory"); InicialContext ctx = new InitialContext ();
Conectarse a los servicios de directorio:
Hashtable env = new Hashtable (); env.put (context.initial_context_factory, "com.sun.jndi.ldap.ldapctxfactory"); env.put (context.provider_url, "ldap: //myserver.com/"); env.put (context.security_authentication, "simple"); // El nombre de usuario requerido para iniciar sesión en el servidor LDAP es env.put (context.security_prudipal, "ldapuser"); // Iniciar sesión en LDAP La contraseña requerida por el servidor es env.put (context.security_credentials, "mypassword"); InitialDirText CTX = new InitialDircontext (env);
Proveedor de múltiples servicios: si la aplicación contiene múltiples proveedores de servicios, es ligeramente diferente cuando se conecta. Tome el servicio de nombre como ejemplo
Hashtable env = new Hashtable (); env.put (context.initial_context_factory, "com.sun.jndi.rmi.registry.registryContextFactory"); env.put (context.provider_url, "rmi: //myserver.com: 1099"); // Use diferentes constructores InitialContext CTX = new InitialContext (env);
Encontrar objetos
Ya sea que se trate de un servicio de nombre o un servicio de directorio, la búsqueda se utiliza para encontrar objetos. Además de usar String como parámetro, la búsqueda también puede usar la interfaz de nombre como parámetro.
Gravers gooder = (saludador) ctx.lookup ("sayhello"); Si desea obtener todos los nombres de objetos en el contexto, use LIS para devolver la lista NameClassPair. NameClasspair contiene nombre de objeto y nombre de clase de objeto. Si desea obtener la lista real de instancias de objetos, use ListBindings, que devuelve la lista de enlace. La vinculación es una subclase de NameclassPair, que contiene instancias de objetos.
- lista
NamingEnumeration list = ctx.list ("awt"); while (list.hasmore ()) {nameclasspair nc = (nameClasspair) list.next (); System.out.println (NC); } - Listbindings
NamingEnumeration Bindings = ctx.listbindings ("awt"); while (bindings.hasmore ()) {Binding bd = (vinculante) bindings.next (); System.out.println (bd.getName () + ":" + bd.getObject ()); }
Vinculación de objetos
- Agregue la unión usando BIND
Fruta fruta = fruta nueva ("naranja"); ctx.bind ("favorita", fruta); - Use Rebind para modificar el enlace
Fruta fruta = fruta nueva ("limón"); ctx.rebind ("favorito", fruta); - Use Unwind para eliminar los enlaces.
ctx.unbind ("favorito");
Cambiar el nombre del objeto
Use el cambio de nombre para cambiar el nombre de un objeto en el contexto
ctx.rename ("Report.txt", "Old_report.txt");- Las interfaces relacionadas con la obtención de atributos de atributos son atributos y atributos, que están en el paquete Javax.naming.Directory. Puede establecer el atributo del objeto a través del método getAttributes de DirContext, luego usar el método GET de atributos para obtener los atributos correspondientes y finalmente puede obtener el valor de atributo a través del método GET de atributo.
String dn = "uid = me, dc = myCompany, dc = com, ou = customer, o = examplepp"; Context user = (context) ctx.lookup (dn); // Obtener todos los atributos atributos attrs = user.getAttributes (""); Atributo test = attrs .get ("test"); Objeto testValue = test.get ();En el ejemplo anterior, se obtienen todos los atributos del usuario. En uso real, teniendo en cuenta el impacto del ancho de banda de la red, puede establecer la lista de atributos para obtener:
String reqd_attrs = new String [] {"Surname", "Inicials", "Título", "RFC822Mailalias"}; Atributos attrs = user.getAttributes ("", reqd_attrs);
Encontrar y filtrar
Use el método de búsqueda para completar.
public dirContext [] findUser (String Initials, String Surname, String Country, String Phone) {// Condiciones de construcción BASICATTRIBUTES Search_Attrs = new BasicAttributes (); search_attrs.put ("iniciales", iniciales); search_attrs.put ("Sn", incidente); search_attrs.put ("c", país); if (phone! = null) search_attrs.put ("PhoneNumber", teléfono); Resultados de NamingEnumeration = inicial_ctx.search ("ou = cliente, o = ejemplepp", search_attrs); LinkedList encontrado = new LinkedList (); while (results.hasmore ()) {SearchResults sr = (SearchResults) results.next (); Name de cadena = Sr.getName (); Objeto ctx = sr.getObject (); if ((ctx == null) ||! (ctx instanceOf dircontext)) encontrado.add (inicial_ctx.lookup (nombre)); más encontrado.Add (CTX); } Dircontext [] ret_val = new DirContext [Found.size ()]; encontrado.toarray (ret_val); return ret_val; }
Los principales métodos de filtrado de la interfaz DirContext:
1. Use cadenas de filtro
String reqd_attrs = new String [] {"cn", "uid", "rfc822mailalias"}; Resultados de NamingEnumeration = inicial_ctx.search ("ou = cliente, o = ejemplepp", search_attrs, reqd_attrs);
2. Use SearchControls para obtener más control
SearchControls ctrls = new SearchControls (); ctrls.setCountLimit (20); Ctrls.settimelimit (5000); ctrls.setsearchscope (SearchControls.subtree_scope); Resultados de NamingEnumeration = inicial_ctx.search ("cat = libros, ou = productos, o = ejemplepp", "title =*java*", ctrls); Modificar propiedades
Se realiza utilizando los métodos ModifyAttributes de DirContext e InitialDirText. El llamado proceso de modificación es en realidad construir primero la lista de atributos para ser modificados y luego enviar utilizando el método anterior. Cuando una propiedad contiene múltiples valores, es necesario incluir los valores no modificados de la propiedad, de lo contrario, el servidor eliminará esos valores si ya no son necesarios.
public void UpdateAddress (String DN, String Dirección, String Country, String Phone) {BasicAttributes mod_attrs = new BasicAttributes (); if (dirección! = null) mod_attrs.put ("dirección", dirección); if (country! = null) mod_attrs.put ("c", país); if (phone! = null) mod_attrs.put ("PhoneNumber", teléfono); if (mod_attrs.size ()! = 0) inicial_ctx.modifyattributes (dn, dircontext.replace_attribute, mod_attrs); } Usando ModificationItem, también puede realizar múltiples operaciones de modificación diferentes a la vez:
ModificaciónItem [] mod_items = nueva modificaciónItems [2]; Atributo correo electrónico = new BasicAttribute ("RFC822Mailalias", new_email); ModificationItem agero_mod = new ModificationItem (dircontext.add_attribute, correo electrónico); Atributo addr = new BasicAttribute ("dirección", dirección); Modificaciones ADDR_MOD = new ModificationItem (dircontext.replace_attribute, addr); mod_Items [0] = email_mod; mod_items [1] = addr_mod; inicial_ctx.modifyattributes (dn, mod_items); Crear un contexto
Use el método CreateSubContext para completar.
BasicAttributes attrs = new BasicAttributes (); attrs.put ("iniciales", iniciales); attrs.put ("sn", incidente); attrs.put ("rfc822mailalias", correo electrónico); if (dirección! = null) attrs.put ("dirección", dirección); if (country! = null) attrs.put ("c", país); if (phone! = null) attrs.put ("PhoneNumber", teléfono); inicial_ctx.createSubContext (dn, attrs);
Eliminar el contexto
Use el método DestroySubContext para completar.
inicial_ctx.destroySubContext (dn);
Ejemplo
Aquí hay otro ejemplo.
Configurar en Tomcat's conf/server.xml:
<Context Path = "/jndi"> <resource name = "bean/myBeanFactory" auth = "Container" type = "com.huawei.jndi.bean.mybean" factory = "org.apache.naming.factory.beanfactory" bar = "23"/> </contexto>
Se declara un componente en Tomcat anterior, y puede obtener este componente en el código:
intente {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 (); }Resumen: Configure el componente JNDI en TomCat y luego obtenga los componentes equipados en el código.
Las clases de implementación de JNDI de cada contenedor web son diferentes. Por ejemplo, en JBoss, la clase de disposición JNDI es org.jnp.interfaces.namingContextFactory, que es diferente de Tomcat.
Desde este punto de vista, el papel de JNDI es similar al de la inyección de dependencia de Spring. Sin embargo, a través de JNDI, es posible obtener componentes entre aplicaciones e incluso en dominios. Los componentes configurados en el servidor A se pueden obtener a través de JNDI en otro servidor B.
Spring también proporciona encapsulación de JNDI, que es más conveniente de usar. El siguiente es un ejemplo.
< clave = "java.naming.provider.url"> 10.137.96.212:18199 </prop> <prop syke = "java.naming.factory.url.pkgs"> org.jnp.interfaces: org.jboss.naming </prop> </props> </propiedad> </bean> <! id = "JMSConnectionFactory"> <Property Name = "JnDiTemplate" ref = "jnditemplate" /> <propiedad name = "jndiname" value = "topicConnectionFactory" /> < /bean>
Primero declare JNDITEMPLATE, configure la dirección de destino y las clases de aprovisionamiento de servicios JNDI. Luego, a través de JNDIObjectFactoryBean, puede obtener fácilmente los componentes JNDI y realizar la conversión de tipo.