All Classes and Interfaces
Class
Description
Abstract deployment unit processors used to process
ComponentDescription instances.Class that provides common functionality required by processors that process environment information from deployment descriptors.
Superclass for EE annotation processors that attach their information to the EEClassDescription via
ClassAnnotationInformationFoundation for processors which binds EE platform common resources, to all EE module and comp naming contexts.
A helper class for security deployment processors
Represents a piece of component metadata
DeploymentUnitProcessor responsible for determining if property replacement should be
done on Jakarta Enterprise Beans annotations.The app client handler for jboss-all.xml
Processor that aggregates all module descriptions visible to the deployment in an EEApplicationClasses structure.
Processor that sets up application clients.
Deployment processor that deploys a naming context for the current application.
Deployment processor responsible for finding @AroundInvoke annotated methods in classes within a deployment.
EE related attachments.
EE related attachments.
A basic component implementation.
A service for creating a component.
An abstract base component instance.
ProfileParsingCompletionHandler that installs a default Jakarta Bean Validation extension and subsystem if the
profile included a legacy EE subsystem version but not Jakarta Bean Validation subsystem.A binding into JNDI.
An annotation information factory that simply returns true if the annotation is present
Class level information about the annotations present on a particular class.
Abstract factory that can produce a
ClassAnnotationInformationthrowaway utility class for traversing a class configuration from most general superclass down
Common contract for an EE component.
Class that represents an instance of a component client.
The construction parameter set passed in to an abstract component.
A configurator for components.
An exception relating to a problem with the creation of an EE component.
A factory for component creation which allows component behavior customization.
A description of a generic Jakarta EE component.
An instance of a Jakarta EE component.
A factory to create interceptors per ComponentInstance instance.
A factory to create interceptors that are tied to a component instance.
Exception indicating that a component receiving a method call has stopped.
A component's naming context operation mode.
Registry that can be used to create a fully injected class instance.
Service wrapper for a
Component which starts and stops the component instance.An injection source which injects a component based upon its type.
A component view.
The interface for a Jakarta Concurrency Implementation
Injection source that can be used to bind a potentially empty context
The configuration for a Context Service, which indicates if a context type should be cleared, propagated or unchanged.
The builder class.
The
DeploymentUnitProcessor which adds the EE subsystem default bindings configuration to EE module descriptions.The resource definition wrt EE default bindings configuration.
DeploymentUnitProcessor responsible for setting the default ear subdeployments isolation for each .ear
deployment unit.DependencyConfigurator<T extends org.jboss.msc.service.Service>
A configurator for a service dependency.
The environment as read from a deployment descriptor
Helper class for dealing with the
Attachments#RESOURCE_ROOT_TYPE attachment.Deployment descriptor that resolves interceptor methods defined in ejb-jar.xml that could not be resolved at
DD parse time.
DeploymentUnitProcessor responsible for determining if
property replacement should be done on EE spec descriptors.Utility class for working with method descriptors
The Java EE6 spec and Enterprise Beans 3.1 spec contradict each other on what the "application-name" semantics are.
Processor which ensures that subdeployments of an EAR all synchronize before the next phase.
Processor responsible for detecting and marking EAR file deployments.
A service that creates JACC permissions for an ear deployment
Deployment processor responsible for parsing the application.xml file of an ear.
Handles ear deployments
Deployment processor responsible for detecting EAR deployments and putting setting up the basic structure.
Processes Jakarta Enterprise Beans annotations and attaches them to the
EEModuleClassDescriptionAllows a deployment to get old of class descriptions from all sub deployments it has access to.
The capabilities provided by and required by this subsystem.
Cleans up references to EE structures in the deployment unit
A processor which sets up the default Jakarta EE permission set.
The jndi names for the default EE bindings.
Examines a deployment unit and its top level parent to check for any distinct-name that's configured in the
deployment descriptor(s) of the deployment units.
JBossAS domain extension used to initialize the ee subsystem handlers and associated classes.
Warning this class consists of generated code.
The description of a (possibly annotated) class in an EE module.
TODO: do we still need this?
Deployment processor responsible for creating a
EEModuleConfiguration from a EEModuleDescription and
populating it with component and class configurationsClass that is responsible for resolving name conflicts.
User: jpai
User: jpai
Handler for adding the ee subsystem.
Versions of the EE subsystem model
ResourceDefinition for the EE subsystem's root management resource.Handles the "write-attribute" operation for the EE subsystem.
Metadata for configurations contained in jboss-ejb-client.xml descriptor
A deployment unit processor which parses jboss-ejb-client.xml in top level deployments.
Processor that only runs for ear deployments where no application.xml is provided.
A description of an env-entry.
An injection of a fixed value.
A deployment processor that prepares the global directories that are going to be used as dependencies in a deployment.
This service does the required steps to add a directory as a deployment dependency and as an
ExternalModule.The resource definition for global-directory child resource in EE subsystem.
Service responsible creating a
GlobalDirectory which contains the information of a configured global directory.Dependency processor that adds modules defined in the global-modules section of
the configuration to all deployments.
AttributeDefinition implementation for the "global-modules" attribute.Processor responsible for binding java:comp/InAppClientContainer
Sets up dependencies for the next phase if initialize in order is set.
A simple EE-style namespace context selector which uses injected services for the contexts.
A configuration for an injection source.
A resolution context for the injection source.
An injection target field or method in a class.
Utility class for injection framework.
Processor responsible for binding java:comp/InstanceName
Processor that takes interceptor information from the class description and applies it to components
Post class loading description of an interceptor class.
A description of an
@Interceptor annotation value or its equivalent
deployment descriptor construct.Class that represents the environment entries of an interceptor, defined in the interceptors section
of ejb-jar.xml.
Class that maintains interceptor ordering for various interceptor chains
Marker enum that can be used to identify special types of invocations
A
DeploymentUnitProcessor for Jakarta Authorization policies.A service for Jakarta Authorization policies
Deployment processor which adds the Jakarta EE APIs to EE deployments
Sets and restores the
java: contextsDeployment processor responsible for finding @PostConstruct and @PreDestroy annotated methods.
A binding which gets its value from another JNDI binding.
Deployment unit processor responsible for scanning a deployment to find classes with
jakarta.annotation.ManagedBean annotations.Component descriptor for
jakarta.annotation.ManagedBean managed beans.User: jpai
Processor that only runs for ear deployments where no application.xml is provided.
Runtime stats from an executor.
Implementation of
InjectionSource responsible for finding a message destinationProcessor that resolves all message destinations.
Marker class used to set/get the metadata-complete status of the deployment.
Class which can turn a pre-runtime description of annotations into a runtime description.
Deployment processor that deploys a naming context for the current module.
Processor that sets up JNDI bindings that are owned by the module.
A configurator which adds interceptors to the component which establish the naming context.
An interceptor which imposes the given namespace context selector.
Container for an ordered list of object.
An invocation handler for a component proxy.
The foundation to create processors wrt deployment of classes annotated with EE Resource Definitions, as defined by EE.5.18.
Utility class to help handle resource definition annotation elements
Foundation for resource definition deployment descriptor processors.
The abstract InjectionSource for EE Resource Definitions.
Deployment processor responsible for analyzing each attached
ComponentDescription instance to configure
required resource injection configurations.A configuration for resource injection.
Represents an object that has a descriptor based JNDI environment.
Deployment processor that sets up env-entry, resource-ref and resource-env-ref bindings
DUP that adds the to the deployment, and adds the bean validation resolvers.
Runtime metadata about the annotations that are present on a particular class
Countdown tracker with capabilities similar to SE CountDownLatch, but allowing threads
to mark and unmark themselves as privileged.
A configuration of a component view.
A configurator for views.
A description of a view.
Factory that can be used to customize a views proxy creation
TODO: this needs to be thought through a bit more
A managed reference factory for a component view.
The bridge injector for binding views into JNDI.
Interface used to allow the proxy to support serialization.