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
Tutoriales
