All Classes and Interfaces
Class
Description
This class can be used as a starting point for those writing their own
ActiveDescriptor.
Skeleton implementation of injection binder with convenience methods for
binding definitions.
An ActiveDescriptor contains information about a Descriptor after it has been reified.
The active descriptor build is for building up a
non-reified ActiveDescriptor.
An active descriptor class that serves as an alias for another descriptor.
Supports inline instantiation of annotation type instances.
This interface is implemented by all services that use the
AOP Alliance Interceptor feature of HK2.
The binder is used in conjunction with the
ServiceLocatorUtilities.bind(org.glassfish.hk2.api.ServiceLocator, Binder...)
method in order to add (or remove) services to a ServiceLocator.Base binding builder (marker) interface.
HK2 injection binding utility methods.
This class is used to generate DescriptorBuilders to be used
as a simple mechanism to create a Filter or Descriptor.
When HK2 automatically analyzes a class to find the constructor, fields,
initializer methods and postConstruct and preDestroy methods it uses this
service to analyze the class.
This is a
PopulatorPostProcessor that adds an HK2Loader
based on a ClassLoader.This is an implementation of
DescriptorFileFinder that
uses a particular classloader in order to find descriptor files.CleanerFactory provides a Cleaner reference which is created on the first
reference to the CleanerFactory.
An implementation of this must be put into the system in order to
create contextual instances of services.
Used by several contexts for keeping the inputs of
Context.findOrCreate(ActiveDescriptor, ServiceHandle).This annotation is used by HK2 during automatic
class analysis to indicate that a class or
interface should be included in the list of
contracts for a service
This annotation is put on annotations that are used
to mark things as hk2 contracts.
An explicit list of contracts provided.
Indicates that a method should be customized.
Gives the type (and optional name) of a customizer service
to use when an unknown method on a bean interface is
encountered.
A Descriptor is a bean-like structure that describes a service
declaration in HK2.
This is an object that uses the Builder pattern
in order to generate a Descriptor (for binding) or
a Filter (for searching).
This is a simple implementation of the
DescriptorBuilderImplementations of this interface allow the customization of
how hk2 inhabitant files are found.
Returns information about the
InputStream
returned by DescriptorFileFinder.findDescriptorFiles()
that can be used to give better information when one of the
streams fails.The implementation of the descriptor itself, with the
bonus of being externalizable, and having writeable fields
This describes the type of descriptor
This enumeration determines how visibility of a descriptor
This post-processor removes duplicate descriptors from the
set of descriptors being added to the service registry.
The mode of the duplicate post processor
This exception is thrown when an idempotent filter of a
DynamicConfiguration object matches an existing descriptor
in the ServiceLocator
This class is used to add
Descriptors to a ServiceLocator
instance.A service that listens for dynamic configuration changes.
The dynamic configuration service is the source of
DynamicConfiguration
instances, which can be used to bind and unbind entities into the systemThis module can be used to enable exceptions to be
thrown from getService API when a descriptor throws
an exception during reification or other errors.
This class has information in it about the error that
has occurred
This interface should be implemented by those who wish to be
notified of error conditions that occur within HK2.
This enumeration describes the types of errors that might
occur
This interface should be implemented in order to provide
a factory for another type.
This is a convenience class that links together the factory descriptor as a factory
for another type and the factory as a service itself.
This is an implementation of FactoryDescriptors that can be
used by hk2 uses when creating descriptors that describe
a
FactoryThis object is used to search for items
in the service registry
This annotation can be put on interfaces in order
to provide the
GreedyResolver the default
implementation that should be bound when this
interface is injected and there are no other
implementationsThis is a greedy resolve that will add in any class
that has failed to be resolved.
Data structure with the handle and the service
Base class for HK2 defined checked exceptions
This is an interface that is also implemented by the
MethodInvocation object
passed to the invoke method of MethodInterceptor
and the ConstructorInvocation object
passed to the invoke method of ConstructorInterceptor.This class is responsible for loading classes, and different
implementations can be used for different descriptors.
This is an implementation of an
HK2Loader that uses
a given classloaderBase class for HK2 defined runtime exceptions
This is an implementation of
ErrorService that simply swallows
the exception caught.Immediate is a scope that operates like
Singleton scope, except that instances are created as soon as their
corresponding Descriptors are added.This service is advertised when the Immediate service is put into the
registry.
Implementations of this service will be called whenever
an Immediate scoped service fails
The implementation of the immediate context.
Filter only picks up local services
This module can be used to enable the
Immediate scope
feature.This filter can be used to limit the set of Descriptors
passed to the matches method.
Implementation created by the builder
Meta-annotation indicating that the annotation designates
a resident service of a
ServiceLocator.InheritableThread is a scope that operates like
PerThread scope, except with the caveat that
InheritableThread scoped services provide inheritance of values from parent
thread to child thread.This module can be used to enable the
InheritableThread scope
feature.An Injectee represents the point of injection.
This is a writeable version of the Injectee interface.
This annotation is placed on another annotation to indicate that the annotation
may be used to indicate an injection point
This class allows users to provide a custom injection target for
any annotation (including @Inject).
This object contains information about a lifecycle
event.
This describes the type of lifecycle events
that can happen in the system
This processor is called for certain events in the lifecycle of instances
of services.
Contains information about the caller of a
Factory.provide() methodThis service is used to get information about
the creation of a service from an
implementation of
Factory.This service is implemented in order to configure
interceptors on methods or constructors provided by
hk2 services.
This object can be injected rather than
Provider when
it is desired to iterate over more than one returned instance of the type.The JustInTimeInjectionResolver is called when an injection point
cannot find anything to inject.
This qualifier must be placed on any hk2 descriptor that can
receive messages.
This annotation marks a method of an annotation as providing a value that
should be placed into the metadata of a
Descriptor.This is used to describe the values to be given to
the method in the
ServiceLocator.assistedInject(Object, java.lang.reflect.Method, MethodParameter...)
methodAn implementation of
MethodParameter that
has immutable position and valueThis exception can contain multiple other exceptions.
Named service binding builder.
This is an implementation of the
Named annotation.This defines the operations that may be validated
Marker annotation indicating that an instance variable or method marked with
Inject
is not required to be present at run-time.Creates a filter that matches if at least one
of the sub-filters is a match.
PerLookup is the scope for objects that are created every time they are looked up.
PerThread is a scope that operates like
Singleton scope, except on a per-thread basis.This module can be used to enable the
PerThread scope
feature.Implementations of this interface are used to populate HK2
service locators from inhabitants files
This interface allows the customization of services read in from
an external source.
Classes implementing this interface register an interest in
being notified when the instance has been created and the
component is about to be place into commission.
Components implementing this interface registers an interest
in being notified when they are about to be decommissioned.
Scope annotations that are also marked with this
annotation are proxiable.
Every proxy generated by HK2 will implement this interface, which can be used to have finer
control on the behavior of the proxy
This annotation is used when automatically analyzing a class or a
{link
Factory.provide() method to indicate that the descriptor
either should or should use a proxy when being injected into a service
from the same scope.This annotation is used to provide the initial rank of
a service marked with
Service.This is an implementation of
ErrorService that simply rethrows
the exception caught.Scoped service binding builder.
Scoped and named service binding builder.
This annotation is placed on an injection point that is to be injected with the
ActiveDescriptor that was used
to create the instance.Annotation placed on classes that are to be automatically added
to an hk2
ServiceLocator.Service binding builder.
This service handle can be used to get a specific instance
of a service, and can be used to destroy that service as well
ServiceLocator is the registry for HK2 services
This factory can be used to create new named ServiceLocators
Tells the create method what to do if an existing ServiceLocator
with the given name exists
The implementation of the
ServiceLocatorFactory that looks
in the OSGi service registry or the META-INF/services for the implementation
to use.An implementation of this class can be placed in META-INF/services
in order to customize the creation of the ServiceLocator
This is added to the
ServiceLocatorFactory in order to listen on service locators
coming and going.The possible states in which a service locator can be in.
This is a set of useful utilities for working with
ServiceLocator.This cache can be used in some circumstances when there can be only one
of a service.
This is a filter that matches an exact descriptor
A filter that gets everything! w00t w00t!
When this annotation is placed on an abstract class the methods of
the class that are abstract will be generated into a subclass by
the hk2-metadata-generator along with an empty
Service annotationThis annotation is put onto one parameter of a method to indicate that
this method should be called whenever a Topic sends a message.
This service is used for publishing events to subscribers.
This service is responsible for distributing messages to Topic subscribers
Implementations of this interface can be added to a
DynamicConfiguration
in order to atomically participate in the changes being made to the
ServiceLocator.Supports inline instantiation of objects that represent parameterized
types with actual type parameters.
This annotation must go on a scope annotation in order to indicate
that no services from this scope may be proxied.
An injection point can be annotated with @Unqualified if
it should only be injected with services that have no qualifiers
at all
This is an implementation of
Unqualified.This exception will be found in a
MultiException when a class
has a dependency that should be satisfied but cannot be.This annotation is used when automatically analyzing a class or a
{link
Factory.provide() method to indicate that the descriptor
either should or should not use a proxy.This object contains information about the validation
point.
This service can be used to add validation points to Descriptors.
This method is called when it determined that a type that is
annotated with a Validating annotation is to be injected into
any other class.
This annotation is used when automatically analyzing a class or a
{link
Factory.provide() method to indicate that the descriptor
either should or should not have LOCAL visibility.