Package org.eclipse.sisu.space

Customizable scanning of bean implementations.

See: Description

Interface Summary

Interface	Description
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.

Class Summary

Class	Description
BundleClassSpace	ClassSpace backed by a strongly-referenced Bundle.
CloningClassSpace	ClassSpace that can create multiple (deferred) copies of the same implementation type.
DefaultClassFinder	ClassFinder that finds Class resources under a given package name.
IndexedClassFinder	ClassFinder that finds Class resources listed in the named index.
LoadedClass<T>	Pseudo DeferredClass backed by an already loaded Class.
QualifiedTypeBinder	QualifiedTypeListener that installs Modules, registers Mediators, and binds types.
QualifiedTypeVisitor	SpaceVisitor that 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 SpaceVisitor visit a ClassSpace; can be directed by an optional ClassFinder.
Streams	Utility methods for dealing with streams.
URLClassSpace	ClassSpace backed by a strongly-referenced ClassLoader and a URL class path.

Enum Summary

Enum	Description
BeanScanning	Common techniques for discovering bean implementations.

Package org.eclipse.sisu.space Description

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