 |
Añadir una dirección | Buscador | Cursos | Artículos | Foros | Formación |
 |
 |
Sistema de Nombrado en Java (JNDI) [Parte I] |
|
En esta página:
Operaciones Híbridas de Nombrado y Directorio
La lección Conceptos de nombrado explicó cómo podemos usar bind(), rebind(), y createSubcontext() en el interface Context para crear uniones y subcontextos. El interface DirContext contiene versiones sobrecargadas de estos métodos que aceptan atributos.
Podemos usar estos métodos de DirContext para asociar atributos con el objeto en el momento en que la unión o el subcontexto son añadidos al espacio de nombres. Por ejemplo, podríamos crear un objeto Persona y unirlo al espacio de nombres y en ese mismo momento asociarle atributos sobre ese objeto Persona.
| Antes de continuar: Los ejemplos de esta lección requieren que hagamos adiciones al esquema. Podemos desactivar el chequeo de esquemas del servidor LDAP o añadirle al servidor el esquema que acompaña a este tutorial. Estas dos tareas son típicas de un administrador de servidor de directorios. Puedes ver la lección Preparaciones. |
Crear un Contexto que tiene Atributos
Para crear un contexto que tiene atributos, le suministramos a DirContext.createSubcontext() el nombre del contexto que queremos crear y sus atributos.
// Create attributes to be associated with the new context
Attributes attrs = new BasicAttributes(true); // case-ignore
Attribute objclass = new BasicAttribute("objectclass");
objclass.add("top");
objclass.add("extensibleObject");
attrs.put(objclass);
// Create the context
Context result = ctx.createSubcontext("cn=Fruits", attrs);
Este ejemplo crea un nuevo contexto llamado "cn=Fruits" que tiene un atributo "objectclass" con dos valores, "top" y "extensibleObject", en el contexto ctx.
Si listamos el contexto ctx, veremos que ahora contiene una entrada para "cn=Fruits".
# java Create ou=Groups: javax.naming.directory.DirContext ou=People: javax.naming.directory.DirContext cn=Fruits: javax.naming.directory.DirContext
Añadir una Unión que Tiene Atributos
Se usa DirContext.bind() para añadir una unión que tiene atributos a un contexto. Acepta como argumentos el nombre del objeto, el objeto a unir y un conjunto de atributos.
// Create the object to be bound
Fruit fruit = new Fruit("orange");
// Create attributes to be associated with the object
Attributes attrs = new BasicAttributes(true); // case-ignore
Attribute objclass = new BasicAttribute("objectclass");
objclass.add("top");
objclass.add("extensibleObject");
attrs.put(objclass);
attrs.put("color", "orange");
attrs.put("flavor", "sweet");
// Perform bind
ctx.bind("cn=favorite, cn=Fruits", fruit, attrs);
Este ejemplo crea un objeto de la clase Fruit y lo une al nombre "cn=favorite" dentro del contexto "cn=Fruits", relativo a ctx. Esta unión tiene tres atributos: "objectclass", "color", y "flavor"). Si después buscamos el nombre "cn=favorite, cn=Fruits" en ctx, obtendremos el objeto fruit. Si obtenemos los atributos de "cn=favorite, cn=Fruits", obtendríamos aquellos atributos con los que se creó el objeto. Aquí tenemos un ejemplo de la salida.
# java Bind orange attribute: flavor value: sweet attribute: color value: orange attribute: objectclass value: top value: extensibleObject value: javaObject value: javaNamingReference attribute: javaclassname value: Fruit attribute: javafactory value: FruitFactory attribute: javareferenceaddress value: #0#fruit#orange attribute: cn value: favorite
Los atributos extras y los valores de los atributos mostrados aquí se usan para almacenar información sobre el objeto (fruit). Estos atributos extras se explican en más detalle en la sección Objetos Java y el Directorio.
Si ejecutaramos este ejemplo dos veces, la segunda vez fallaría y obtendríamos una NameAlreadyBoundException.
Esto es porque, el nombre "cn=favorite" ya está unido en el contexto "cn=Fruits". Para que el segundo intento tenga éxito, deberíamos usar rebind().
Reemplaar Uniones que tienen Atributos
Se usa DirContext.rebind() para añadir o reemplazar una unión y sus atributos. Acepta los mismos argumentos que bind(). Sin embargo, la semántica de rebind() requiere que el nombre ya esté unido, entonces los desune y lo vuelve a unir al objeto dado con sus atributos.
// Create the object to be bound
Fruit fruit = new Fruit("lemon");
// Create attributes to be associated with the object
Attributes attrs = new BasicAttributes(true); // case-ignore
Attribute objclass = new BasicAttribute("objectclass");
objclass.add("top");
objclass.add("extensibleObject");
attrs.put(objclass);
attrs.put("color", "yellow");
attrs.put("flavor", "sour");
// Perform bind
ctx.rebind("cn=favorite, cn=Fruits", fruit, attrs);
Cuando ejecutamos este ejemplo, reemplaza la unión que se creó con el ejemplo bind().
# java Rebind lemon attribute: flavor value: sour attribute: color value: yellow attribute: objectclass value: top value: extensibleObject value: javaObject value: javaNamingReference attribute: javaclassname value: Fruit attribute: javafactory value: FruitFactory attribute: javareferenceaddress value: #0#fruit#lemon attribute: cn value: favorite
|
|
|
| Principio Página |
|
© 1999-2002, Programación en castellano, s.l. Contacto - Datos legales ReD Internet: Hospedaje Web | envio sms gratis | Salvapantallas | Fondos de Escritorio, famosas | melodias moviles gratis| Gratis |