Package javax.inject
Annotation Interface Scope
Identifies scope annotations. A scope annotation applies to a class
containing an injectable constructor and governs how the injector reuses
instances of the type. By default, if no scope annotation is present, the
injector creates an instance (by injecting the type's constructor), uses
the instance for one injection, and then forgets it. If a scope annotation
is present, the injector may retain the instance for possible reuse in a
later injection. If multiple threads can access a scoped instance, its
implementation should be thread safe. The implementation of the scope
itself is left up to the injector.
In the following example, the scope annotation @Singleton
ensures
that we only have one Log instance:
@Singleton class Log { void log(String message) { ... } }
The injector generates an error if it encounters more than one scope annotation on the same class or a scope annotation it doesn't support.
A scope annotation:
- is annotated with
@Scope
,@Retention(RUNTIME)
, and typically@Documented
. - should not have attributes.
- is typically not
@Inherited
, so scoping is orthogonal to implementation inheritance. - may have restricted usage if annotated with
@Target
. While this specification covers applying scopes to classes only, some injector configurations might use scope annotations in other places (on factory method results for example).
For example:
@java.lang.annotation.Documented @java.lang.annotation.Retention(RUNTIME) @javax.inject.Scope public @interface RequestScoped {}
Annotating scope annotations with @Scope
helps the injector
detect the case where a programmer used the scope annotation on a class but
forgot to configure the scope in the injector. A conservative injector
would generate an error rather than not apply a scope.
- See Also: