When you build a complex object-oriented system you usually face the same problem: finding object instances in between all those thousand instances around in the system.

Figure 20. A bag with objects

Most complex systems provide a mechanism for looking-up objects, so you can find the instance you need easily.

JavaEE application servers, for instance, provide you with a JNDI Context that you can use to locate JDBC DataSources, JMS Topics and Queues and lots of other stuff. Similar mechanisms exist in other systems. JINI, for instance, contains a Service Lookup service, used to locate JINI services.

So all complex systems have some sort of "bag" you use to store objects, and have also some sort of "look-up" mechanism you use to find objects in the bag.

And so does NetBeans! it contains a "Lookup Library" you can use to look-up objects in bags. Let's see how.

NetBeans "object bags" are represented by the "org.openide.util.Lookup" class. Looking-up objects in such a bag is quite simple, all you need is know what type of object you need. The code is as follows:

import org.openide.util.Lookup;
import my.application.MyClass;
...
Lookup bag= ... 
...
MyClass myInstance = bag.lookup( MyClass.class ); 
...
Collection<MyClass> myInstances = bag.lookupAll( MyClass.class ); 

That's quote simple, isn't it?

If you now a little bit about SQL, and/or about JDBC, then you know you can submit a query to the database, and that the database in turn gives you a cursor (or a ResultSet).

NetBeans Lookups (i.e., NetBeans "bags") do also allow you to make queries and to obtain results for the queries.

Queries are represented by the "Lookup.Template" class, and results are represented by the "Lookup.Result" class. You use them like this:

import org.openide.util.Lookup;
...
Lookup bag = ... // the bag of objects
...
// A query that looks up instances extending "MyClass"...
Lookup.Template<MyClass> pattern = new Lookup.Template(MyClass.class); 
...
// The result of the query
Lookup.Result<MyClass> result = bolsa.lookup( pattern ); 
...
// Get all instances in the bag...
Collection<MyClass> objects = result.allInstances(); 
...
Collection<Lookup.Item<MyClass>> objects2 = result.allItems(); 

So we now know how to look-up stuff in our bags. We know how to retrieve objects by class. We can find a single instance of different instances, and we can use queries to obtain Lookup.Results. Good. Now, how do we create bags?

The simplest way to create a bag, a Lookup object, is to use the Lookups class (note there's a final "s" there). This is a utility class you use to create certain types of lookups. Let's see some examples (note there're many others out there, check the API!)

  // An immutable bag with one string
  Lookup bag1 = Lookups.singleton("Hello"); 

  // An immutable bag with two strings
  Lookup bag2 = Lookups.fixed("Hello", "World!"); 

  // An immutable bag without strings
  Lookup bag3 = Lookups.exclude( bag2, String.class );

  // Join two bags into a single one
  Lookup bag4 = new ProxyLookup( bag1, bag2 );

  // A bag that can change
  InstanceContent bagContents = new InstanceContent();
  Lookup bag5 = new AbstractLookup( bagContents );
  bagContents.add( "Hello" );
  bagContents.add( "World!");

  System.out.println( bag1.lookupAll( String.class ) );
  System.out.println( bag2.lookupAll( String.class ) );
  System.out.println( bag3.lookupAll( String.class ) );
  System.out.println( bag4.lookupAll( String.class ) );
  System.out.println( bag5.lookupAll( String.class ) );

    

  Lookup bolsaGlobal = Lookup.getDefault();

...
Lookup bolsa = Lookups.singleton( miobjeto );
...

...
Lookup bolsa = Lookups.fixed( "Hola", new Integer(3) );
...

  InstanceContent contenedor = new InstanceContent();
  contenedor.add( "Hola" );
  contenedor.remove( "Hola" );
  contenedor.add( new Integer(3) );

  Lookup bolsa = new AbstractLookup( contenedor );

  Lookup a = ...
  Lookup b = ...
  Lookup a_y_b = new ProxyLookup( a, b );

Figure 21. ¡Convierta su bolsa en un sombrero!

Imagínese que diseña una clase con una serie de propiedades (un entero, una cadena, etcétera). Imagínese ahora que, una vez la ha creado y publicado en un API, necesita cambiarla. ¿Qué sucederá con los usuarios de su API? Tendrán que cambiar su código, ¿verdad? ¡Una verdadera lata!

Lo que puede hacer es añadir una bolsa a su objeto, e ir poniendo en la bolsa diferentes propiedades. De este modo se pueden añadir objetos a la bolsa sin cambiar para nada su API. ¡Es como poder modificar las clases en tiempo de ejecución! ¡Es como sacarse un conejo del sombrero!

En esta sección hemos visto por encima la librería de Lookup de NetBeans. Hay muchísimo más. Por ejemplo, ¿sabía que podemos informarnos de cambios en el resultado de un Lookup? ¡Hay listeners que nos permiten hacer justamente eso! ¿sabía que puede construir sus propias bolsas? La verdad es que hay mucho que aprender (y que aprovechar).

Para más información puede consultarse el javadoc de la librería, o el API y, cómo no, las listas de correo de NetBeans.