Here's a class I use for finding JavaSpaces:

/**
* JavaSpaceCache is a class that caches references to JavaSpace
* instances available from all reachable lookup service.
* <br>
* This source code is copyright 2006 by S P Engineering, Inc.
* Permission is granted for non-commercial use.
*
* @author Patrick May (pjm@spe.com)
* @author &copy; 2006 S P Engineering, Inc.  All rights reserved.
* @version 1
*/

package com.spe.jini.util;

import java.util.logging.Logger;

import net.jini.space.JavaSpace;

public class JavaSpaceCache
{
 private static Logger logger_
   = Logger.getLogger("com.spe.jini.util.JavaSpaceCache");

 private ServiceCache serviceCache_ = null;

 /**
  * The full constructor for the JavaSpaceCache class.
  *
  * @param groups The names of the Jini groups to which JavaSpace
  *               instances must belong.
  */
 public JavaSpaceCache(String[] groups)
   {
   serviceCache_ = new ServiceCache(groups,JavaSpace.class);
   }

 /**
  * The default constructor for the JavaSpaceCache class.
  */
 public JavaSpaceCache()
   {
   this(new String[] { "" });  // default to public group
   }

 /**
  * Return a JavaSpace from the cache.
  */
 public JavaSpace javaSpace()
   {
   JavaSpace javaSpace = (JavaSpace)serviceCache_.service();

   if (javaSpace == null)
     logger_.info("No JavaSpace found.");
   else
     logger_.info("JavaSpace found.");

   return javaSpace;
   }

 /**
  * A test harness for the JavaSpaceCache class.
  *
  * @param args The command line arguments passed in.
  */
 public static void main(String args[])
   {
   System.setSecurityManager(new java.rmi.RMISecurityManager());

   JavaSpaceCache cache = new JavaSpaceCache();
   JavaSpace space = null;
   while (space == null)
     {
     space = cache.javaSpace();
     if (space == null)
       {
       try { Thread.currentThread().sleep(5000); }
       catch (Exception e) { }
       }
     }
   }
}  // end JavaSpaceCache

JavaSpaceCache depends on ServiceCache for most of its functionality:

/**
* ServiceCache is a class that maintains a cache of Jini services.  Both
* lookup services discovered dynamically via multicast and those
* statically specified lookup services accessed via unicast can be used
* as sources of services.
* <br>
* A security manager such as RMISecurityManager must be in effect for
* this class to work.
* <br>
* This class is intended to be immutable, hence the lack of methods to
* change groups, locators, and service templates.
* <br>
* This source code is copyright 2006 by S P Engineering, Inc.
* Permission is granted for non-commercial use.
*
* @author Patrick May (pjm@spe.com)
* @author &copy; 2006 S P Engineering, Inc.  All rights reserved.
* @version 1
*/

package com.spe.jini.util;

import java.util.logging.Logger;

import net.jini.discovery.LookupDiscoveryManager;
import net.jini.discovery.DiscoveryGroupManagement;
import net.jini.discovery.DiscoveryListener;
import net.jini.discovery.DiscoveryEvent;
import net.jini.lookup.ServiceDiscoveryListener;
import net.jini.lookup.ServiceDiscoveryManager;
import net.jini.lookup.LookupCache;
import net.jini.lookup.ServiceItemFilter;
import net.jini.lookup.ServiceDiscoveryEvent;
import net.jini.core.discovery.LookupLocator;
import net.jini.core.lookup.ServiceRegistrar;
import net.jini.core.lookup.ServiceTemplate;
import net.jini.core.lookup.ServiceItem;
import net.jini.lease.LeaseRenewalManager;

