Package org.eclipse.sisu.space
Customizable scanning of bean implementations.
The default visitor strategy is to use
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 @Qualifier
s and bind them as follows:
Components
Any qualified components are bound using a special "wildcard" key that theBeanLocator
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 qualifiedMediator
s 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 { // ... } }
-
Interface Summary Interface Description AnnotationVisitor Something that can visit annotation declarations.ClassFinder Finds (and optionally filters)Class
resources fromClassSpace
s.ClassSpace Represents an abstract collection of related classes and resources.ClassVisitor Something that can visit class definitions.QualifiedTypeListener Listens for types annotated withQualifier
annotations.SpaceModule.Strategy Visitor strategy.SpaceVisitor Something that can visitClassSpace
s. -
Class Summary Class Description AbstractDeferredClass<T> Abstract combination ofDeferredClass
andDeferredProvider
.AbstractSisuIndex Skeleton class that generates a qualified class index.BundleClassSpace ClassSpace
backed by a strongly-referencedBundle
.BundleClassSpace.ChainedEnumeration<T> Chains a series ofEnumeration
s together to look like a singleEnumeration
.CloningClassSpace ClassSpace
that can create multiple (deferred) copies of the same implementation type.CloningClassSpace.CloningClassLoader ClassLoader
that can define multiple copies of the same implementation type.DefaultClassFinder ClassFinder
that findsClass
resources under a given package name.FileEntryIterator Iterator
that iterates over named entries beneath a file-system directory.IndexedClassFinder ClassFinder
that findsClass
resources listed in the named index.LoadedClass<T> PseudoDeferredClass
backed by an already loadedClass
.MediationListener InjectionListener
that listens for mediated watchers and registers them with theBeanLocator
.MediationListener.Mediation<Q extends java.lang.annotation.Annotation,T,W> Record containing all the necessary details about a mediated watcher.NamedClass<T> DeferredClass
representing a named class from aClassSpace
.QualifiedTypeBinder QualifiedTypeVisitor SpaceVisitor
that reports types annotated withQualifier
annotations.QualifierCache CachingClassVisitor
that maintains a map of knownQualifier
annotations.ResourceEnumeration Enumeration
of resources found by scanning JARs and directories.ResourceEnumeration.NestedJarConnection CustomURLConnection
that can access JARs nested inside an arbitrary resource.ResourceEnumeration.NestedJarHandler CustomURLStreamHandler
that can stream JARs nested inside an arbitrary resource.SisuIndex Command-line utility that generates a qualified class index for a space-separated list of JARs.SisuIndexAPT6 Java 6 AnnotationProcessor
that generates a qualified class index for the current build.SpaceModule GuiceModule
that automatically binds types annotated withQualifier
annotations.SpaceModule.RecordedElements SpaceScanner Streams Utility methods for dealing with streams.URLClassSpace WildcardKey BindingKey
for implementations that act as "wild-cards", meaning they match against any assignable type.WildcardKey.QualifiedImpl Pseudo-Annotation
that can wrap any implementation type as aQualifier
.ZipEntryIterator Iterator
that iterates over named entries inside JAR or ZIP resources. -
Enum Summary Enum Description BeanScanning Common techniques for discovering bean implementations.GlobberStrategy Enumerates various optimized filename globbing strategies. -
Annotation Types Summary Annotation Type Description WildcardKey.Qualified Qualifier
that captures a qualified implementation type.