Nombres
Los nombres se explican más extensamente en la lección
¿Qué es un nombre?. Esta lección
explica en general cómo un desarrollador de proveedores de servicio debería tratar los
parámetros string y los nombres estructurados de los métodos del interface
Context y sus subinterfaces.
Nombres String
Un nombre String es un
nombre mixto.
Incluso si la implementación de contexto que estamos escribiendo no va a soportar federación,
seguir esta regla es una buena idea para que los usuarios de nuestro proveedor no tengan que
tratar a nuesto proveedor de forma diferente en este aspecto.
Siguiendo esta regla, escribiremos las sobrecargas del interface
Context y sus subinterfaces que aceptan un nombre
java.lang.String como una simple envoltura alrededor de las
sobrecargas que aceptan un
Name. Como ejemplo, aquí tenemos una definición de implementación
de contexto de
Context.lookup():
Object lookup(String name) throws NamingException {
return lookup(new CompositeName(name));
}
Nombres Mixtos
Un nombre estructurado está representado por un objeto que implementa el interface
Name. Puede representar un
nombre mixto o un
nombre compuesto. En
cualquier caso, el parámetro nombre pertenece al llamador y no deberíamos modificarlo (puedes
ver más detalles en la página
Parámetros y Valores de Retorno).
Un nombre mixto está representado por un ejemplar de
CompositeName. Si nuestra implementación de contexto no soporta
federación, entonces puede crear nombres mixtos de dos formas. La más simple es para la
implementación de contexto que lanza una
InvalidNameException cuando recibe un
CompositeName. Sin embargo, esta aproximación es Draconicana en
que impide que la aplciación pase un CompositeName, incluso
si el CompositeName contiene sólo componentes que pertencen
al espacio de nombres de la implementación de contexto. Una aproximación más comprometida es
para la implementación de contexto que sólo acepta CompositeNames
que contienen componentes que pertenecen a su espacio de nombres. En esta aproximación, la
implementación extrae los componentes que pertenecen a su espacio de nombres, y para los
componentes que no pertenece, lanza una InvalidNameException.
Si nuestra implementación de contexto soporta federación, debería extraer los componentes del
CompositeName que pertenecen a su espacio de nombres. Para
componentes que no le pertenecen debería resolver sus propios componentes y pasar los
componentes restantes al nns. (Se darán más detalles sobre esto en la
lección Añadir Soporte de Federación.)
Si la implementación sólo recibe componentes de su espacio de nombre, debería procesar la
operación solicitada.
Aquí tenemos un pseudo-código que ilustra el caso no-federado:
Object lookup(Name name) throws NamingException {
if (name instanceof CompositeName) {
{mine, theirs} = splitName(name);
if (theirs.size() == 0) {
// Find in internal tables
return impl.get(mine);
} else {
// Don't support federation
throw new InvalidNameException(name.toString() +
" has more components than I can handle");
}
} else {
// Process the compound name
...
}
}
Nombres Compuestos
Un nombre compuesto puede estar representado por cualquier implementación del interface
Name excepto CompositeName
o una de sus subclases. La forma más sencilla, aunque no la más eficiente, de hacer que una
implementación de contexto acepta un nombre compuesto es convertirlo en un nombre mixto.
Aquí tenemos un ejemplo que mapea un nombre compuesto en un nombre mixto de un sólo componente:
Object lookup(Name name) throws NamingException {
if (name instanceof CompositeName) {
// Process composite name
...
} else {
// Process compound name; turn it into single-component CompositeName
return lookup(new CompositeName().add(name.toString()));
}
}
Esta es la solución más general. Normalmente una implementación de contexto puede hacer esto
mucho más eficientemente usando directametne la forma pre-analizada
(ejemplar de Name) o el nombre compuesto "stringified". Por
ejemplo, una implementación podría usar el nombre compuesto "stringified" como una clave para
una tabla interna.
Tutoriales