public class ServiceCache
 implements DiscoveryListener, ServiceDiscoveryListener
{
 private static Logger logger_
   = Logger.getLogger("com.spe.jini.util.ServiceCache");

 private LookupDiscoveryManager lookupDiscoveryManager_ = null;
 private LeaseRenewalManager leaseRenewalManager_ = new LeaseRenewalManager();
 private ServiceDiscoveryManager serviceDiscoveryManager_ = null;
 private LookupCache lookupCache_ = null;

 /**
  * The full constructor for the ServiceCache class.
  *
  * @param groups The names of the Jini groups to which Lookup Services
  *               must belong.
  * @param locators Jini unicast Lookup Service locators.
  * @param template The ServiceTemplate that specifies the services of
  *                 interest.
  * @param filter The ServiceItemFilter that further specifies the
  *               services of interest.
  */
 public ServiceCache(String[] groups,
                     LookupLocator[] locators,
                     ServiceTemplate template,
                     ServiceItemFilter filter)
   {
   try
     {
     lookupDiscoveryManager_ = new LookupDiscoveryManager(groups,
                                                          locators,
                                                          this);
     serviceDiscoveryManager_
       = new ServiceDiscoveryManager(lookupDiscoveryManager_,
                                     leaseRenewalManager_);
     lookupCache_ = serviceDiscoveryManager_.createLookupCache(template,
                                                               filter,
                                                               this);

     if (groups != null)
       for (String group : groups)
         logger_.info("Group = " + group);
     else
       logger_.info("No groups found.");
     }
   catch (Exception e)
     {
     logger_.severe(e.getMessage());
     throw new JiniUtilityException(e);
     }
   }

 /**
  * A convenience constructor for the ServiceCache class.
  *
  * @param template The ServiceTemplate that specifies the services of
  *                 interest.
  */
 public ServiceCache(ServiceTemplate template)
   {
   this(DiscoveryGroupManagement.ALL_GROUPS,  // all groups, via multicast
        null,                                 // no unicast lookup servers
        template,
        null);                                // no service filter
   }

 /**
  * A convenience constructor for the ServiceCache class.
  *
  * @param groups The names of the Jini groups to which Lookup Services
  *               must belong.
  * @param serviceClass The class of the service of interest.
  */
 public ServiceCache(String[] groups,Class serviceClass)
   {
   this(groups,
        null,                                 // no unicast lookup servers
        new ServiceTemplate(null,new Class[] { serviceClass },null),
        null);                                // no service filter
   }

 /**
  * A convenience constructor for the ServiceCache class.
  *
  * @param serviceClass The class of the service of interest.
  */
 public ServiceCache(Class serviceClass)
   {
   this(DiscoveryGroupManagement.ALL_GROUPS,  // all groups, via multicast
        null,                                 // no unicast lookup servers
        new ServiceTemplate(null,new Class[] { serviceClass },null),
        null);                                // no service filter
   }

 /**
  * The default constructor for the ServiceCache class.
  */
 public ServiceCache()
   {
   this(DiscoveryGroupManagement.ALL_GROUPS,  // all groups, via multicast
        null,                                 // no unicast lookup servers
        new ServiceTemplate(null,null,null),  // all services
        null);                                // no service filter
   }

 /**
  * Called when a new lookup service is found.  Inherited from
  * DiscoveryListener.
  */
 public void discovered(DiscoveryEvent event)
   {
   logger_.info("Discovery event received.");

   ServiceTemplate template = new ServiceTemplate(null,null,null);
   ServiceRegistrar[] registrars = event.getRegistrars();

   for (ServiceRegistrar registrar : registrars)
     {
     try
       {
       logger_.info("Registrar discovered on "
                    + registrar.getLocator().getHost()
                    + ":"
                    + registrar.getLocator().getPort()
                    + ".");
       }
     catch (Exception e)
       { logger_.warning(e.getMessage()); }
     }
   }

 /**
  * Called when a lookup service is discarded.  Inherited from
  * DiscoveryListener.
  */
 public void discarded(DiscoveryEvent event) { }

 /**
  * Called when a service of interest is registered with one of the
  * cached lookup services.  Inherited from ServiceDiscoveryListener.
  */
 public void serviceAdded(ServiceDiscoveryEvent event)
   {
   ServiceItem item = event.getPostEventServiceItem();

   logger_.info("Service discovery event received:  "
                + item.service.getClass().getName()
                + "("
                + item.serviceID.toString()
                + ")");
   }

 /**
  * Called when a service of interest is changed within one of the
  * cached lookup services.  Inherited from ServiceDiscoveryListener.
  */
 public void serviceChanged(ServiceDiscoveryEvent event)
   {
   ServiceItem preEventItem = event.getPreEventServiceItem();
   ServiceItem postEventItem = event.getPostEventServiceItem();

   logger_.info("Service change event received:  "
                + preEventItem.service.getClass().getName()
                + "("
                + preEventItem.serviceID.toString()
                + ") to "
                + postEventItem.service.getClass().getName()
                + "("
                + postEventItem.serviceID.toString()
                + ")");
   }

 /**
  * Called when a service of interest is removed from one of the
  * cached lookup services.  Inherited from ServiceDiscoveryListener.
  */
 public void serviceRemoved(ServiceDiscoveryEvent event)
   {
   ServiceItem item = event.getPreEventServiceItem();

   logger_.info("Service removed event received:  "
                + item.service.getClass().getName()
                + "("
                + item.serviceID.toString()
                + ")");
   }

 /**
  * Find a service that passes the specified filter.
  *
  * @param filter The filter to apply to the services in the cache.
  */
 public Object service(ServiceItemFilter filter)
   {
   ServiceItem item = lookupCache_.lookup(filter);

   return (item == null) ? null : item.service;
   }

 /**
  * Find a service with the specified class.
  *
  * @param serviceClass The class of the service to find.
  */
 public Object service(final Class serviceClass)
   {
   return service(new ServiceItemFilter()
                    {
                    public boolean check(ServiceItem item)
                      {
                      return (item.service.getClass() == serviceClass);
                      }
                    });
   }

 /**
  * Find any service.  This is only useful if the ServiceCache instance
  * has been configured to only cache services of a single type.
  */
 public Object service()
   {
   return service(new ServiceItemFilter()
                    {
                    public boolean check(ServiceItem item)
                      {
                      return true;
                      }
                    });
   }
}  // end ServiceCache

Let me know if you have any problems with these.

Regards,

Patrick

------------------------------------------------------------------------
S P Engineering, Inc.    | The experts in large scale distributed OO
                        | systems design and implementation.
         pjm@spe.com    | (C++, Java, Common Lisp, Jini, CORBA, UML)