Package oracle.dbtools.plugin.api.di
A javax.inject
compatible Dependency Injection (D.I.) framework.
Injecting Dependencies
A type can declare dependencies on other types via an @Inject
annotated constructor. Field and method based injection are *NOT* supported.
For example:
public class SomeService {
@Inject
SomeService(final SomeOtherType dependency) {
this.dependency = dependency;
}
public String doSomething(final String input) {
final String result = dependency.doSomethingElse(input);
return result;
}
private final SomeOtherType dependency;
}
Optional Dependencies
An injection site can be marked optional, by annotating it with the
Optional annotation, for
example:
public class SomeService {
@Inject
SomeService(@Optional final SomeDependency dependency) {
this.dependency = dependency;
}
...
}
If an injection site is optional and no instance of the requested dependency
can be located, then a null value is injected instead.
Multiple Dependencies
An injection site can inject multiple providers of a service, by injecting a
parameterized Iterable instance. For example:
public class SomeService {
@Inject
SomeService(final Iterable<ServiceType> providers) {
this.providers = providers;
}
...
}
If there are no providers of the requested service type available, then an
empty Iterable will be injected.
The provided Iterable instance is immutable.
Provider Injection
Instead of injecting a dependency directly an injection site can inject a
parameterized javax.inject.Provider instance, for example:
public class SomeService {
@Inject SomeService(final Provider<CyclicDependency> provider) {
this.provider = provider;
}
public void doSomething() {
final CyclicDependency dependency = provider.get();
// Use CyclicDependency
...
}
private final Provider<CyclicDependency> provider;
}
Available Dependencies
The set of out of the box services that the dependency injection runtime
provides are documented by the
AvailableDependencies type.
Advertising Services
A type can advertise to the dependency injection runtime that it is available
to provide one more dependencies (aka services) by using the
Provides annotation. Consult
the Provides documentation
for more information on how the set of services provided by a type is
inferred (or alternatively specified explicitly if necessary).
Dynamic Dependency Location
For some uses cases it can be useful to be able to discover dependencies at runtime rather than always having to inject them directly via an @Inject annotated constructor.
The InstanceLocator and
InstanceProvider types provide the means
to do these kinds of operations.
- Author:
- cdivilly
-
ClassDescriptionProvides methods for working with annotations.Annotations.Builder<T extends Annotation>Builds new
AnnotationinstancesProvides methods for working with annotations.Enumerates the publicly available services that can be injected into plugins via theInjectannotation on a type's constructor.InstanceProviderimplementation that defers resolving an instance untilDeferredInstanceProvider.get(),DeferredInstanceProvider.hasMultiple(),DeferredInstanceProvider.isUnsatisfied(), orDeferredInstanceProvider.iterator()is invokedIllegalStateExceptionspecialization raised when an attempt is made using aDeferredInstanceProviderto locate an instance of itself, which would cause a circular referenceA Module is a collection of related servicesAllows the application to dynamically obtain instances of services with a specified combination of required type and qualifiers.Providerspecialization that provides the ability to: determine if a provider implementation was found, viaInstanceProvider.isUnsatisfied()determine if there are multiple implementations found, viaInstanceProvider.isAmbiguous()Iterate over the available implementations, viaInstanceProvider.iterator()Stream through available implementations, viaInstanceProvider.stream()Locates concrete instances of typesBuildInstancesinstancesRepresents an individual instance of a qualified serviceInstantiator<T>Deprecated.Alternative techniques for accelerating dependency injection make the use of this interface redundantEnumerates the set ofDependencyInjectionModules that a givenDependencyInjectionModuledepends onOrders types based on theirPriorityannotations (if any)Represents the discovered matches for a call toInstanceLocator.select(TypeQualifier)Provides the capability to inject additional services and instances into a scope