Package org.eclipse.sisu.space

package org.eclipse.sisu.space
Customizable scanning of bean implementations.

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 ) );
The default visitor strategy is to use QualifiedTypeVisitor with QualifiedTypeBinder to find types annotated with @Named or other @Qualifiers and bind them as follows:

Components

Any qualified components are bound using a special "wildcard" key that the 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.

Providers

Any qualified providers are bound using the same binding heuristics as 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.

Modules

Any qualified modules are are installed using the current binder: 
@Named public class MyModule extends AbstractModule {
  @Override protected void configure() {
    // ...
  }
}

Mediators

Any qualified 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 {
    // ...
  }
}