The SpaceModule should be given a ClassSpace representing the classes and resources to scan:
 
 
Guice.createInjector( new SpaceModule( new URLClassSpace( classloader ) ) );Reduce scanning time by using an
index or provide your own ClassFinder approach:
 
Guice.createInjector( new SpaceModule( new URLClassSpace( classloader ), BeanScanning.INDEX ) );
QualifiedTypeVisitor with QualifiedTypeBinder to find types annotated with @Named or other @Qualifiers and bind them as follows:
 
 BeanLocator uses to check type compatibility at lookup time:
 (This avoids the need to walk the type hierarchy and register bindings for each and every super-type, turning the injector graph to spaghetti.)
 @Named("example") public class MyTypeImpl implements MyType {
   // ...
 }
 If you use an empty @Named or a different @Qualifier annotation then Sisu will pick a canonical name based on the implementation type.
 
 
 Sometimes you need explicit typed bindings for external integration; you can list the types in a @Typed annotation or leave it empty to use the declared interfaces:
 
 @Named @Typed public class MyTypeImpl implements MyType {
   // ...
 }
 
 Default implementations can be indicated by using "default" as a binding name:
 
 @Named("default") public class MyTypeImpl implements MyType {
   // ...
 }
 
 or by starting the implementation name with "Default":
 
 @Named public class DefaultMyType implements MyType {
   // ...
 }
 
 Default components are bound without a qualifier and have a higher ranking than non-default components.
 
 
 @Named public class MyProvider implements Provider<MyType> {
   public MyType get() {
     // ...
   }
 }
 Use @Singleton to scope the provided binding(s) as a singleton:
 
 @Named @Singleton public class MyProvider implements Provider<MyType> {
   public MyType get() {
     // ...
   }
 }
 Note: this is different to the normal Guice behaviour where singleton only applies to the provider itself.
 
 
 @Named public class MyModule extends AbstractModule {
   @Override protected void configure() {
     // ...
   }
 }
 
 Mediators are registered with the BeanLocator:
 
 @Named public class MyMediator implements Mediator<Named, MyType, MyWatcher> {
   public void add( BeanEntry<Named, MyType> entry, MyWatcher watcher ) throws Exception {
     // ...
   }
 
   public void remove( BeanEntry<Named, MyType> entry, MyWatcher watcher ) throws Exception {
     // ...
   }
 }
  | AnnotationVisitor | Something that can visit annotation declarations. | 
| ClassFinder | Finds (and optionally filters) Class resources from ClassSpaces. | 
| ClassSpace | Represents an abstract collection of related classes and resources. | 
| ClassVisitor | Something that can visit class definitions. | 
| QualifiedTypeListener | Listens for types annotated with Qualifier annotations. | 
| SpaceModule.Strategy | Visitor strategy. | 
| SpaceVisitor | Something that can visit ClassSpaces. | 
| BundleClassSpace | ClassSpacebacked by a strongly-referenced Bundle. | 
| CloningClassSpace | ClassSpacethat can create multiple (deferred) copies of the same implementation type. | 
| DefaultClassFinder | ClassFinderthat finds Class resources under a given package name. | 
| IndexedClassFinder | ClassFinderthat finds Class resources listed in the named index. | 
| LoadedClass<T> | Pseudo DeferredClassbacked by an already loaded Class. | 
| QualifiedTypeBinder | QualifiedTypeListenerthat installs Modules, registersMediators, and binds types. | 
| QualifiedTypeVisitor | SpaceVisitorthat reports types annotated with Qualifier annotations. | 
| SisuIndex | Command-line utility that generates a qualified class index for a space-separated list of JARs. | 
| SisuIndexAPT6 | Java 6 Annotation Processor that generates a qualified class index for the current build. | 
| SpaceModule | Guice Module that automatically binds types annotated with Qualifier annotations. | 
| SpaceScanner | Makes a SpaceVisitorvisit aClassSpace; can be directed by an optionalClassFinder. | 
| Streams | Utility methods for dealing with streams. | 
| URLClassSpace | ClassSpacebacked by a strongly-referenced ClassLoader and a URL class path. | 
| BeanScanning | Common techniques for discovering bean implementations. |