All Classes and Interfaces
Class
Description
Exception indicating that the result of a task cannot be retrieved
because the task failed to run for some reason other than being cancelled.
An exception that may be thrown by event listeners to terminate the
processing of the current event.
The AbstractBatchlet provides default
implementations of less commonly implemented methods.
The AbstractCheckpointAlgorithm provides default
implementations of less commonly implemented
methods.
The AbstractChunkListener provides default
implementations of less commonly implemented methods.
AbstractClearableCredential contains behavior common to
CredentialThe AbstractItemProcessListener provides default
implementations of less commonly implemented methods.
The AbstractItemReader provides default implementations
of less commonly implemented methods.
The AbstractItemReadListener provides default
implementations of less commonly implemented methods.
The AbstractItemWriteListener provides default
implementations of less commonly implemented methods.
The AbstractItemWriter provides default implementations
of not commonly implemented methods.
The AbstractJobListener provides default
implementations of less commonly implemented methods.
Abstract skeleton implementation of a
MultivaluedMap that is backed
by a [key, multi-value] store represented as a Map<K, List<V>>.The AbstractPartitionAnalyzer provides default
implementations of less commonly implemented methods.
The AbstractBatchlet provides default
implementations of less commonly implemented methods.
The
AbstractQuery interface defines functionality that is common
to both top-level queries and subqueries.The AbstractStepListener provides default
implementations of less commonly implemented methods.
Used to specify an access type to be applied to an entity class,
mapped superclass, or embeddable class, or to a specific attribute
of such a class.
An AccessLocalException is thrown to indicate that the caller does not
have permission to call the method.
Specifies the amount of time in a given time unit that a concurrent
access attempt should block before timing out.
Used with the
Access annotation to specify an access
type to be applied to an entity class, mapped superclass, or
embeddable class, or to a specific attribute of such a class.An
ActionEvent represents the
activation of a user interface component (such as a UICommand).A listener interface for
receiving
ActionEvents.Provides a simple implementation of
ActionListener that can be subclassed by developers wishing to
provide specialized behavior to an existing ActionListener
instance.ActionSource is an interface that may be implemented
by any concrete
UIComponent that wishes to be a source of
ActionEvents, including the ability to invoke application
actions via the default ActionListener mechanism.ActionSource2 extends
ActionSource and
provides a JavaBeans property analogous to the "action"
property on ActionSource.A VDL handler that exposes
ActionListener to a page author.A marker interface for VDL tags that
represent
<composite:actionSource/> for use by the
composite component page author.The container provides a built in interceptor that may be used to annotate classes and methods to indicate
that a request context should be activated when this method is invoked.
Designates a JavaBean as an
ActivationSpec.Used to provide information to the deployer about the configuration of
a message driven bean in its operational environment.
This interface serves as a marker.
This abstract class models the addresses in a message.
The exception thrown when a wrongly formatted address is encountered.
This abstract class implements string comparisons for Message
addresses.
This class implements Message Address comparisons.
Designates a JavaBean as an administered object.Administered objects are
specific to a messaging style or message provider.
Annotation used to define a Connector administered object to be
registered in JNDI.
Declares one or more
AdministeredObjectDefinition
annotations.
The event type of the second event fired by the container when it has fully completed the bean discovery process, validated
that there are no definition errors relating to the discovered beans, and registered
Bean
and ObserverMethod objects for the discovered beans, but before detecting deployment
problems.Designate a stateful session bean method to receive the after begin
session synchronization callback.
Designate a stateful session bean method to receive the after completion
session synchronization callback.
The event type of the third event fired by the container after it has validated that there are no deployment problems and
before creating contexts or processing requests.
This event type is thrown by the container after type discovery is complete.
An instance of this class
is added as a
ClientBehavior to a component using the ClientBehaviorHolder.addClientBehavior(java.lang.String, javax.faces.component.behavior.ClientBehavior)
contract that components implement.AjaxBehaviorEvent
represents the component behavior specific to
Ajax).By implementing this class, an object
indicates that it is a listener for one or more kinds of
BehaviorEvents.
Provides an operation for obtaining and destroying contextual instances with a particular scope of any contextual type.
Specifies that a bean is an alternative.
Supports inline instantiation of the
Alternative annotation.
Indicates that multiple beans match a certain combination of required type and required qualifiers and are eligible for
injection into a certain class.
This class implements the logical AND operator on individual
SearchTerms.
Represents a Java program element that can be annotated.
Represents a callable member of a Java type.
Represents a constructor of a Java class.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedConstructor
Represents a field of a Java class.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedField
Represents a member of a Java type.
Represents a method of a Java type.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedMethod
Represents a parameter of a method or constructor.
This interface is part of the
AnnotatedTypeConfigurator SPI and helps defining an AnnotatedParameter
Represents a Java class or interface.
This API is a helper to configure a new
AnnotatedType instance.
Supports inline instantiation of annotation type instances.
The built-in qualifier type.
Supports inline instantiation of the
Any qualifier.Application represents a
per-web-application singleton object where applications based on
JavaServer Faces (or implementations wishing to provide extended
functionality) can register application-wide singletons that provide
functionality required by JavaServer Faces.
Defines the components of a JAX-RS application and supplies additional
meta-data.
This class defines a
java.util.ServiceLoader
service which enables programmatic configuration of the JSF runtime using the existing
Application Configuration Resources schema.Applied to an exception to denote that it is an application exception
and should be reported to the client directly (i.e., unwrapped).
ApplicationFactory is a
factory object that creates
(if needed) and returns
Application instances.The presence of this annotation (along
with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getApplicationMap() to be
injected as the value of that field.Identifies the application path that serves as the base URI
for all resource URIs provided by
Path.
Specifies that a bean is application scoped.
Deprecated.
Supports inline instantiation of the
ApplicationScoped annotation.An
ApplicationServerInternalException is thrown
by an application
server to indicate error conditions specific to an application server.Provides a simple implementation of
Application that can be subclassed by developers wishing
to provide specialized behavior to an existing Application instance.Designates an interceptor method that receives a callback when
the target class constructor is invoked.
Defines an interceptor method that interposes on business methods.
Defines an interceptor method that interposes on timeout methods.
ArrayDataModel is a convenience implementation of
DataModel that wraps an array of Java objects.Defines property resolution behavior on arrays.
The annotated element must be false.
Defines several
AssertFalse annotations on the same element.The annotated element must be true.
Defines several
AssertTrue annotations on the same element.Used to override a mapping for an entity relationship.
Used to override mappings of multiple relationship properties or fields.
Class representing the execution context for an asynchronous operation
that was initiated on a ServletRequest.
Event that gets fired when the asynchronous operation initiated on a
ServletRequest (via a call to
ServletRequest.startAsync() or
ServletRequest.startAsync(ServletRequest, ServletResponse))
has completed, timed out, or produced an error.Used to mark a session bean method as an asynchronous method or to designate all
business methods of a session bean class as asynchronous.
Uniform interface for asynchronous invocation of HTTP methods.
Listener that will be notified in the event that an asynchronous
operation initiated on a ServletRequest to which the listener had been
added has completed, timed out, or resulted in an error.
An injectable JAX-RS asynchronous response that provides means for asynchronous server side
response processing.
Wraps the result of an asynchronous method call as a
Future
object, preserving compatability with the business interface signature.The
abstract base interface for a
handler representing an attached object in a VDL page.
Within the declaration of a
composite component, an
AttachedObjectTarget
allows the composite component author to expose the
semantics of an inner component to the page author without
exposing the rendering or implementation details of the inner
component.Represents an attribute of a Java type.
A class that implements this interface can be used to convert
entity attribute state into database column representation
and back again.
An interface that allows other code
to identify FaceletHandlers that correspond to component attributes.
Represents an attribute node of an entity graph.
Used to override the mapping of a
Basic (whether
explicit or default) property or field or Id property or
field.Used to override mappings of multiple properties or fields.
Deprecated.
The Faces implementation must now provide the
implementation for this class.
This interface defines the common functionality implemented by
Authentication context configuration objects.
This class is used to obtain
AuthConfigProvider objects
that can be used to obtain authentication context configuration objects,
that is, ClientAuthConfig and ServerAuthConfig
objects.Represents the layer identifier, application context identifier,
and description components of an AuthConfigProvider registration at the
factory.
This interface is implemented by objects that can be used to obtain
authentication context configuration objects, that is,
ClientAuthConfig or ServerAuthConfig objects.A generic authentication exception.
This exception is thrown when the connect method on a Store or
Transport object fails due to an authentication failure (e.g.,
bad user name or password).
An enumerated type that represents the various interfaces
that a resource adapter may support for the representation
of the credentials.
Parameters that are provided along with an authentication request.
The AuthenticationStatus is used as a return value by primarily
the
HttpAuthenticationMechanism to indicate the result (status)
of the authentication process.The class Authenticator represents an object that knows how to obtain
authentication for a network connection.
A generic authentication exception.
The AuthStatus class is used to represent return values from Authentication
modules and Authentication Contexts.
The AutoApplySession annotation provides an application the ability to declaratively designate
that an authentication mechanism uses the
javax.servlet.http.registerSession
and auto applies this for every request.A runtime exception indicating a
bad client request.The simplest type of mapping to a database column.
BasicAuthenticationCredential extends UsernamePasswordCredential
to represent credentials used by HTTP Basic Authentication.Annotation used to define a container authentication mechanism that implements
the HTTP basic access authentication protocol as defined by the Servlet spec (13.6.1)
and make that implementation available as an enabled CDI bean.
Instances of the type
BasicType represent basic types (including
temporal and enumerated types).A batchlet is type of batch step
that can be used for any type of
background processing that does not
explicitly call for a chunk oriented
approach.
Annotation used by batch artifacts to declare a
field which is injectable via a JSL-defined value
(possibly leveraging Job XML substitutions).
BatchRuntime represents the JSR 352 Batch Runtime.
This is the common base class for all of the RuntimeException(s) thrown
by the
JobOperator API methods to its callers.BatchStatus enum defines the batch status values
possible for a job.
Represents an enabled bean.
The BeanAttributes interface exposes the basic attributes of a bean.
This API is an helper to configure a new
BeanAttributes instance.This API is an helper to configure a new
Bean instance.Describes a constrained Java Bean and the constraints associated to it.
Defines property resolution behavior on objects using the JavaBeans
component architecture.
Allows a portable extension to interact directly with the container.
An
ELResolver for resolving user or container managed beans.Resolves a bean by its known name.
The annotation that may be used to inject custom JAX-RS "parameter aggregator" value object
into a resource class field, property or resource method parameter.
A Validator that delegates
validation of the bean property to the Bean Validation API.
This event type is thrown by the container before the bean discovery process begins.
Designate a stateful session bean method to receive the before completion
session synchronization callback.
An event with this qualifier is fired when a context is about to be destroyed, i.e.
Supports inline instantiation of the
BeforeDestroyed qualifier.
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
The Behavior interface is
the root API of the component behavior model.
BehaviorBase is a
convenience base class that provides a default implementation of the
Behavior contract.Convey the id of a behavior declared in
a view.
BehaviorEvent
is the event that can be generated from component
Behavior.The
FaceletHandler that
corresponds to attached objects that represent an instance of ClientBehavior that must be added to
the parent component, which must implement ClientBehaviorHolder, with a call to
ClientBehaviorHolder.addClientBehavior(java.lang.String, javax.faces.component.behavior.ClientBehavior).Represent an attached object that is a
BehaviorHolder in a VDL page.Represent a
BehaviorHolder
attached object target in a VDL page.A generic base interface for event
listeners for various types of
BehaviorEvents.Converter implementation for
java.math.BigDecimal values.Converter implementation for
java.math.BigInteger values.Specifies predefined binary data handling strategies.
Instances of the type
Bindable represent object or attribute types
that can be bound into a Path.An encapsulation of the evaluation of the body of an action so it is
available to a tag handler.
This class models a Part that is contained within a Multipart.
The BodyTag interface extends IterationTag by defining additional
methods that let a tag handler manipulate the content of evaluating its body.
A base class for defining tag handlers implementing BodyTag.
This class implements searches on a message body.
Converter implementation for java.lang.Boolean
(and boolean primitive) values.Represents the user specified default configuration in
META-INF/validation.xml.This provides a mechanism to pass a bootstrap context to a resource adapter
instance when it is bootstrapped.
Defines the state used to bootstrap the
Configuration.Specifies standard measurements of the upper and lower limits of the value of an attribute.
The BoundedRangeStatistic model aggregates the attributes of RangeStatistic and BoundaryStatistic and provides standard measurements of a range that has fixed limits.
Indicates that the container has rejected a request because a concurrent request is associated with the same conversation
context.
A DataSource backed by a byte array.
Converter implementation for java.lang.Byte
(and byte primitive) values.A
BytesMessage object is used to send a message containing a
stream of uninterpreted bytes.Interface used to interact with the second-level cache.
Specifies whether an entity should be cached if caching is enabled
when the value of the
persistence.xml caching element
is ENABLE_SELECTIVE or DISABLE_SELECTIVE.An abstraction for the value of a HTTP Cache-Control response header.
Used as the value of the
javax.persistence.cache.retrieveMode property to
specify the behavior when data is retrieved by the
find methods and by queries.Used as the value of the
javax.persistence.cache.storeMode property to specify
the behavior when data is read from the database and when data is
committed into the database.CallerOnlyCredential represents a credential that only
contains a caller name and no secret of any kind.Principal that represents the caller principal associated with the invocation being
processed by the container (e.g.
Callback for setting the container's caller (or Remote user) principal.
Represents a cascadable element.
Defines the set of cascadable operations that are propagated
to the associated entity.
Provides access to the current container.
Interface implemented by a CDI provider to provide access to the current container
Callback for CertStore.
Converter implementation for java.lang.Character
(and char primitive) values.CheckpointAlgorithm provides a custom checkpoint
policy for chunk steps.
ChunkListener intercepts chunk processing.
A persistence provider supplies an instance of this
interface to the
PersistenceUnitInfo.addTransformer
method.Client is the main entry point to the fluent API used to build and execute client
requests in order to consume responses returned.
An implementation of this interface is used to secure service request
messages, and validate received service response messages.
This interface encapsulates the configuration of ClientAuthContext objects
for a message layer and application context (for example, the messaging context of
a specific application, or set of applications).
This ClientAuthContext class encapsulates ClientAuthModules that are used
to secure service requests made by a client, and to validate any responses
received to those requests.
A ClientAuthModule secures request messages, and validates received
response messages.
ClientBehavior is the
base contract for
Behaviors that attach script content to
client-side events exposed by ClientBehaviorHolder
components.ClientBehaviorBase is a
convenience base class that implements the default concrete behavior
of all methods defined by
ClientBehavior.ClientBehaviorContext
provides context information that may be useful to
ClientBehavior.getScript(javax.faces.component.behavior.ClientBehaviorContext)
implementations.Parameter instances
represent name/value pairs that "submitting" ClientBehavior implementations
should include when posting back into the Faces lifecycle.
An enum that specifies hints that describes
the behavior of ClientBehavior implementations.
The ClientBehaviorHolder
interface may be implemented by any concrete
UIComponent that wishes to support
client behaviors as defined by ClientBehavior.A ClientBehaviorRenderer produces
the client-side script that implements a
ClientBehavior's client-side
logic.Main entry point to the client API used to bootstrap
Client
instances.The ClientEndpoint annotation a class level annotation is used to denote that a POJO
is a web socket client and can be deployed as such.
The ClientEndpointConfig is a special kind of endpoint configuration object that contains
web socket configuration information specific only to client endpoints.
The ClientEndpointConfig.Builder is a class used for creating
ClientEndpointConfig objects for the purposes of
deploying a client endpoint.The Configurator class may be extended by developers who want to
provide custom configuration algorithms, such as intercepting the opening handshake, or
providing arbitrary methods and algorithms that can be accessed from each endpoint
instance configured with this configurator.
A base runtime application exception indicating a client request error
(HTTP
4xx status codes).Client request filter context.
An extension interface implemented by client request filters.
Client response filter context.
An extension interface implemented by client response filters.
This class represents a client window,
which may be a browser tab, browser window, browser pop-up, portlet,
or anything else that can display a
UIComponent hierarchy rooted at a UIViewRoot.Create
ClientWindow instances based on
the incoming request.Wrapper for
ClientWindowContract for obtaining the
Clock used as the reference for now when
validating the @Future and @Past constraints.A class encapsulating the reason why a web socket has been closed, or why it is being asked to
close.
A marker interface for the close codes.
An Enumeration of status codes for a web socket close that
are defined in the specification.
Instances of the type
CollectionAttribute represent persistent
java.util.Collection-valued attributes.CollectionDataModel is a convenience
implementation of
DataModel that wraps an Collection of
Java objects.The
CollectionJoin interface is the type of the result of
joining to a collection over an association or element
collection that has been specified as a java.util.Collection.Specifies the table that is used for the mapping of
collections of basic or embeddable types.
Specifies the mapped column for a persistent property or field.
Used in conjunction with the
SqlResultSetMapping annotation or
ConstructorResult annotation to map a column of the SELECT
list of a SQL query.This indicates errors related to failed or interrupted
communication with an EIS instance.
The
CommonAbstractCriteria interface defines functionality
that is common to both top-level criteria queries and subqueries as
well as to update and delete criteria operations.This class models the comparison operator.
A request processing callback that receives request processing completion events.
A
CompletionListener is implemented by the application and may
be specified when a message is sent asynchronously.Reactive invoker based
CompletionStage.Passed to the constructor of
ComponentHandler.Public base class for markup
element instances that map to
UIComponent instances in the
view.Typed
FacesException for the SearchExpressionHandler,
if a component can't be resolved.
ComponentSystemEvent is
the base class for
SystemEvents that are specific to a UIComponent instance.Implementors of this class do not need
an
isListenerForSource() method because they are only
installed on specific component instances, therefore the
isListenerForSource() method is implicit.This interface must be implemented by the
Map
returned by the composite component ELResolver,
described in section JSF.5.6.2.2 of the specification, when
evaluating #{cc.attrs} epressions.Maintains an ordered composite list of child
ELResolvers.A FaceletHandler that is derived of 1 or
more, inner FaceletHandlers.
The
CompoundSelection interface defines a compound selection item
(tuple, array, or result of constructor).Declares a singleton session bean's concurrency management type.
Used to specify the value of the
ConcurrencyManagement annotation
for a singleton session bean.A ConcurrentAccessException indicates that the client
has attempted an invocation on a stateful session bean or singleton bean
while another invocation is in progress and such concurrent access
is not allowed.
This exception indicates that an attempt to concurrently access
a stateful session or singleton bean method resulted in a timeout.
Abstract class that facilitates implementation of conditional actions
where the boolean result is exposed as a JSP scoped variable.
Class supporting access to configuration settings.
Designates a JavaBean property as a configuration property
Represents a client or server-side configurable context in JAX-RS.
ConfigurableNavigationHandler
extends the contract of
NavigationHandler to allow runtime
inspection of the NavigationCases that make up the rule-base
for navigation.Provides a simple implementation of
ConfigurableNavigationHandler that can be subclassed by developers wishing
to provide specialized behavior to an existing ConfigurableNavigationHandler instance.Receives configuration information, selects the appropriate
Bean Validation provider and builds the appropriate
ValidatorFactory.A configuration state associated with a
configurable JAX-RS context.A
Connection object is a client's active connection to its JMS
provider.A Connection represents an application-level handle that is used
by a client to access the underlying physical connection.
The adapter which receives connection events.
Asynchronous request processing lifecycle callback that receives connection
related
asynchronous response lifecycle events.For application servers,
Connection objects provide a special
facility
for creating a ConnectionConsumer (optional).Defines a set of connection interfaces and classes pertaining to a particular
connection type.
Defines a set of connection definitions that the JavaBean, that has been
annotated with this annotation, is a part of.
This class models Connection events.
The ConnectionEvent class provides information about the source of
a connection related event.A ConnectionEvent instance contains the
following information:
Type of the connection event
ManagedConnection instance that generated the connection event.
The
ConnectionEventListener interface provides an event
callback mechanism to enable an application server to receive
notifications from a ManagedConnection instance.A
ConnectionFactory object encapsulates a set of connection
configuration
parameters that has been defined by an administrator.ConnectionFactory provides an interface for getting
connection to an EIS instance.Annotation used to define a Connector Connection Factory resource to be
registered in JNDI.
Declares one or more
ConnectionFactoryDefinition
annotations.This is the Listener interface for Connection events.
ConnectionManager interface provides a hook for the resource adapter to
pass a connection request to the application server.
A
ConnectionMetaData object provides information describing the
Connection object.The interface
ConnectionMetaData provides information
about an EIS instance connected through a Connection instance.The ConnectionRequestInfo interface enables a resource adapter to
pass its own request specific data structure across the connection
request flow.
ConnectionSpec is used by an application component to pass
connection request-specific properties to the ConnectionFactory.
The
Connector annotation is a component-defining annotation and
it can be used by the resource adapter developer to specify that the JavaBean
is a resource adapter JavaBean.Indicates the run-time context in which an annotated JAX-RS provider
is applicable.
Marks an annotation as being a Bean Validation constraint.
Exception raised if a constraint declaration is not legal.
Exception raised if a constraint definition is not legal.
Describes a single constraint and its composing constraints.
Used to control the application of a constraint.
Defines the constraint target.
Defines the logic to validate a given constraint
A
for a given object type T.Provides contextual data and operation when applying a given constraint validator.
ConstraintViolation builder allowing to optionally associate
the violation report to a sub path.ConstraintValidatorContext.ConstraintViolationBuilder.ContainerElementNodeBuilderCustomizableContext
Represents a container element node whose context is
configurable (i.e.
Represents a container element node whose context is known
(i.e.
Represents refinement choices for a container element node.
Represents a node whose context is
configurable (i.e.
Represents a node whose context is known
(i.e.
Represents refinement choices for a node which is
in an iterable, e.g.
Represents a node whose context is
configurable (i.e.
Represents a node whose context is known
(i.e.
Represents refinement choices for a node which is
in an iterable, e.g.
Instantiates a
ConstraintValidator instance based off its class.Describes a constraint violation.
Reports the result of constraint violations.
Describes a validated constructor.
Used in conjunction with the
SqlResultSetMapping annotation to map the SELECT
clause of a SQL query to a constructor.Defines the media types that the methods of a resource class or
MessageBodyReader can accept.Represents an element that might be a container, thus allowing container element
constraints.
Describes a validated container element type, e.g.
Provider class that allows the developer to get a reference to
the implementation of the WebSocketContainer.
Container request filter context.
An extension interface implemented by container request filters.
Container response filter context.
An extension interface implemented by container response filters.
This class represents a MIME ContentDisposition value.
This class represents a MIME Content-Type value.
Provides an operation for obtaining contextual instances with a particular scope of any contextual type.
This annotation is used to inject information into a class
field, bean property or method parameter.
A simple callback interace that enables taking action on a
specific UIComponent (either facet or child) in the view while
preserving any contextual state for that component instance in the
view.
Indicates a problem relating to context management.
Indicates that a context is not active.
Contract for a provider that supplies context information to resource
classes and other providers.
The ContextService provides methods for creating dynamic proxy objects
(as defined by
java.lang.reflect.Proxy) with
the addition of context typically associated with applications executing in a
Java™ EE environment.
Defines operations to create and destroy contextual instances of a certain type.
Allows the application to manage the conversation context by marking
the current conversation as transient or long-running, specifying a conversation identifier, or setting the conversation
timeout.
Specifies that a bean is conversation scoped.
Supports inline instantiation of the
ConversationScoped annotation.Specifies the conversion of a Basic field or property.
Converter is an
interface describing a Java class that can perform Object-to-String
and String-to-Object conversions between model data objects and a
String representation of those objects that is suitable for
rendering.
Specifies that the annotated class is a converter and defines its
scope.
A Facelet version of the JSP
ConverterTag.ConverterELTag is a base class for all JSP custom
actions that create and register a
Converter instance on
the ValueHolder associated with our most immediate
surrounding instance of a tag whose implementation class is a
subclass of UIComponentClassicTagBase.ConverterException is an exception thrown by the
getAsObject() or getAsText() method of a
Converter, to indicate that the requested conversion cannot
be performed.Handles setting a
Converter instance on a ValueHolder parent.Deprecated.
This has been partially replaced by
ConverterELTag.Converts group
from to group to during cascading.Defines several
ConvertGroup annotations
on the same element.Used to group
Convert annotations.Creates a cookie, a small amount of information sent by a servlet to
a Web browser, saved by the browser, and later sent back to the server.
Represents the value of a HTTP cookie, transferred in a request.
Binds the value of a HTTP cookie to a resource method parameter,
resource class field, or resource class bean property.
Specifies standard count measurements.
The CreateException exception must be included in the throws clauses of
all create methods defined in an enterprise bean's home or local home
interface.
Provides operations that are used by the
Contextual implementation during instance
creation and destruction.
Indicates that a checked exception was thrown during creation of a bean.
Credential represents the credential the caller will use to authenticate.CredentialValidationResult is the result from an attempt to
validate an instance of Credential.Used to construct criteria queries, compound selections,
expressions, predicates, orderings.
Interface used to build general case expressions.
Interface used to build coalesce expressions.
Interface used to build in predicates.
Interface used to build simple case expressions.
Used to specify how strings are trimmed.
The
CriteriaDelete interface defines functionality for performing
bulk delete operations using the Criteria APIThe
CriteriaQuery interface defines functionality that is specific
to top-level queries.The
CriteriaUpdate interface defines functionality for performing
bulk update operations using the Criteria API.Describes an element holding cross-parameter constraints of a method or constructor
Annotation used to define a container authentication mechanism that implements
authentication resembling Servlet FORM authentication (Servlet spec 13.6.3).
Deprecated.
This has been replaced by CDI custom scopes and
javax.enterprise.context.spi.Context.Annotation used to define a container-provided
IdentityStore that
stores caller credentials and identity attributes in a relational database,
and make that implementation available as an enabled CDI bean.DataModel
is an abstraction around arbitrary data
binding technologies that can be used to adapt a variety of data sources
for use by JavaServer Faces components that support per-row processing
for their child components (such as
UIData.DataModelEvent represents an event of interest to
registered listeners that occurred on the specified
DataModel.DataModelListener represents an event listener that
wishes to be notified of
DataModelEvents occurring on a
particular DataModel instance.Annotation used to define a container
DataSource to
be registered with JNDI.Declares one or more
DataSourceDefinition annotations.This class implements comparisons for Dates
Converter
implementation for java.util.Date values.A Decider receives control as part of a decision element
in a job.
The annotated element must be a number whose value must be lower or
equal to the specified maximum.
Defines several
DecimalMax annotations on the same element.The annotated element must be a number whose value must be higher or
equal to the specified minimum.
Defines several
DecimalMin annotations on the same element.Used by application to declare security roles.
A general exception that occurs when trying to decode a custom object from a text or binary message.
The Decoder interface holds member interfaces that define how a developer can provide
the web socket container a way web socket messages into developer defined custom objects.
This interface defines how a custom object (of type T) is decoded from a web socket message in
the form of a byte buffer.
This interface defines how a custom object is decoded from a web socket message in
the form of a binary stream.
This interface defines how a custom object is decoded from a web socket message in
the form of a string.
This interface defines how a custom object of type T is decoded from a web socket message in
the form of a character stream.
A decorator may inject metadata about the bean it is decorating
Specifies that a class is a decorator.
Represents an enabled decorator.
The default qualifier type.
Default Bean Validation group.
Supports inline instantiation of the
Default qualifier.Defines the default value of request meta-data that is bound using one of the
following annotations:
PathParam,
QueryParam,
MatrixParam,
CookieParam,
FormParam,
or HeaderParam.
Thrown when a definition error occurs.
Identifies the delegate injection point of a decorator.
Enable the JSF
implementation to provide the appropriate behavior for the kind of
MetaTagHandler subclass for each kind of element in the view,
while providing a base-class from which those wanting to make a Java
language custom tag handler can inherit.Indicates that the annotated method responds to HTTP DELETE requests.
The delivery modes supported by the JMS API are
PERSISTENT and
NON_PERSISTENT.Specifies that no security roles are allowed to invoke the specified
method(s).
Specifies that a bean belongs to the dependent pseudo-scope.
Supports inline instantiation of the
Dependent annotation.Used to express an initialization dependency between singleton
components.
Thrown when a deployment problem occurs.
Checked exception indicating some kind of failure either to publish
an endpoint on its server, or a failure to connect a client to its server.
Provides JSONB Mapper functionality on top of JSONP parser.
A
Destination object encapsulates a provider-specific
address.An event with this qualifier is fired when a context is destroyed, i.e.
Supports inline instantiation of the
Destroyed qualifier.The annotated element must be a number within accepted range
Supported types are:
BigDecimal
BigInteger
CharSequence
byte, short, int, long, and their respective
wrapper types
Defines several
Digits annotations on the same element.Defines supported types of the discriminator column.
Specifies the value of the discriminator column for
entities of the given type.
Enumeration of filter dispatcher types.
Identifies the disposed parameter of a disposer method.
This is a mix-in interface that may be optionally implemented by a
ManagedConnection implementation.This models a
Work instance that would be distributed by a
DistributableWorkManager for execution in a remote
DistributableWorkManagerThis interface models a
WorkManager that supports distributed
execution of Work instances.Converter implementation for java.lang.Double
(and double primitive) values.DoubleRangeValidator
is a
Validator that checks the value of the corresponding
component against specified minimum and maximum values.For a tag to declare that it accepts dynamic attributes, it must implement
this interface.
A JAX-RS meta-provider for dynamic registration of post-matching providers
during a JAX-RS application setup at deployment time.
EditableValueHolder is an
extension of ValueHolder that describes additional features supported
by editable components, including
ValueChangeEvents and
Validators.A VDL handler that exposes
Validator or ValueChangeListener to a page author.A marker interface for VDL tags that
represent
<composite:editableValueHolder/> for use
by the composite component page author.An
EISSystemException is used to indicate any EIS
specific system-level
error conditions.Indicates a dependency on the local, no-interface, or remote view of an Enterprise
JavaBean.
This exception indicates that client access to a business
method was denied.
Used to execute an EJB application in an embeddable container.
The EJBContainerProvider SPI is used by the embeddable container bootstrap
class to initialize a suitable embeddable container.
The EJBContext interface provides an instance with access to the
container-provided runtime context of an enterprise bean instance.
The EJBException is thrown to report that the invoked
business method or callback method could not be completed because
of an unexpected error (e.g.
The EJBHome interface must be extended by all enterprise beans'
remote home interfaces.
The EJBLocalHome interface must be extended by all enterprise
beans' local home interfaces.
The EJBLocalObject interface must be extended by all enterprise beans' local
interfaces.
The EJBMetaData interface allows a client to obtain the enterprise bean's
meta-data information.
Class for EJB method permissions.
The EJBObject interface is extended by all enterprise beans' remote
interfaces.
Class for EJB
isCallerInRole (String reference)
permissions.Declares multiple
EJB annotations.Specifies statistics provided by all EJB component types.
This exception indicates that a request carried a null transaction context,
but the target object requires an active transaction.
This exception is thrown to a remote client to indicate that the
transaction associated with processing of the request has been
rolled back, or marked to roll back.
A runtime representation of a Class in the EL expressions.
Context information for expression parsing and evaluation.
An event which indicates that an
ELContext has been created.The listener interface for receiving notification when an
ELContext is created.Specifies a collection of instances of a basic type or embeddable
class.
Describes a validated element (class, property, method etc.).
Declares restrictions on retrieved constraints.
Enum of possible kinds of elements encountered in Bean Validation.
Represents any of the exception conditions that can arise during
expression evaluation.
Deprecated.
As of JSP 2.1, replaced by
ELExceptionManages EL parsing and evaluation environment.
Deprecated.
As of JSP 2.1, replaced by
ELExceptionProvides an API for using EL in a stand-alone environment.
Enables customization of variable, property, method call, and type
conversion resolution behavior for EL expression evaluation.
The string has to be a well-formed email address.
Defines several
@Email constraints on the same element.Specifies a class whose instances are stored as an intrinsic
part of an owning entity and share the identity of the entity.
Instances of the type
EmbeddableType represent embeddable types.Specifies a persistent field or property of an entity whose
value is an instance of an embeddable class.
Applied to a persistent field or property of an entity
class or mapped superclass to denote a composite primary
key that is an embeddable class.
Disables automatic decoding of parameter values bound using
QueryParam,
PathParam, FormParam or MatrixParam.A general exception that occurs when trying to encode a custom object to a string or binary message.
The Encoder interface defines how developers can provide a way to convert
their custom objects into web socket messages.
This interface defines how to provide a way to convert a custom
object into a binary message.
This interface may be implemented by encoding algorithms
that want to write the encoded object to a binary stream.
This interface defines how to provide a way to convert a custom
object into a text message.
This interface may be implemented by encoding algorithms
that want to write the encoded object to a character stream.
A
DataSource that also implements
EncodingAware may specify the Content-Transfer-Encoding
to use for its data.The Web Socket Endpoint represents an object that can handle websocket conversations.
The endpoint configuration contains all the information needed during the handshake process
for this end point.
The EnterpriseBean interface is a common superinterface for the
SessionBean, EntityBean and MessageDrivenBean interfaces.
Specifies that the class is an entity.
Encapsulates message entity including the associated variant information.
Specifies statistics provided by entity beans.
Thrown by the persistence provider when
EntityManager.persist(Object) is called and the entity already exists.This type represents the root of an entity graph that will be used
as a template to define the attribute nodes and boundaries of a
graph of entities and entity relationships.
Specifies the callback listener classes to be used for an
entity or mapped superclass.
Interface used to interact with the persistence context.
Interface used to interact with the entity manager factory
for the persistence unit.
Thrown by the persistence provider when an entity reference obtained by
EntityManager.getReference
is accessed but the entity does not exist.Used in conjunction with the
SqlResultSetMapping annotation to map the SELECT
clause of a SQL query to an entity result.An abstraction for the value of a HTTP Entity Tag, used as the value
of an ETag response header.
Interface used to control transactions on resource-local entity
managers.
Instances of the type
EntityType represent entity types.Converter implementation
for java.lang.Enum (and enum primitive) values.Specifies that a persistent property or field should be persisted
as a enumerated type.
Defines mapping for enumerated types.
Contains information about an error, for error pages.
Deprecated.
This has been replaced by
ELException.The listener interface for receiving notification when an
EL expression is evaluated.
Allows the application to fire events of a particular type.
Represents a context of a fired event.
Provides access to metadata about an observed event payload.
ExceptionHandler is the central
point for handling unexpected
Exceptions that
are thrown during the Faces lifecycle.ExceptionHandlerFactory
is a factory object that creates (if needed) and returns a new
ExceptionHandler instance.Provides
a simple implementation of
ExceptionHandler that can
be subclassed by developers wishing to provide specialized behavior
to an existing ExceptionHandler instance.If a JMS provider detects a serious problem with a
Connection
object, it informs the Connection object's
ExceptionListener, if one has been registered.Contract for a provider that maps Java exceptions to
Response.The system event facility will create an
instance of this class whenever
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) is called with
ExceptionQueuedEvent.class as systemEventClass
argument.This helper class provides context to
the
ExceptionQueuedEvent regarding the state of the system at the
point in time when the ExceptionQueuedEvent occurs and links
the ExceptionQueuedEvent to the ExceptionHandler by virtue of implementing
SystemEventListener.Used to exclude class-level interceptors for the
lifecycle callback method, business method, timeout method,
or constructor to which it is applied.
Used to exclude default interceptors for a target class or for
a lifecycle callback method, business method, timeout method,
or constructor of a target class.
Specifies that the invocation of default listeners is
to be excluded for the entity class (or mapped superclass)
and its subclasses.
Specifies that the invocation of superclass listeners is
to be excluded for the entity class (or mapped superclass)
and its subclasses.
Provides the common functionality of
MethodDescriptor and
ConstructorDescriptor.Defines the types of executables targeted by an operation.
Validates parameters and return values of methods and constructors.
This class models an execution context (transaction, security, etc)
with which the
Work instance must be executed.Base class for the expression subclasses
ValueExpression and
MethodExpression, implementing characteristics common to both.Type for query expressions.
Deprecated.
As of JSP 2.1, replaced by
ValueExpressionDeprecated.
As of JSP 2.1, replaced by
ExpressionFactoryProvides an implementation for creating and evaluating EL expressions.
Service interface implemented by extensions.
A simple representation of a websocket extension as a name and map of extension parameters.
This member interface defines a single websocket extension parameter.
This class allows the Faces API to be unaware of the nature of its containing
application environment.
ExternalContextFactory
is a factory object that creates
(if needed) and returns new
ExternalContext instances, initialized
for the processing of the specified request and response objects.Provides
a simple implementation of
ExternalContext that can
be subclassed by developers wishing to provide specialized behavior
to an existing ExternalContext instance.Marks the type parameter of a generic container type to which a
ValueExtractor is
tied or specifies the type of the wrapped element(s) of non-generic container types.The parent or root object
in a FaceletHandler composition.
This API defines the facility by
which the Facelets
ViewDeclarationLanguage
creates and caches instances of Facelets.Factory interface for creating
Facelet or View Metadata Facelet instances.
Allows customization of the
implementation of
FaceletCache.Context representative of a single
request from a Facelet.
An Exception from the Facelet
implementation
This is the root class for markup
elements in Facelets VDL.
Root class for all tag handlers that
represent attached objetcts in a Facelets page.
The presence of this annotation on a
class automatically registers the class with the runtime as a
ResourceResolver.The presence of this annotation on a
class automatically registers the class with the runtime as a
Behavior.The presence of this annotation on a
class automatically registers the class with the runtime as a
ClientBehaviorRenderer.The presence of this annotation
on a class that extends
UIComponent must cause the runtime to
register this class as a component suitable for inclusion in a view.The presence of this annotation on a managed
bean deployed within an application causes version specific features
to be enabled as specified in the enum
FacesConfig.VersionFacesContext contains all of the
per-request state information related to the processing of a single
JavaServer Faces request, and the rendering of the corresponding
response.
FacesContextFactory
is a factory object that creates
(if needed) and returns new
FacesContext instances, initialized
for the processing of the specified request and response objects.Provides a simple
implementation of
FacesContext that can be subclassed by
developers wishing to provide specialized behavior to an existing
FacesContext instance.The presence of this annotation
on a class automatically registers the class with the runtime as a
Converter.FacesEvent is the base class
for user interface and application events that can be fired by
UIComponents.This class encapsulates general JavaServer Faces exceptions.
A generic base interface for event listeners for various types of
FacesEvents.FacesMessage represents a single validation (or
other) message, which is typically associated with a particular
component in the view.
Class used to represent message severity levels in a typesafe
enumeration.
The presence of this annotation on a
class automatically registers the class with the runtime as a
Renderer.FacesServlet is a
servlet that manages the request processing lifecycle for web
applications that are utilizing JavaServer Faces to construct the
user interface.
The
presence of this annotation on a
class automatically registers the class with the runtime as a
Validator.Any
wrapper class in JSF that must provide
access to the object it wraps must implement this interface.
An interface that allows other code
to identify FaceletHandlers that correspond to component facets.
FacetTag is the JSP mechanism for denoting a
UIComponent is to be added as a
facet to the component associated with its parent.FactoryFinder
implements the standard discovery algorithm for all factory objects
specified in the JavaServer Faces APIs.
A feature extension contract.
A configurable context passed to
Feature and DynamicFeature
instances by JAX-RS runtime during the phase of their configuration.Represents a join-fetched association or attribute.
Represents an element of the from clause which may
function as the parent of Fetches.
Clients use a FetchProfile to list the Message attributes that
it wishes to prefetch from the server for a range of messages.
This inner class is the base class of all items that
can be requested in a FetchProfile.
Defines strategies for fetching data from the database.
Used in conjunction with the
EntityResult annotation to map columns specified
in the SELECT list of a SQL query to the properties or fields of an entity class.A filter is an object that performs
filtering tasks on either the request to a resource (a servlet or static content), or on the response
from a resource, or both.
A FilterChain is an object provided by the servlet container to the developer
giving a view into the invocation chain of a filtered request for a resource.
A filter configuration object used by a servlet container
to pass information to a filter during initialization.
Interface through which a
Filter may be further configured.Interface through which a
Filter registered via one of the
addFilter methods on ServletContext may be further
configured.The Flags class represents the set of flags on a Message.
This inner class represents an individual system flag.
This class implements comparisons for Message Flags.
The Flash
concept is taken from Ruby on Rails and provides a way to pass
temporary objects between the user views generated by the faces
lifecycle.
FlashFactory is a
factory object that creates (if needed) and returns
Flash
instances.Converter implementation for java.lang.Float
(and float primitive) values.Flow is the runtime
representation of a Faces Flow.
A Java language API for building
Flows.The presence of this annotation on a CDI producer
method for the
FlowDefinition annotation causes the FlowBuilder
to be passed to that method.Create a flow call node in the current
Flow.The presence of this annotation on a CDI producer
method indicates that the method will produce a flow.
FlowHandler is the main entry
point that enables the runtime to interact with the faces flows
feature.
FlowHandlerFactory is
used by the
Application to create the
singleton instance of FlowHandler.FlowHandlerFactoryWrapper
provides a simple implementation of
FlowHandlerFactory that
can be subclassed by developers wishing to provide specialized
behavior to an existing FlowHandlerFactory instance.The presence of this annotation (along
with
@Inject) on a field of type Map<Object,
Object> causes the map returned from FlowHandler.getCurrentFlowScope() to be
injected as the value of that field.FlowNode is the base
class for all nodes in a faces flow graph.
FlowScoped is a CDI scope that causes the runtime to
consider classes with this annotation to be in the scope of the
specified
Flow.Flush mode setting.
Folder is an abstract class that represents a folder for mail
messages.
The adapter which receives Folder events.
This exception is thrown when a method is invoked on a Messaging object
and the Folder that owns that object has died due to some reason.
This class models Folder existence events.
This is the Listener interface for Folder events.
This exception is thrown by Folder methods, when those
methods are invoked on a non existent folder.
A runtime exception indicating that an access to a resource requested by
a client has been
forbidden
by the server.Used to specify the handling of foreign key constraints when schema
generation is in effect.
Represents the the HTML form data request entity encoded using the
"application/x-www-form-urlencoded" content type.Annotation used to define a container authentication mechanism that implements
FORM authentication as defined by the Servlet spec (13.6.3) and make that
implementation available as an enabled CDI bean.
Binds the value(s) of a form parameter contained within a request entity body
to a resource method parameter.
Represents a bound type, usually an entity that appears in
the from clause, but may also be an embeddable belonging to
an entity in the from clause.
This class implements string comparisons for the From Address
header.
This class implements comparisons for the From Address header.
Information for a function in a Tag Library.
The interface to a map between EL function names and methods.
Deprecated.
As of JSP 2.1, replaced by
FunctionMapperThe annotated element must be an instant, date or time in the future.
Defines several
Future annotations on the same element.The annotated element must be an instant, date or time in the present or in the future.
Defines several
FutureOrPresent annotations on the same element.The
Generated annotation is used to mark source code
that has been generated.Provides for the specification of generation strategies for the
values of primary keys.
Defines the types of primary key generation strategies.
Defines the state used to bootstrap Bean Validation and
creates a provider agnostic
Configuration.Deprecated.
The preferred way to represent generic credential information
is via the
org.ietf.jgss.GSSCredential interface in
J2SE Version 1.4, which provides similar functionality.Represents a message entity of a generic type
T.Defines a generic, protocol-independent
filter.
Defines a generic, protocol-independent
servlet.
Represents a generic message entity type
T.Indicates that the annotated method responds to HTTP GET requests.
A group conversion rule to be applied during cascaded validation.
Exception raised if a group definition is not legal.
Callback establishing group principals within the argument subject.
Defines group sequence.
The Handle interface is implemented by all EJB object handles.
The
HandleDelegate interface is implemented by the EJB container.This annotation is used to declare the class types that a
ServletContainerInitializer can handle.The handshake request represents the web socket defined Http GET request
for the opening handshake of a web socket session.
The handshake response represents the web socket-defined Http response
that is the response to the opening handshake request.
Indicates that the annotated method responds to HTTP HEAD requests.
The Header class stores a name/value pair to represent headers.
The presence of this annotation (along
with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getRequestHeaderMap() to be
injected as the value of that field.Binds the value(s) of a HTTP header to a resource method parameter,
resource class field, or resource class bean property.
This class implements comparisons for Message headers.
This class tokenizes RFC822 and MIME headers into the basic
symbols specified by RFC822 and MIME.
The Token class represents tokens returned by the
HeaderTokenizer.
The presence of this annotation (along
with
@Inject) on a field of type Map<String,
String[]> causes the map returned from ExternalContext.getRequestHeaderValuesMap() to be
injected as the value of that field.This exception is thrown by the rollback operation on a resource to
report that a heuristic decision was made and that all relevant updates
have been committed.
This exception is thrown to report that a heuristic decision was made and
that some relevant updates have been committed and others have been
rolled back.
This exception is thrown by the commit operation to report that a heuristic
decision was made and that all relevant updates have been rolled back.
A standard
WorkContext that allows a Work
instance to propagate quality-of-service (QoS) hints about the Work to the WorkManager.The HomeHandle interface is implemented by all home object handles.
NONE
Represents a column that will be rendered
in an HTML
table element.Represents an HTML
input element
for a button of type submit or reset.Represents an HTML
a element for a hyperlink that acts
like a submit button.Represents an HTML
script element for a function that acts
like an ajax form submit.Represents a set of repeating data (segregated into
columns by child UIColumn components) that will
be rendered in an HTML
table element.NONE
Represents an HTML
form element.Represents an HTML
img element, used to retrieve
and render a graphical image.NONE
Represents an HTML
input element
of type hidden.Represents an HTML
input element
of type password.Represents an HTML
input element
of type text.Represents an HTML
textarea element.By default, the
rendererType property must be set to "javax.faces.Message".By default, the
rendererType property must be set to "javax.faces.Messages".Represents an HTML
input element of type "button" or image that
may be used to link to a URL handled by the Faces Servlet resolved preemptively using
the logical outcome defined by the outcome property.Represents an HTML
a (hyperlink) element that may be
used to link to a URL handled by the Faces Servlet resolved preemptively using the logical
outcome defined by the outcome property.Represents a component that looks up a localized message in a
resource bundle, optionally uses it as a
MessageFormat pattern string and substitutes in
parameter values from nested UIParameter components, and
renders the result.Represents an HTML
label element, used to define
an accessible label for a corresponding input element.Represents an HTML
a (hyperlink) element that may be
used to link to an arbitrary URL defined by the value
property.
Renders the component value as text, optionally wrapping in a
span element if I18N attributes, CSS styles or style
classes are specified.Renders child components in a table, starting a new
row after the specified number of columns.
Causes all child components of this component
to be rendered.
Represents an HTML
input element of type checkbox.Represents a
multiple-selection component that is rendered as a set of
HTML
input elements of type
checkbox.Represents a multiple-selection component that is rendered
as an HTML
select element, showing either all
available options or the specified number of options.Represents a multiple-selection component that is rendered
as an HTML
select element, showing a single
available option at a time.Represents a single-selection component that is rendered
as an HTML
select element, showing either all
available options or the specified number of options.Represents a single-selection component that is rendered
as an HTML
select element, showing a single
available option at a time.Represents a
single-selection component that is rendered as a set of HTML
input elements of type
radio.HttpAuthenticationMechanism is a mechanism for obtaining a caller's
credentials in some way, using the HTTP protocol where necessary.This annotation is used within the
ServletSecurity annotation to
represent the security constraints to be applied to all HTTP protocol
methods for which a corresponding HttpMethodConstraint element does
NOT occur within the ServletSecurity annotation.Java Class representation of an
HttpConstraint annotation value.Provides an abstract class to be subclassed to create
an HTTP filter suitable for a Web site.
An injectable interface that provides access to HTTP header information.
The HttpJspPage interface describes the interaction that a JSP Page
Implementation Class must satisfy when using the HTTP protocol.
HttpMessageContext contains all of the per-request state information and encapsulates the client request,
server response, container handler for authentication callbacks, and the subject representing the caller.This class is an implementation of the HttpMessageContext interface that
can be subclassed by developers wishing to provide extra or different
functionality.
Associates the name of a HTTP method with an annotation.
This annotation is used within the
ServletSecurity annotation to
represent security constraints on specific HTTP protocol messages.Java Class represntation of an
HttpMethodConstraint annotation value.Provides an abstract class to be subclassed to create
an HTTP servlet suitable for a Web site.
Allows runtime discovery of the manner in which the
HttpServlet for the current HttpServletRequest was invoked.Extends the
ServletRequest interface to provide
request information for HTTP servlets.Provides a convenient implementation of the HttpServletRequest interface
that can be subclassed by developers wishing to adapt the request to a
Servlet.
Extends the
ServletResponse interface to provide HTTP-specific
functionality in sending a response.Provides a convenient implementation of the HttpServletResponse interface that
can be subclassed by developers wishing to adapt the response from a Servlet.
Provides a way to identify a user across more than one page
request or visit to a Web site and to store information about that user.
Objects that are bound to a session may listen to container
events notifying them that sessions will be passivated and that
session will be activated.
Interface for receiving notification events about HttpSession
attribute changes.
Events of this type are either sent to an object that implements
HttpSessionBindingListener when it is bound or unbound from a
session, or to a HttpSessionAttributeListener that has been
configured in the deployment descriptor when any attribute is bound, unbound
or replaced in a session.Causes an object to be notified when it is bound to
or unbound from a session.
Deprecated.
As of Java(tm) Servlet API 2.1
for security reasons, with no replacement.
This is the class representing event notifications for changes to
sessions within a web application.
Interface for receiving notification events about HttpSession
id changes.
Interface for receiving notification events about HttpSession
lifecycle changes.
This interface encapsulates the upgrade protocol processing.
Deprecated.
As of Java(tm) Servlet API 2.3.
Specifies the primary key of an entity.
Specifies a composite primary key class that is mapped to
multiple fields or properties of the entity.
Instances of the type
IdentifiableType represent entity or
mapped superclass types.IdentityStore is a mechanism for validating a caller's credentials
and accessing a caller's identity attributes.Determines the type of validation (operations) that should be done by this store.
IdentityStoreHandler is a mechanism for validating a caller's
credentials, and accessing a caller's identity attributes, by consulting
a set of one or more IdentityStores.Class for IdentityStore permissions.
This exception indicates that an attempt was made to perform an
illegal loopback invocation.
Indicates that a producer method returned a null value or a producer field contained a null value, and the scope of the
producer method or field was not
Dependent. This exception is thrown when a method is
invoked at an illegal or inappropriate time or if the provider is
not in an appropriate state for the requested operation.
An
IllegalStateException
is thrown from a method if the callee (resource
adapter or application server for system contracts) is in an illegal or
inappropriate state for the method invocation.This unchecked exception is thrown when a method is invoked at an illegal or
inappropriate time or if the provider is not in an appropriate state for the
requested operation, and the method signature does not permit a
IllegalStateRuntimeException to be thrown.The exception thrown when a write is attempted on a read-only attribute
of any Messaging object.
Defines variable resolution behavior for the EL implicit objects
defined in the JSP specification.
Handles imports of class names and package names.
Inbound Server-sent event.
Used in schema generation to specify creation of an index.
IndexedRecord represents an ordered collection of record elements
based on the
java.util.List interface.Specifies the inheritance strategy to be used for an entity class
hierarchy.
Defines inheritance strategy options.
Designates a method of a session bean that corresponds to a
create<METHOD> method of an adapted home or
local home interface (an interface that adapts an EJB 2.1 or earlier
EJBHome or EJBLocalHome client view respectively).An event with this qualifier is fired when a context is initialized, i.e.
Supports inline instantiation of the
Initialized qualifier.The presence of this annotation (along
with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getInitParameterMap() to be
injected as the value of that field.Identifies injectable constructors, methods, and fields.
Provides access to metadata about an injection point.
This API is an helper to configure an existing
InjectionPoint instance.
Provides operations for performing dependency injection and lifecycle callbacks on an
instance of a type.
An
InjectionTargetFactory can create an InjectionTarget for a given bean.Supports inline instantiation of the
Inject annotation.
Allows the application to dynamically obtain instances of beans with a specified combination of required type and qualifiers.
This class implements comparisons for integers.
Converter implementation for java.lang.Integer
(and int primitive) values.The
javax.resource.cci.Interaction enables a component to
execute EIS functions.An InteractionSpec holds properties for driving an Interaction
with an EIS instance.
An interceptor may inject metadata about the bean it is intercepting.
InterceptionFactory allows to create a wrapper instance whose method invocations are intercepted by method
interceptors and forwarded to a provided instance.
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
Represents an enabled interceptor.
Specifies that a class is an interceptor.
Priorities that define the order in which interceptors are
invoked.
Specifies that an annotation type is an interceptor binding type.
Context shared by message body interceptors that can be used to wrap
calls to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream) and
MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).Declares an ordered list of interceptors for a target class, or
for a method or a constructor of a target class.
A runtime exception indicating an
internal server error.This class represents an Internet email address using the syntax
of RFC822.
InternetHeaders is a utility class that manages RFC822 style
headers.
An individual internet header.
This exception must be thrown when a
client attempts to set a connection's client ID to a value that
is rejected by a provider.
This unchecked exception must be thrown when a client attempts to set a
connection's client ID to a value that is rejected by a provider, and the
method signature does not permit a
InvalidClientIDException to
be thrown. This exception must be thrown when a
destination either is not understood by a provider or is no
longer valid.
This unchecked exception must be thrown when a destination either is not
understood by a provider or is no longer valid, and the method signature does
not permit a
InvalidDestinationException to be thrown.This exception is thrown to indicate invalid configuration
property settings.
This exception must be thrown when a
JMS client attempts to give a provider a message selector with
invalid syntax.
This unchecked exception must be thrown when a JMS client attempts to give a
provider a message selector with invalid syntax, and the method signature
does not permit a
InvalidSelectorException to be thrown.This exception indicates that the request carried an invalid transaction
context.
A client request invocation.
A client request invocation builder.
Callback that can be implemented to receive the asynchronous processing
events from the invocation processing.
Exposes contextual information about the intercepted invocation and
operations that enable interceptor methods to control the behavior
of the invocation chain.
ItemProcessListener intercepts item processing.
ItemProcessor is used in chunk processing
to operate on an input item and produce
an output item.
ItemReader defines the batch artifact that reads
items for chunk processing.
ItemReadListener intercepts item reader
processing.
ItemWriteListener intercepts item writer
processing.
ItemWriter defines the batch artifact that writes to a
list of items for chunk processing.
IterableDataModel is an
implementation of
DataModel that wraps an Iterable.The IterationTag interface extends Tag by defining one additional
method that controls the reevaluation of its body.
Specifies the statistics provided by a JavaMail resource.
Specifies the statistics provided by a JCA Connection Pool
Specifies the statistics provided by a JCA connection
Specifies statistics provided by a JCA resource
Specifies the statistics provided by a JDBC connection pool.
Specifies the statistics provided by all (pooled and non-pooled) JDBC connections.
Statistics provided by a JDBC resource
This annotation may be used to specify the JNDI lookup name of a
javax.jms.ConnectionFactory
to be used when injecting a javax.jms.JMSContext object.An application may use this annotation to specify a JMS
ConnectionFactory resource that it requires in its operational
environment.Specifies one or more
JMSConnectionFactoryDefinition
annotations.Specifies the statistics provided by a JMS connection
A client using the simplified JMS API introduced for JMS 2.0 uses a
JMSConsumer object to receive messages from a queue or topic.Specifies the statistics provided by a JMS message consumer
A
JMSContext is the main interface in the simplified JMS API
introduced for JMS 2.0.An application may use this annotation to specify a JMS
Destination resource that it requires in its operational
environment.Specifies one or more
JMSDestinationDefinition annotations.Specifies the statistics provided by a JMS message producer or a JMS message consumer.
This is the root class of all checked exceptions in the JMS API.
This annotation may be used to specify the userName and password
to be used when injecting a
javax.jms.JMSContext object.A
JMSProducer is a simple object used to send messages on behalf
of a JMSContext.Specifies the statistics provided by a JMS message producer
This is the root class of all unchecked exceptions in the JMS API.
This exception must be thrown when a provider rejects a user
name/password submitted by a client.
This unchecked exception must be thrown when a provider rejects a user
name/password submitted by a client, or for any case where a security
restriction prevents a method from completing, and the method signature does
not permit a
JMSSecurityException to be thrown.This annotation may be used to specify the session mode
to be used when injecting a
javax.jms.JMSContext object.Specifies the statistics provided by a JMS session.
Specifies the statistics provided by a JMS Resource
A JobContext provides information about the current
job execution.
Provides a view of a job execution to the JobOperator.
JobExecutionAlreadyCompleteException is thrown when restart is called for an already-completed job instance.
JobExecutionIsRunningException is thrown when
JobOperator.abandon(long)
is called on a job execution which is currently running (i.e.JobExecutionNotMostRecentException is thrown when
JobOperator.restart(long, java.util.Properties)
is called on a job instance which has already completed (i.e.JobExecutionNotRunningException is thrown when
JobOperator.stop(long)
is called on a job instance which is not currently running.Provides a view of a job instance to the JobOperator.
JobListener intercepts job execution.
JobOperator provide the interface for operating on batch jobs.
JobRestartException is thrown when an error occurs during the JobOperator
restart operation.
SecurityException is thrown when an user is not authorized to run a JobOperator method, such as
restart, stop, abandon, any getters, etc.
JobStartException is thrown when an error occurs during the JobOperator
start operation.
A join to an entity, embeddable, or basic type.
Specifies a column for joining an entity association or element
collection.
Specifies the mapping for composite foreign keys.
Specifies the mapping of associations.
Defines the three types of joins.
Factory class for creating JSON processing objects.
JsonArray represents an immutable JSON array
(an ordered sequence of zero or more values).A builder for creating
JsonArray models from scratch, and for
modifying a existing JsonArray.Jsonb provides an abstraction over the JSON Binding framework operations:Allows to define custom mapping for given java type.
Marks any relevant JSON Binding annotations.
JsonbBuilder class provides the client's entry point to the JSON Binding
API.
This annotation identifies the custom constructor or factory method to use when creating an instance
of the associated class.
Annotation provides way how to set custom date format to field or JavaBean property.
Interface representing a custom deserializer for a given type.
Root class for all JSON Binding exceptions.
Specifies how fields having null values are serialized into JSON.
Annotation provides way how to set custom number format to field or JavaBean property.
Allows customization of field (or JavaBean property) name.This name is used either in serialization or
in deserialization.
Specifies order in which properties are serialized.
Service provider for JSON Binding implementations.
Interface representing a custom serializer for given type.
Prevents mapping of a Java Bean property, field or type to JSON representation.
Annotation provides way how to set custom JsonbAdapter to field or JavaBean property.
Annotation provides way how to set custom JsonbDeserializer to field or JavaBean property.
Annotation provides way how to set custom JsonbSerializer to field or JavaBean property.
Factory to create
JsonObjectBuilder and JsonArrayBuilder
instances.Annotation provides way how to customize visibility strategy of the JSON Binding.
This class contains some implementations of
java.util.stream.Collector for accumulating
JsonValues into JsonArray and JsonObject.JsonException indicates that some exception happened during
JSON processing.JsonGenerationException indicates an incorrect JSON is
being generated.Writes JSON data to an output source in a streaming way.
Factory to create
JsonGenerator instances.Provides the location information of a JSON event in an input source.
This interface represents an implementation of a JSON Merge Patch
as defined by RFC 7396.
An immutable JSON number value.
JsonObject class represents an immutable JSON object value
(an unordered collection of zero or more name/value pairs).A builder for creating
JsonObject models from scratch.Provides forward, read-only access to JSON data in a streaming way.
An event from
JsonParser.Factory for creating
JsonParser instances.JsonParsingException is used when an incorrect JSON is
being parsed.This interface represents an immutable implementation of a JSON Patch
as defined by RFC 6902.
This enum represents the list of valid JSON Patch operations
as defined by RFC 6902.
A builder for constructing a JSON Patch as defined by
RFC 6902 by adding
JSON Patch operations incrementally.
This interface represents an immutable implementation of a JSON Pointer
as defined by RFC 6901.
Service provider for JSON processing objects.
Factory to create
JsonReader instances.An immutable JSON string value.
JsonValue represents an immutable JSON value.Indicates the type of a
JsonValue object.Factory to create
JsonWriter instances.Stores application-scoped information relevant to JSP containers.
This interface provides access to the
<jsp-config>
related configuration of a web application.JspContext serves as the base class for the
PageContext class and abstracts all information that is not specific
to servlets.The JspEngineInfo is an abstract class that provides information on the
current JSP engine.
A generic exception known to the JSP engine; uncaught
JspExceptions will result in an invocation of the errorpage
machinery.
The JspFactory is an abstract class that defines a number of factory
methods available to a JSP page at runtime for the purposes of creating
instances of various interfaces and classes used to support the JSP
implementation.
Encapsulates a portion of JSP code in an object that
can be invoked as many times as needed.
This interface indicates to the container that a tag handler
wishes to be provided with a
compiler generated ID.
The JspPage interface describes the generic interaction that a JSP Page
Implementation class must satisfy; pages that use the HTTP protocol
are described by the HttpJspPage interface.
This interface provides access to the
<jsp-property-group>
related configuration of a web application.Serves as a base class for Tag and SimpleTag.
Exception to be used by a Tag Handler to indicate some unrecoverable
error.
The actions and template data in a JSP page is written using the
JspWriter object that is referenced by the implicit variable out which
is initialized automatically using methods in the PageContext object.
Specifies the statistics provided by a JTA resource.
Specifies the statistics provided by a Java VM.
Encapsulates a parameterized
ValueExpression.Contains information about the last execution of a task.
This is a mix-in interface that may be optionally implemented by a
ConnectionManager implementation.This is a mix-in interface that may be optionally implemented by a
ConnectionManager implementation.This is a mix-in interface that may be optionally implemented by a
ManagedConnection implementation.Annotation used to define a container-provided
IdentityStore that stores
caller credentials and identity attributes (together caller identities) in an
LDAP store, and make that implementation available as an enabled CDI bean.Enum representing LDAP search scope values.
LengthValidator is a
Validator that checks the number of characters in the String
representation of the value of the associated component.Lifecycle manages the
processing of the entire lifecycle of a particular JavaServer Faces
request.
LifecycleFactory is
a factory object that creates (if needed) and returns
Lifecycle instances.Class representing hypermedia links.
Builder class for hypermedia links.
An implementation of JAXB
XmlAdapter
that maps the JAX-RS Link type to a value that can be
marshalled and unmarshalled by JAXB.Value type for
Link that can be marshalled and
unmarshalled by JAXB.Instances of the type
ListAttribute represent persistent
javax.util.List-valued attributes.ListDataModel is a convenience implementation of
DataModel that wraps an List of Java objects.Defines property resolution behavior on instances of
List.Classes tagged with this annotation are
installed as listeners using the method
Application.subscribeToEvent(java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Class<?>, javax.faces.event.SystemEventListener) or UIComponent.subscribeToEvent(java.lang.Class<? extends javax.faces.event.SystemEvent>, javax.faces.event.ComponentSystemEventListener) (depending on the
circumstances, described below).ListenerRegistration defines the methods which clients of the MEJB
use to add and remove event listeners.
Container annotation to specify multiple
ListenerFor annotations on a single class.The
ListJoin interface is the type of the result of
joining to a collection over an association or element
collection that has been specified as a java.util.List.Load states returned by the
ProviderUtil SPI methods.Specifies that a persistent property or field should be persisted
as a large object to a database-supported large object type.
Declares the local business interface(s) for a session bean.
Designates that a session bean exposes a no-interface view.
Class which exposes the locale-determination logic for resource bundles
through convenience methods.
Declares the local home or adapted local home interface
for a session bean.
Class representing an I18N localization context.
The LocalTransaction defines a transaction demarcation interface for
resource manager local transactions.
LocalTransaction interface provides support for transactions that
are managed internal to an EIS resource manager, and do not require
an external transaction manager.
A
LocalTransactionException represents various
error conditions related to the local transaction management contract.An object that represents the Location
of a tag or attribute of a tag in a View Declaration Language
file.
Declares a concurrency lock for a singleton session bean
with container managed concurrency.
Lock modes can be specified by means of passing a
LockModeType
argument to one of the EntityManager methods that take locks
(lock, find, or refresh) or
to the Query.setLockMode() or
TypedQuery.setLockMode() method.Thrown by the persistence provider when an pessimistic locking
conflict occurs that does not result in transaction rollback.
Concurrency lock type for singleton beans with container-managed concurrency.
The
LoginToContinue annotation provides an application the ability to declaratively
add login to continue functionality to an authentication mechanism.Converter implementation for java.lang.Long
(and long primitive) values.LongRangeValidator is a
Validator that checks the value of the corresponding
component against specified minimum and maximum values.JSTL allows developers to write custom iteration tags by
implementing the LoopTag interface.
Exposes the current status of
an iteration.
Base support class to facilitate implementation of iteration tags.
Formats and parses date specification based on
RFC 2822.
Common base class for mail events, defining the dispatch method.
Annotation used by Java EE applications to define a
MailSession
to be registered with JNDI.Declares one or more
MailSessionDefinition annotations.Interface to be implemented by the Java™ EE product providers on threads
that are created by calling
ThreadFactory.newThread(java.lang.Runnable).The
ManagedBean annotation marks a POJO (Plain Old Java Object)
as a ManagedBean.Deprecated.
This has been replaced by the Managed Beans specification in
general and specifically the dependency injection, scopes and naming
from the CDI specification.
ManagedConnection instance represents a physical connection
to the underlying EIS.
ManagedConnectionFactory instance is a factory of both ManagedConnection
and EIS-specific connection factory instances.
The ManagedConnectionMetaData interface provides information about the
underlying EIS instance associated with a ManagedConnection instance.
Utility methods for classes defined in this package.
A manageable version of a
ExecutorService.The presence of this annotation (along
with
@Inject) on a field of any type causes the value returned from
evaluating an expression language expression to be
injected as the value of that field.Deprecated.
This has been replaced by
javax.faces.annotation.ManagedProperty,
which is a CDI build-in bean with similar semanticsA manageable version of a
ScheduledExecutorService.A task submitted to an
ManagedExecutorService or
ManagedScheduledExecutorService can optionally implement this
interface to provide identifying information about the task, to provide
a ManagedTaskListener to get notification of lifecycle events of
the task, or to provide additional execution properties.A ManagedTaskListener is used to monitor the state of a task's Future.
A manageable version of a
ThreadFactory.Instances of the type
ManagedType represent entity, mapped
superclass, and embeddable types.The Management interface provides the APIs to navigate and manipulate
managed objects.
The required home interface for the J2EE Management EJB component (MEJB).
Specifies a many-valued association with many-to-many multiplicity.
Specifies a single-valued association to another entity class that
has many-to-one multiplicity.
Instances of the type
MapAttribute represent
persistent java.util.Map-valued attributes.Defines property resolution behavior on instances of
Map.The
MapJoin interface is the type of the result of
joining to a collection over an association or element
collection that has been specified as a java.util.Map.Specifies the map key for associations of type
java.util.Map when the map key is itself the primary
key or a persistent field or property of the entity that is
the value of the map.Specifies the type of the map key for associations of type
java.util.Map.Specifies the mapping for the key column of a map whose
map key is a basic type.
Specifies the enum type for a map key whose basic type is an enumerated type.
Specifies a mapping to an entity that is a map key.
Supports composite map keys that reference entities.
A
MapMessage object is used to send a set of name-value pairs.The interface
javax.resource.cci.MappedRecord is
used for key-value map based representation of record elements.Designates a class whose mapping information is applied
to the entities that inherit from it.
Instances of the type
MappedSuperclassType represent mapped
superclass types.Enumeration of Servlet mapping types.
Designates a
ManyToOne or
OneToOne relationship attribute that provides the
mapping for an EmbeddedId primary key, an attribute within
an EmbeddedId primary key, or a simple primary key of
the parent entity.Binds the value(s) of a URI matrix parameter to a resource method parameter,
resource class field, or resource class bean property.
The annotated element must be a number whose value must be lower or
equal to the specified maximum.
Defines several
Max annotations on the same element.An abstraction for a media type.
The
Message interface is the root interface of all JMS
messages.This class models an email message.
This inner class defines the types of recipients allowed by
the Message class.
An interface optionally implemented by
DataSources to
supply information to a DataContentHandler about the
message context in which the data content object is operating.Contract for a provider that supports the conversion of a stream to a
Java type.
Contract for a provider that supports the conversion of a Java type to a
stream.
This class models Message change events.
This is the Listener interface for MessageChanged events
A client uses a
MessageConsumer object to receive messages
from a destination.The context in which a piece of Message content is contained.
The adapter which receives MessageCount events.
This class notifies changes in the number of messages in a folder.
This is the Listener interface for MessageCount events.
Component-defining annotation for a message driven bean.
The MessageDrivenBean interface defines methods that the EJB container uses
to notify a message driven bean instance of the instance's life cycle
events.
Specifies the statistics provided by a message driven bean.
The MessageDrivenContext interface provides access to the runtime
message-driven context that the container provides for a message-driven
bean instance.
This defines a contract for a message endpoint.
This serves as a factory for creating message endpoints.
This exception must be thrown when an unexpected
end of stream has been reached when a
StreamMessage or
BytesMessage is being read. This exception must be thrown when a JMS client
attempts to use a data type not supported by a message or attempts to
read data in a message as the wrong type.
This unchecked exception must be thrown when a JMS application attempts to
use a data type not supported by a message or attempts to read data in a
message as the wrong type, and the method signature does not permit a
MessageFormatException to be thrown.Developers implement MessageHandlers in order to receive incoming messages
during a web socket conversation.
This kind of handler is notified by the implementation as it becomes ready
to deliver parts of a whole message.
This kind of handler is notified by the container on arrival of a complete message.
This term models the RFC822 "MessageId" - a message-id for
Internet messages that is supposed to be unique per message.
A message processing runtime uses this interface to pass messages and
message processing state to authentication contexts for processing by
authentication modules.
Interpolates a given constraint violation message.
Information related to the interpolation context.
A
MessageListener object is used to receive asynchronously
delivered messages.This serves as a request-response message listener type that message
endpoints (message-driven beans) may implement.
This exception must be thrown when a JMS client attempts to read a
write-only message.
This exception must be thrown when a JMS client attempts to write to a
read-only message.
This unchecked exception must be thrown when a JMS client attempts to write
to a read-only message.
This class implements comparisons for Message numbers.
This class defines a message authentication policy.
This interface is used to represent message authentication policy.
This interface is used to represent and perform
message targeting.
This class defines the message protection policies for specific Targets.
A client uses a
MessageProducer object to send messages to a
destination.The exception thrown when an invalid method is invoked on an expunged
Message.
The base class for all exceptions thrown by the Messaging classes
There are concrete subclasses within the
implementation that map concepts in the Facelet VDL page to JSF Java API
calls the appropriate instances.
Provides access to the metamodel of persistent
entities in the persistence unit.
The root class of the abstraction that dictates
how attributes on a markup element in a Facelets VDL page are wired to the
JSF API object instance associated with that element.
A mutable set of rules to be used in
auto-wiring state to a particular object instance.
Every kind of markup element in Facelets VDL
that has attributes that need to take action on a JSF Java API artifact is
associated with an instance of this class.
Deprecated.
This has been replaced by
MethodExpression.Create a method call node in the current
Flow.Represents a method call node in the flow graph.
Describes a validated method.
An
Expression that refers to a method on an object.MethodExpressionValidator
is a
Validator that wraps a MethodExpression, and it
performs validation by executing a method on an object identified by
the MethodExpression.Holds information about a method that a
MethodExpression
evaluated to.Thrown when a method could not be found while evaluating a
MethodExpression.Deprecated.
This has been replaced by
MethodNotFoundException.The exception thrown when a method is not supported by the
implementation
Represents the type of a method: getter or non getter.
The Metric interface defines job metrics recorded by
the batch runtime.
The enum defining the specification-defined metric types.
This class represents a MIME body part.
This class represents a MIME style email message.
This inner class extends the javax.mail.Message.RecipientType
class to add additional RecipientTypes.
The MimeMultipart class is an implementation of the abstract Multipart
class that uses MIME conventions for the multipart data.
The MimePart interface models an Entity as defined
by MIME (RFC2045, Section 2.4).
A utility class that implements a DataSource out of
a MimePart.
This is a utility class that provides various MIME related
functionality.
The annotated element must be a number whose value must be higher or
equal to the specified minimum.
Defines several
Min annotations on the same element.
The built-in stereotype intended for use with beans that define the model layer of an MVC web application architecture such
as JSF.
Multipart is a container that holds multiple body parts.
Annotation that may be specified on a
Servlet
class, indicating that instances of the Servlet expect requests
that conform to the multipart/form-data MIME type.Java Class represntation of an
MultipartConfig annotation value.MultipartDataSource is a
DataSource that contains body
parts.A hash table based implementation of
MultivaluedMap interface.A map of key-values pairs.
Meta-annotation used to create name binding annotations for filters
and interceptors.
String-based qualifier.
A
NamedAttributeNode is a member element of a
NamedEntityGraph.Used to specify the path and boundaries for a find operation or query.
Used to group
NamedEntityGraph annotations.The presence of this annotation on a
class automatically registers the class with the runtime as a
ComponentSystemEvent for use with the <f:event />
tag in a page.Supports inline instantiation of the
Named qualifier.Specifies multiple native SQL named queries.
Specifies a named native SQL query.
Specifies multiple named Java Persistence query language queries.
Specifies a static, named query in the Java Persistence query language.
Specifies multiple named stored procedure queries.
Specifies and names a stored procedure, its parameters, and its result type.
A
NamedSubgraph is a member element of a
NamedEntityGraph.NamingContainer is an
interface that must be
implemented by any
UIComponent that wants to be a naming
container.
NavigationCase
represents a
<navigation-case> in the navigation
rule base, as well as the <from-view-id> with
which this <navigation-case> is a sibling.Create a navigation case in the current
Flow.Provides a simple implementation of
NavigationCase that can be subclassed by developers wishing to
provide specialized behavior to an existing NavigationCase
instance.A
NavigationHandler is passed the outcome string
returned by an application action invoked for this application, and will
use this (along with related state information) to choose the view to
be displayed next.
NavigationHandlerWrapper
provides a simple implementation of
NavigationHandler that
can be subclassed by developers wishing to provide specialized
behavior to an existing NavigationHandler instance.The annotated element must be a strictly negative number (i.e.
Defines several
Negative constraints on the same element.The annotated element must be a negative number or 0.
Defines several
NegativeOrZero constraints on the same element.
The
New qualifier was deprecated in CDI 1.1.Supports inline instantiation of the
New qualifier.Used to create a new HTTP cookie, transferred in a response.
This class models an RFC1036 newsgroup address.
An I/O exception thrown by
MessageBodyReader implementations
when reading a zero-length message content to indicate that the message body reader
is not able to produce an instance representing an zero-length message content.Base interface for building all kinds of flow nodes.
This exception indicates that a calendar-based timer will not
result in any more timeouts.
Excludes a member of an annotation type (such as a qualifier type or
interceptor binding type) from consideration when the container compares two annotation
instances.
Supports inline instantiation of the
Nonbinding annotation.Deprecated.
This has been replaced by
javax.enterprise.context.Dependent,
which is a CDI build-in scope with approximately similar semantics.
Indicates that the conversation context could not be restored.
Thrown by the persistence provider when
Query.getSingleResult() or TypedQuery.getSingleResult() is executed on a
query and there is more than one result from the query.Exception raised if no Bean Validation provider could be found.
Thrown by the persistence provider when
Query.getSingleResult() or TypedQuery.getSingleResult()is executed on a query
and there is no result to return.
Specifies that an annotation type is a normal scope type.
A NoSuchEJBException is thrown if an attempt is made to invoke
a business method on a stateful session or singleton object that no longer exists.
Used in JobOperator methods when referencing a job name value
which does not correspond to a job recognized by the
implementation's repository.
Used in JobOperator methods when referencing a job execution value
which does not correspond to a job execution recognized by the
implementation's repository.
Used in JobOperator methods when referencing a job instance value
which does not correspond to a job instance recognized by the
implementation's repository.
A NoSuchObjectLocalException is thrown if an attempt is made to invoke
a method on a local object (local EJB object or timer) that no longer exists.
This exception is thrown when Session attempts to instantiate a
Provider that doesn't exist.
A runtime exception indicating that a client request is
not acceptable
by the server.A runtime exception indicating a client requesting a resource method that is
not allowed.A runtime exception indicating request authorization failure caused by one of the following
scenarios:
a client did not send the required authorization credentials to access the requested resource,
i.e.
The annotated element must not be
null and must contain at least one
non-whitespace character.Defines several
@NotBlank constraints on the same element.The annotated element must not be
null nor empty.Defines several
@NotEmpty constraints on the same element.A runtime exception indicating a resource requested by a client was
not found on the server.Notification options are used to configure observer notification.
Notification options builder.
The annotated element must not be
null.Defines several
NotNull annotations on the same element.A
NotSupportedException is thrown to indicate that
callee (resource adapter
or application server for system contracts) cannot execute an operation
because the operation is not a supported feature.NotSupportedException exception indicates that the request cannot be
executed because the operation is not a supported feature.
A runtime exception indicating that the client request entity media type is
not supported.This class implements the logical NEGATION operator.
The annotated element must be
null.Defines several
Null annotations on the same element.Converter
implementation for java.lang.Number values.An
ObjectMessage object is used to send a message that contains
a serializable object in the Java programming language ("Java object").
Indicates that a checked exception was thrown by an observer method during event notification.
Represents an observer method of an enabled
bean.
An
ObserverMethodConfigurator can configure an ObserverMethod.Represents an operation that accepts a context of a fired event.
Identifies the event parameter of an observer method.
Identifies the event parameter of an asynchronous observer method.
This method level annotation can be used to decorate a Java method that wishes
to be called when a web socket session is closing.
This method level annotation can be used to decorate a Java method that wishes to be called in order
to handle errors.
Specifies a many-valued association with one-to-many multiplicity.
Specifies a single-valued association to another entity that has
one-to-one multiplicity.
This method level annotation can be used to make a Java method receive incoming web socket messages.
This method level annotation can be used to decorate a Java method that wishes to be called when a new
web socket session is open.
Thrown by the persistence provider when an optimistic locking conflict
occurs.
Indicates that the annotated method responds to HTTP OPTIONS requests.
An object that defines an ordering over the query results.
Specifies the ordering of the elements of a collection valued
association or element collection at the point when the association
or collection is retrieved.
Specifies a column that is used to maintain the persistent order of
a list.
This class implements the logical OR operator on individual SearchTerms.
Representation of a single outbound Server-sent event.
A builder class used for creating
OutboundSseEvent instances.Marks an attribute as overriding the attribute of a composing constraint.
Defines several
OverridesAttribute annotations on the same element
PageContext extends JspContext to provide useful context information for
when JSP technology is used in a Servlet environment.
Translation-time information on a JSP page.
Defines a contract for a delegate responsible for converting between a
String form of a message parameter value and the corresponding custom
Java type T.Mandates that a conversion of any
default value delegated
to a parameter converter annotated with @Lazy
annotation SHOULD occur only once the value is actually required (e.g.Contract for a provider of
ParamConverter instances.Represents a parameter in any of several
places where parameters are needed when processing flows.
Type for query parameter objects.
Describes a validated method or constructor parameter.
Type of criteria query parameter expressions.
This class holds MIME parameters (attribute-value pairs).
Specifies the mode of a parameter of a stored procedure query.
Provides names for method and constructor parameters.
The exception thrown due to an error in parsing RFC822
or MIME headers, including multipart bodies.
The
Part interface is the common base interface for
Messages and BodyParts. This class represents a part or form item that was received within a
multipart/form-data POST request.PartialResponseWriter
decorates an existing
ResponseWriter to support the
generation of a partial response suitable for Ajax operations.Components that want to leverage the
partial state saving feature must implement this interface instead of
implementing
StateHolder, from which this interface
inherits.PartialViewContext
contains methods and properties that pertain to partial request
processing and partial response rendering on a view.
PartialViewContextFactory is a
factory object that creates (if needed) and returns new
PartialViewContext instances.Provides
a simple implementation of
PartialViewContext that can
be subclassed by developers wishing to provide specialized behavior
to an existing PartialViewContext instance.PartitionAnalyzer receives control to process
data and final results from each partition.
PartitionCollector provides a way to pass data from
individual partitions to a single point of control running on
the step's parent thread.
PartitionMapper receives control at the start of a partitioned
execution.
PartitionPlan is a helper class that carries partition processing
information set by the @PartitionMapper method.
The PartitionPlanImpl class provides a basic implementation
of the PartitionPlan interface.
PartitionReducer provides unit of work demarcation across
partitions.
An enum used in
PartitionReducer.afterPartitionedStepCompletion(PartitionStatus).Indicates that a custom implementation of
Bean or
Contextual is passivation capable.Represents a text-based password, and includes a built-in mechanism for securely
clearing the value.
The class PasswordAuthentication is a data holder that is used by
Authenticator.
The class PasswordCredential acts as a holder for username and
password.
PasswordHash is an interface for objects that can generate and verify password hashes.Callback for PasswordValidation.
The annotated element must be an instant, date or time in the past.
Defines several
Past annotations on the same element.The annotated element must be an instant, date or time in the past or in the present.
Defines several
PastOrPresent annotations on the same element.Indicates that the annotated method responds to HTTP PATCH requests.
Represents a simple or compound attribute path from a
bound type or collection, and is a "primitive" expression.
Represents the navigation path from an object to another
in an object graph.
Identifies the URI path that a resource class or class method will serve
requests for.
Node representing a bean.
Node representing a constructor.
Node representing an element in a generic container such as
Optional,
List or Map.Node representing the element holding cross-parameter constraints
of a method or constructor.
Node representing a method.
Represents an element of a navigation path.
Node representing a parameter of a method or constructor.
Node representing a property.
Node representing the return value of a method or constructor.
This annotation may be used to annotate method parameters on server endpoints
where a URI-template has been used in the path-mapping of the
ServerEndpoint
annotation.Binds the value of a URI template parameter or a path segment
containing the template parameter to a resource method parameter, resource
class field, or resource class
bean property.
Represents a URI path segment and any associated matrix parameters.
The annotated
CharSequence must match the specified regular expression.Possible Regexp flags.
Defines several
Pattern annotations on the same element.Payload type that can be attached to a given
constraint declaration.
This interface represents the built-in
Pbkdf2PasswordHash implementation.Specifies that all security roles are allowed to invoke the specified
method(s) — i.e., that the specified method(s) are "unchecked".
A TagLibraryValidator class to allow a TLD to restrict what
taglibs (in addition to itself) may be imported on a page where it's
used.
Bootstrap class that is used to obtain an
EntityManagerFactory
in Java SE environments.Expresses a dependency on a container-managed
EntityManager and its
associated persistence context.Declares one or more
PersistenceContext annotations.Specifies whether a transaction-scoped or extended
persistence context is to be used in
PersistenceContext.Thrown by the persistence provider when a problem occurs.
Describes a single container or persistence provider property.
Interface implemented by the persistence provider.
Determine the list of persistence providers available in the
runtime environment.
Holds the global
PersistenceProviderResolver
instance.Expresses a dependency on an
EntityManagerFactory and its
associated persistence unit.Interface implemented by the container and used by the
persistence provider when creating an
EntityManagerFactory.Declares one or more
PersistenceUnit annotations.Specifies whether entity managers created by the
EntityManagerFactory will be JTA or
resource-local entity managers.Utility interface between the application and the persistence
provider managing the persistence unit.
Utility interface between the application and the persistence
provider(s).
Thrown by the persistence provider when an pessimistic locking conflict
occurs.
Defines the values of the
javax.persistence.lock.scope
property for pessimistic locking.PhaseEvent represents the beginning or ending of
processing for a particular phase of the request processing lifecycle,
for the request encapsulated by the specified
FacesContext.Typesafe enumeration of
the legal values that may be returned by the
getPhaseId() method of the FacesEvent interface.An interface implemented by objects that wish to be notified at
the beginning and ending of processing for each standard phase of the
request processing lifecycle.
Instances of the type
PluralAttribute represent
persistent collection-valued attributes.The
PluralJoin interface defines functionality
that is common to joins to all collection types.The methods of this interface are used by containers to
create policy statements in a Policy provider.
Abstract factory and finder class for obtaining
the instance of the class that implements the PolicyConfigurationFactory
of a provider.
This utility class is used by containers to communicate policy context
identifiers and other policy relevant context to
Policy
providers.This checked exception is thrown by implementations of the
javax.security.jacc.PolicyConfiguration Interface, the
javax.security.jacc.PolicyConfigurationFactory abstract class,
the javax.security.jacc.PolicyContext utility class, and
implementations of the
javax.security.jacc.PolicyContextException Interface.This interface defines the methods that must be implemented by handlers
that are to be registered and activated by the
PolicyContext
class.The PongMessage interface represents a web socket pong.
The annotated element must be a strictly positive number (i.e.
Defines several
Positive constraints on the same element.The annotated element must be a positive number or 0.
Defines several
PositiveOrZero constraints on the same element.Indicates that the annotated method responds to HTTP POST requests.
Designates a method to receive a callback after a stateful session
bean has been activated.
When an instance of this event is
passed to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is a UIComponent instance and that either that
instance or an ancestor of that instance was just added to the view.The
PostConstruct annotation is used on a method that
needs to be executed after dependency injection is done to perform
any initialization.This event must be published by the
runtime after all configuration resources have been parsed and
processed.
This class is provided to allow custom
scopes to publish a "post construct" event in the same way that other
scopes do to let the application become aware of the beginning of the
scope.
This event must be published by a call
to {javax.faces.application.Application#publishEvent} when the view
map is first created.
This event must be published by a call
to
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) when a value
is kept in the flash.Specifies a callback method for the corresponding
lifecycle event.
Specifies a callback method for the corresponding
lifecycle event.
This event must be published by a call
to
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) when a value
is stored in the flash.Specifies a callback method for the corresponding
lifecycle event.
When an instance of this event is passed to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event instance
is the UIViewRoot instance that has just been rendered.When an instance of this event is passed
to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is in a tree that has just had its state restored.Specifies a callback method for the corresponding
lifecycle event.
When an instance of
this event is passed to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is the UIComponent instance that is that has just
been validated.This event must be published by a call
to
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) before the flash
is cleared.The
PreDestroy annotation is used on a method as a
callback notification to signal that the instance is in the
process of being removed by the container.This event must be published by the
runtime before the factories associated with this
Application are released.This class is provided to allow custom
scopes to publish a "pre construct" event in the same way that other
scopes do to let the application become aware of the beginning of the
scope.
This event must be published by a call
to
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) when the
clear method is called on the map returned from UIViewRoot.getViewMap().The type of a simple or compound predicate: a conjunction or
disjunction of restrictions.
A MimeBodyPart that handles data that has already been encoded.
This
ExceptionHandlerFactory instance
produces JSF 1.2 compatible
ExceptionHandler instances.Global binding annotation that can be applied to a
container request filter to indicate that such filter should be applied globally
on all resources in the application before the actual resource matching occurs.Designates a method to receive a callback before a stateful session
bean is passivated.
Specifies a callback method for the corresponding
lifecycle event.
Specifies a callback method for the corresponding
lifecycle event.
This event must be published by a call
to
Application.publishEvent(javax.faces.context.FacesContext, java.lang.Class<? extends javax.faces.event.SystemEvent>, java.lang.Object) when a value
is removed from the flash.When an instance of this event is passed
to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is a UIComponent instance that is about to be
removed from the view.When an instance of this event is passed
to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is the UIComponent instance that is about to be
rendered and that it is safe to call UIComponent.getParent(), UIComponent.getClientId(), and other
methods that depend upon the component instance being in the
view.When an instance of this event is passed
to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is the UIViewRoot instance that is about to be
rendered.Specifies a callback method for the corresponding
lifecycle event.
When an instance of
this event is passed to
SystemEventListener.processEvent(javax.faces.event.SystemEvent) or
ComponentSystemEventListener.processEvent(javax.faces.event.ComponentSystemEvent), the listener
implementation may assume that the source of this event
instance is the UIComponent instance that is about to be
validated.Specifies a primary key column that is used as a foreign key to
join to another table.
Groups
PrimaryKeyJoinColumn annotations.A collection of built-in priority constants for the JAX-RS components that are supposed to be
ordered based on their
javax.annotation.Priority class-level annotation value when used
or applied by JAX-RS runtime.
This interface allows some SPI implementation to change their priority programmatically.
The
Priority annotation can be applied to classes
or parameters to indicate in what order they should be used.Callback for acquiring a Public Key Infrastructure (PKI) private key
and its corresponding certificate chain.
Request type for private keys that are identified using an alias.
Request type for private keys that are identified using a
certificate digest or thumbprint.
Request type for private keys that are identified using an
issuer/serial number.
Marker interface for private key request types.
Request type for private keys that are identified using a SubjectKeyID
The container fires an event of this type for each Java class or interface it discovers in a bean archive, before it reads
the declared annotations.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive, before
registering the
Bean object.
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive before
registering the
Bean object.A base JAX-RS runtime processing exception.
The container fires an event of this type for every injection point of every Java EE component class supporting injection
that may be instantiated by the container at runtime, including every managed bean declared using
javax.annotation.ManagedBean, EJB session or message-driven bean, enabled bean, enabled interceptor or enabled
decorator.
The container fires an event of this type for every Java EE component class supporting injection that may be instantiated by
the container at runtime, including every managed bean declared using
javax.annotation.ManagedBean, EJB session or
message-driven bean, enabled bean, enabled interceptor or enabled decorator.
The container fires an event of this type for each enabled managed bean, before registering the
Bean object.
The container fires an event of this type for each observer method of each
enabled bean, before registering the
ObserverMethod object.
The container fires an event of this type for each producer method or field of
each enabled bean, including resources.
The container fires an event of this type for each enabled producer field, before registering the
Bean object.
The container fires an event of this type for each enabled producer method, before registering the
Bean object.
The container fires an event of this type for each enabled session bean, before registering the
Bean object.
The container fires an event of this type for each Java class or interface added by
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType),
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType, String) or
AfterTypeDiscovery.addAnnotatedType(AnnotatedType, String)
The container fires an event of this type for each custom bean implementation added through
AfterBeanDiscovery.addBean() or AfterBeanDiscovery.addBean(Bean), before registering the
Bean object.
The container fires an event of this type for each custom implementation of
ObserverMethod added through
AfterBeanDiscovery.addObserverMethod(ObserverMethod) or AfterBeanDiscovery.addObserverMethod(), before
registering the ObserverMethod object.
Provides a generic operation for producing an instance of a type.
A
ProducerConfigurator can configure a Producer.
An
ProducerFactory can create an Producer for a given bean.
Identifies a producer method or field.
Defines the media type(s) that the methods of a resource class or
MessageBodyWriter can produce.This class enables a feature similar to
the
RAILS_ENV feature of the Ruby on Rails web
framework.Describes a Java Bean property hosting validation constraints.
Allows to define custom property naming strategy.
Thrown when a property could not be found while evaluating a
ValueExpression or MethodExpression.Deprecated.
This has been replaced by
PropertyNotFoundException.Thrown when a property could not be written to while setting the
value on a
ValueExpression.Specifies predefined property order strategies.
Deprecated.
This has been replaced by
ELResolver.Provides mechanism how to define customized property visibility strategy.
This exception is thrown by the runtime
when a violation of the view protection mechanism is encountered.
Provides instances of
T.The Provider is a class that describes a protocol
implementation.
Marks an implementation of an extension interface that should be discoverable
by JAX-RS runtime during a provider scanning phase.
This inner class defines the Provider type.
An injectable interface providing runtime lookup of provider instances.
Defines the state used to bootstrap Bean Validation and
creates a provider specific
Configuration
of type T.Utility interface implemented by the persistence provider.
The CDI annotation
@Push allows you to inject a PushContext associated with a given
<f:websocket> channel in any container managed artifact in WAR.Build a request to be pushed.
CDI interface to send a message object to the push socket channel as identified by
@Push.Indicates that the annotated method responds to HTTP PUT requests.
Identifies qualifier annotations.
Supports inline instantiation of the
Qualifier annotation.Interface used to control query execution.
Used to supply a query property or hint to the
NamedQuery or NamedNativeQuery annotation.Binds the value(s) of a HTTP query parameter to a resource method parameter,
resource class field, or resource class bean property.
Thrown by the persistence provider when a query times out
and only the statement is rolled back.
A
Queue object encapsulates a provider-specific queue name.A client uses a
QueueBrowser object to look at messages on a
queue without removing them.A
QueueConnection object is an active connection to a
point-to-point JMS provider.A client uses a
QueueConnectionFactory object to create
QueueConnection objects with a point-to-point JMS provider.A client uses a
QueueReceiver object to receive messages that
have been delivered to a queue.The
QueueRequestor helper class simplifies
making service requests.A client uses a
QueueSender object to send messages to a queue.A
QueueSession object provides methods for creating
QueueReceiver, QueueSender,
QueueBrowser, and TemporaryQueue objects.This class represents a set of quotas for a given quota root.
An individual resource in a quota root.
An interface implemented by Stores that support quotas.
Specifies standard measurements of the lowest and highest values an attribute has held as well as its current value.
Interface for message body reader interceptors that wrap around calls
to
MessageBodyReader.readFrom(java.lang.Class<T>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.String>, java.io.InputStream).Context class used by
ReaderInterceptor
to intercept calls to (@link javax.ws.rs.ext.MessageBodyReader#readFrom}.
This class represents a call-back mechanism that will notify implementations
as HTTP request data becomes available to be read without blocking.
This exception is thrown when an attempt is made to open a folder
read-write access when the folder is marked read-only.
This class implements comparisons for the Message Received date
Distinguishes conditional observer methods from observer methods which are
always notified.
This class implements string comparisons for the Recipient Address
headers.
This class implements comparisons for the Recipient Address headers.
The
javax.resource.cci.Record interface is the base
interface for the representation of an input or output to the
execute methods defined on an Interaction.The RecordFactory interface is used for creating MappedRecord and
IndexedRecord instances.
A runtime application exception indicating a request redirection
(HTTP
3xx status codes).The Referenceable interface extends the javax.naming.Referenceable
interface.
Deprecated.
The referenced-bean concept was used for a design time promise
which however did not achieve widespread adoption.
Deprecated.
This has been replaced by
ELException.A Validator that checks
against a Regular Expression (which is the pattern property).
Interface through which a
Servlet or Filter registered
via one of the addServlet or addFilter methods,
respectively, on ServletContext may be further configured.An implementation of this interface may be associated with an
AuthConfigProvider registration at an AuthConfigFactory at the
time the AuthConfigProvider is obtained for use from the factory.
The RememberMe annotation provides an application the ability to declaratively designate
that an authentication mechanism effectively "remembers" the authentication and auto
applies this with every request.
RememberMeCredential represents a credential presented as a token,
for the explicit usage with the JSR 375 provided remember me function.RememberMeIdentityStore is a mechanism for validating a caller's
credentials and accessing a caller's identity attributes that's specifically
tailored for the "remember me" feature.Declares the remote business interface(s) for a session bean.
The RemoteEndpoint object is supplied by the container and represents the
'other end' or peer of the Web Socket conversation.
This representation of the peer of a web socket conversation has the ability
to send messages asynchronously.
This representation of the peer of a web socket conversation has the ability
to send messages synchronously.
Declares the remote home interface or adapted remote home interface
for a session bean.
Applied to a business method of a stateful session bean class to indicate
to the container that the stateful session bean is to be removed by the
container after completion of the method.
The RemoveException is thrown at an attempt to remove an
EJB object or local EJB object when the enterprise bean or the
container does not allow the EJB object to be removed.
A Renderer converts
the internal representation of
UIComponents into the output
stream (or writer) associated with the response we are creating for a
particular request.RenderKit
represents a collection of
Renderer instances that, together,
know how to render JavaServer Faces UIComponent instances for
a specific client.RenderKitFactory is a
factory object that registers
and returns
RenderKit instances.A constraint annotation hosting this annotation will return the
composed annotation error report if any of the composing annotations fail.
An injectable helper for request processing, all methods throw an
IllegalStateException if called outside the scope of a request
(e.g.The CDI container provides a built in instance of RequestContextController that is dependent scoped for the purposes
of activating and deactivating.
The presence of this annotation (along
with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getRequestCookieMap() to be
injected as the value of that field.Defines an object that receives requests from the client
and sends them to any resource (such as a servlet,
HTML file, or JSP file) on the server.
The presence of this annotation (along
with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getRequestMap() to be
injected as the value of that field.The presence of this annotation (along
with
@Inject) on a field of type Map<String,
String> causes the map returned from ExternalContext.getRequestParameterMap() to be
injected as the value of that field.The presence of this annotation (along
with
@Inject) on a field of type Map<String,
String []> causes the map returned from ExternalContext.getRequestParameterValuesMap() to be
injected as the value of that field.
Specifies that a bean is request scoped.
Deprecated.
This has been replaced by
javax.enterprise.context.RequestScoped,
which is a CDI build-in scope with similar semantics.Supports inline instantiation of the
RequestScoped annotation.A Validator that checks for an empty
value in the same way that UIInput checks for a value.
The
Resource annotation marks a resource that is needed
by the application.An
instance of
Resource is a Java object representation of the artifact
that is served up in response to a resource request from the
client.The two possible authentication types for a resource.
This represents a resource adapter instance and contains operations for
lifecycle management and message endpoint setup.
This interface specifies the methods to associate a
ResourceAdapter object with other objects that
implement this interface like
ManagedConnectionFactory and ActivationSpec.A
ResourceAdapterInternalException indicates any
system-level error conditions related to a resource adapter.The interface
javax.resource.cci.ResourceAdapterMetaData
provides information about capabilities of a resource adapter
implementation.This exception is thrown when a provider is unable to allocate the
resources required by a method.
A
ResourceAllocationException can be thrown by an
application server or
resource adapter to indicate any failure to allocate system resources
(example: threads, physical connections).This unchecked exception is thrown when a provider is unable to allocate the
resources required by a method.
Defines property resolution behavior on instances of
ResourceBundle.The resource context provides access to instances of resource classes.
Container annotation to specify multiple
ResourceDependency annotations on a single class.Instances of
UIComponent or Renderer that have this annotation (or ResourceDependencies attached at the class level will automatically
have a resource dependency added so that the named resource will be
present in user agent's view of the UIViewRoot in which
this component or renderer is used.This is the root interface of the exception hierarchy defined
for the Connector architecture.
ResourceHandler is the run-time API by
which
UIComponent and Renderer instances, and the ViewDeclarationLanguage can reference Resource instances. An implementation of this class must be
thread-safe.Provides a simple implementation of
ResourceHandler that can be subclassed by developers wishing
to provide specialized behavior to an existing ResourceHandler instance.An injectable class to access the resource class and resource method
matched by the current request.
Deprecated.
This class is used to allow multiple resources declarations.
Defines the resource traversal options.
A
ResourceWarning provides information on warnings related to
execution of an interaction with an EIS.Defines the contract between a returned instance and the runtime when
an application needs to provide meta-data to the runtime.
A class used to build Response instances that contain metadata instead
of or in addition to an entity.
Commonly used status codes defined by HTTP, see
{@link <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10">HTTP/1.1 documentation}
for the complete list.
An enumeration representing the class of status code.
Base interface for statuses used in responses.
JAX-RS client-side runtime processing exception thrown to indicate that
response processing has failed (e.g.
ResponseStateManager
is the helper class to
StateManager
that knows the specific rendering technology being used to generate
the response.ResponseStream is an interface describing an adapter
to an underlying output mechanism for binary output.
ResponseWriter
is an abstract class describing an adapter to an underlying output
mechanism for character-based output.
Provides a simple implementation
of
ResponseWriter that
can be subclassed by developers wishing to provide specialized
behavior to an existing ResponseWriter instance.This interface represents the result of a <sql:query>
action.
ResultDataModel is a convenience implementation of
DataModel that wraps a JSTL Result object, typically
representing the results of executing an SQL query via JSTL tags.A ResultSet represents tabular data that is retrieved from an EIS
instance by the execution of an Interaction..
ResultSetDataModel is a convenience implementation of
DataModel that wraps a ResultSet of Java objects.The interface
javax.resource.cci.ResultSetInfo provides
information on the support provided for ResultSet by a connected
EIS instance.Supports the creation of a javax.servlet.jsp.jstl.sql.Result object
from a source java.sql.ResultSet object.
A marker interface indicating that the Exception is transient.
A subclass of the
UnavailableException that
indicates that the rejection of the work submission is transient.A subclass of the
WorkRejectedException that
indicates that the the service unavailability is transient.RetryProcessListener intercepts retry processing for
an ItemProcessor.
RetryReadListener intercepts retry processing for
an ItemReader.
RetryWriteListener intercepts retry processing for
an ItemWriter.
Create a return node in the current
Flow.Represents a return node in the flow graph.
Describes a validated return value of a method or constructor.
Specifies the list of security roles permitted to access method(s) in an
application.
Thrown by the persistence provider when
EntityTransaction.commit() fails.RollbackException exception is thrown when the transaction has been
marked for rollback only or the transaction has been rolled back
instead of committed.
A root type in the from clause.
Defines the identity of the application during execution.
Implementations of JAX-RS provide a concrete subclass of RuntimeDelegate and
various JAX-RS API methods defer to methods of RuntimeDelegate for their
functionality.
Defines the contract for a delegate that is responsible for
converting between the String form of a HTTP header and
the corresponding JAX-RS type
T.Enumeration of JAX-RS runtime types.
Uniform interface for reactive invocation of HTTP methods.
RxInvoker provider.ScalarDataModel is a convenience implementation of
DataModel that wraps an individual Java object.Schedule a timer for automatic creation with a timeout schedule based
on a cron-like time expression.
A calendar-based timeout expression for an enterprise bean
timer.
Applied to a timer callback method to schedule multiple calendar-based
timers for the method.
Identifies scope annotations.
Scope looked at when discovering constraints.
A structure that contains the name of
the scope and the scope itself exposed as a
Map<String,
Object>.Defines variable resolution behavior for scoped attributes.
A TagLibraryValidator for enforcing restrictions against
the use of JSP scripting elements.
The exception thrown when a Search expression could not be handled.
A context object that is used to hold
state relating to resolve a search expression.
Provide for separation of interface and
implementation for the
SearchExpressionContext contract.The SearchExpressionHandler is responsible for
resolving search expression(s)
Provides a simple implementation of
SearchExpressionHandler that can
be subclassed by developers wishing to provide specialized behavior
to an existing SearchExpressionHandler instance.An
enum that specifies hints that impact
the behavior of a component tree search.
SearchKeywordContext
provides context information that may be useful to
SearchKeywordResolver.resolve(javax.faces.component.search.SearchKeywordContext, javax.faces.component.UIComponent, java.lang.String) implementations.A SearchKeywordResolver is responsible for
resolving a single keyword.
Search criteria are expressed as a tree of search-terms, forming
a parse-tree for the search expression.
Specifies a secondary table for the annotated entity
class.
Specifies multiple secondary tables for an entity.
Provides access to the current container in Java SE.
A CDI container initializer for Java SE.
Callback for acquiring a shared secret from a key repository.
Request type for secret keys that are identified using an alias.
Marker interface for secret key request types.
A standard
WorkContext that allows a Work
instance to propagate security related context information from an EIS to an
application server.The SecurityContext provides an access point for programmatic security; an injectable type that is intended to be
used by application code to query and interact with the Java EE Security API.
An injectable interface that provides access to security related
information.
A
SecurityException indicates error conditions
related to the security
contract between an application server and resource adapter.The SecurityPermission annotation can be used by the developer, as part of
the Connector annotation, to specify the extended security permissions
required by the resource adapter
The
Selection interface defines an item that is to be
returned in a query result.SelectItem represents a single
item in the list of supported items associated with
a
UISelectMany or UISelectOne component.SelectItemGroup is a subclass of
SelectItem that
identifies a set of options that will be made available as a subordinate
"submenu" or "options list", depending upon the requirements of the
UISelectMany or UISelectOne renderer that is actually used.This exception is thrown when the message cannot be sent.
A simple callback object for asynchronous sending of web socket messages.
The result of asynchronously sending a web socket message.
This class implements comparisons for the Message SentDate.
Defines a primary key generator that may be referenced by name when
a generator element is specified for the
GeneratedValue
annotation.Used to group
SequenceGenerator annotations.Provides JSONB internals for custom serializers.
Developers include implementations of ServerApplicationConfig in an archive containing
websocket endpoints (WAR file, or JAR file within the WAR file) in order to specify the websocket
endpoints within the archive the implementation must deploy.
An implementation of this interface is used to validate received service
request messages, and to secure service response messages.
This interface describes a configuration of ServerAuthConfiguration objects
for a message layer and application context (for example, the messaging context of
a specific application, or set of applications).
This ServerAuthContext class encapsulates ServerAuthModules that are used
to validate service requests received from clients, and to secure any
response returned for those requests.
A ServerAuthModule validates client requests and secures responses
to the client.
The ServerContainer is the specialized view of the WebSocketContainer available
in server-side deployments.
This class level annotation declares that the class it decorates
is a web socket endpoint that will be deployed and made available in the URI-space
of a web socket server.
The ServerEndpointConfig is a special kind of endpoint configuration object that contains
web socket configuration information specific only to server endpoints.
The ServerEndpointConfig.Builder is a class used for creating
ServerEndpointConfig.Builder objects for the purposes of
deploying a server endpoint.The ServerEndpointConfig.Configurator class may be extended by developers who want to
provide custom configuration algorithms, such as intercepting the opening handshake, or
providing arbitrary methods and algorithms that can be accessed from each endpoint
instance configured with this configurator.
A base runtime application exception indicating a server error
(HTTP
5xx status codes).A
ServerSession object is an application server object that
is used by a server to associate a thread with a JMS session (optional).A
ServerSessionPool object is an object implemented by an
application server to provide a pool of ServerSession objects
for processing the messages of a ConnectionConsumer (optional).An abstract class that contains the functionality
common to messaging services, such as stores and transports.
A runtime exception indicating that the requested resource
cannot be served.Defines methods that all servlets must implement.
A servlet configuration object used by a servlet container
to pass information to a servlet during initialization.
Interface which allows a library/runtime to be notified of a web
application's startup phase and perform any required programmatic
registration of servlets, filters, and listeners in response to it.
Defines a set of methods that a servlet uses to communicate with its
servlet container, for example, to get the MIME type of a file,
dispatch requests, or write to a log file.
Event class for notifications about changes to the attributes of
the ServletContext of a web application.
Interface for receiving notification events about ServletContext
attribute changes.
This is the event class for notifications about changes to
the servlet context of a web application.
Interface for receiving notification events about ServletContext
lifecycle changes.
Defines a general exception a servlet can throw when it
encounters difficulty.
Provides an input stream for reading binary data from a client
request, including an efficient
readLine method
for reading data one line at a time.Provides an output stream for sending binary data to the
client.
Interface through which a
Servlet may be further configured.Interface through which a
Servlet registered via one of the
addServlet methods on ServletContext may be further
configured.Defines an object to provide client request information to a servlet.
This is the event class for notifications of changes to the
attributes of the servlet request in an application.
Interface for receiving notification events about ServletRequest
attribute changes.
Events of this kind indicate lifecycle events for a ServletRequest.
Interface for receiving notification events about requests coming
into and going out of scope of a web application.
Provides a convenient implementation of the ServletRequest interface that
can be subclassed by developers wishing to adapt the request to a Servlet.
Defines an object to assist a servlet in sending a response to the client.
Provides a convenient implementation of the ServletResponse interface that
can be subclassed by developers wishing to adapt the response from a Servlet.
This annotation is used on a Servlet implementation class to specify security
constraints to be enforced by a Servlet container on HTTP protocol messages.
Defines the access semantic to be applied to an empty rolesAllowed array.
Defines the data protection requirements that must be satisfied by
the transport
Java Class representation of a
ServletSecurity annotation value.Specifies the statistics provided by a Servlet.
A
Session object is a single-threaded context for producing and consuming
messages.The Session class represents a mail session and is not subclassed.
A Web Socket session represents a conversation between two web socket endpoints.
The SessionBean interface defines methods that the EJB container uses
to notify a session bean instance of the instance's life cycle events.
Specifies the statistics provided by session beans of both stateful and stateless types.
Identifies the kind of EJB session bean.
The SessionContext interface provides access to the runtime session context
that the container provides for a session bean instance.
Class that may be used to configure various properties of cookies
used for session tracking purposes.
A SessionException represents a general exception type reporting problems
occurring on a websocket session.
The presence of this annotation (along
with
@Inject) on a field of type Map<String,
Object> causes the map returned from ExternalContext.getSessionMap() to be
injected as the value of that field.
Specifies that a bean is session scoped.
Deprecated.
This has been replaced by
javax.enterprise.context.SessionScoped,
which is a CDI build-in scope with similar semantics.Supports inline instantiation of the
SessionScoped annotation. The SessionSynchronization interface allows a stateful session
bean instance to be notified by its container of transaction
boundaries.
Enumeration of session tracking modes.
Instances of the type
SetAttribute represent
persistent java.util.Set-valued attributes.The
SetJoin interface is the type of the result of
joining to a collection over an association or element
collection that has been specified as a java.util.Set.A ByteArrayInputStream that implements the SharedInputStream interface,
allowing the underlying byte array to be shared between multiple readers.
Specifies how the provider must use a second-level cache for the
persistence unit.
A
SharedFileInputStream is a
BufferedInputStream that buffers
data from the file and supports the mark
and reset methods.An InputStream that is backed by data that can be shared by multiple
readers may implement this interface.
This is thrown to indicate a connection sharing violation.
Converter implementation for java.lang.Short
(and short primitive) values.Interface for defining Simple Tag Handlers.
A base class for defining tag handlers implementing SimpleTag.
Deprecated.
As of Java Servlet API 2.4, with no direct
replacement.
Component-defining annotation for a singleton session bean.
Identifies a type that the injector only instantiates once.
Supports inline instantiation of the
Singleton annotation.Instances of the type
SingularAttribute represents persistent
single-valued properties or fields.The annotated element size must be between the specified boundaries (included).
Defines several
Size annotations on the same element.This class implements comparisons for Message sizes.
Exception to indicate the calling page must cease evaluation.
Exception indicating that the result of a value-producing task cannot be
retrieved because the task run was skipped.
SkipProcessListener intercepts skippable
itemProcess exception handling.
SkipReadListener intercepts skippable
itemReader exception handling.
SkipWriteListener intercepts skippable
itemWriter exception handling.
Indicates that a bean directly specializes another bean.
Supports inline instantiation of the
Specializes annotation.This interface allows tag handlers implementing it to receive
values for parameter markers in their SQL statements.
Specifies the mapping of the result of a native SQL query or stored
procedure.
Is used to define one or more
SqlResultSetMapping annotations.Server-side entry point for creating
OutboundSseEvent and SseBroadcaster.Server-Sent events broadcasting facility.
Base Server Sent Event definition.
Outbound Server-Sent Events stream.
Client for reading and processing
incoming Server-Sent Events.JAX-RS
SseEventSource builder class.A standard ELContext suitable for use in a stand alone environment.
Mark a singleton bean for eager initialization during the application startup sequence.
Component-defining annotation for a stateful session bean.
Specifies the statistics provided by a stateful session bean.
Specifies the amount of time a stateful session bean can
be idle (not receive any client invocations) before it
is eligible for removal by the container.
Define a
Map-like contract
that makes it easier for components to implement PartialStateHolder.This interface is
implemented by classes that need to save their state between
requests.
Component-defining annotation for a stateless session bean.
Specifies the statistics provided by a stateless session bean.
Encapsulate the saving and
restoring of the view to enable the VDL to take over the
responsibility for handling this feature.
StateManager
directs the process of saving and
restoring the view between requests.
Provides a simple implementation of
StateManager that can
be subclassed by developers wishing to provide specialized behavior
to an existing StateManager instance.An
ELResolver for resolving static fields, enum constants and
static methods.The
StaticMetamodel annotation specifies that the class
is a metamodel class that represents the entity, mapped
superclass, or embeddable class designated by the value
element.The Statistic model and its sub-models specify the data models which are requried to be used to provide the performance data described by the specific attributes in the Stats models.
The Stats model and its submodels specify performance data attributes for each of the specific managed object types.
The Status interface defines static variables used for transaction
status codes.
A StepContext provides information about the current step
of a job execution.
Provides a view of a step execution to the JobOperator.
StepListener intercepts step execution.
Specifies that an annotation type is a stereotype.
An abstract class that models a message store and its
access protocol, for storing and retrieving messages.
This exception is thrown when a method is invoked on a Messaging object
and the Store that owns that object has died due to some reason.
Specifies a parameter of a named stored procedure query.
Interface used to control stored procedure query execution.
This class models notifications from the Store connection.
This is the Listener interface for Store Notifications.
Streamable interface enables a resource adapter to extract data from
an input Record or set data into an output Record as a stream of
bytes.
A type that may be used as a resource method return value or as the entity
in a
Response when the application wishes to stream the output.A
StreamMessage object is used to send a stream of primitive
types in the Java programming language.This class implements the match method for Strings.
This type represents a subgraph for an attribute node that
corresponds to a Managed Type.
This class implements comparisons for the message Subject header.
The
Subquery interface defines functionality that is
specific to subqueries.Defines the target(s) a
ConstraintValidator can validate.Inject a suspended
AsyncResponse into a parameter of an invoked
JAX-RS resource or sub-resource method.Create a switch node in the current
Flow.Represents a case within a switch node in the flow graph.
Create a case in the current switch.
Represents a switch node in the flow graph.
The transaction manager supports a synchronization mechanism
that allows the interested party to be notified before and
after the transaction completes.
Specifies whether the persistence context is always automatically
synchronized with the current transaction or whether the persistence context
must be explicitly joined to the current transaction by means of the
EntityManager.joinTransaction() method.Uniform interface for synchronous invocation of HTTP methods.
SystemEvent
is the base class for non-application specific events that can be fired by
arbitrary objects.
By implementing this class, an object
indicates that it is a listener for one or more kinds of
SystemEvents.Classes that implement this interface
agree to maintain a list of
SystemEventListener instances
for each kind of SystemEvent they can generate.The SystemException is thrown by the transaction manager to
indicate that it has encountered an unexpected error condition
that prevents future transaction services from proceeding.
Specifies the primary table for the annotated entity.
Defines a primary key generator that may be
referenced by name when a generator element is specified for
the
GeneratedValue annotation.Used to group
TableGenerator annotations.The runtime must create an instance of this
class for each element in the Facelets XHTML view.
The interface of a classic tag handler that does not want to manipulate
its body.
Wraps any SimpleTag and exposes it using a Tag interface.
Representation
of an XML attribute name=value pair on an XML element in a Facelet file.
An Exception caused by a
TagAttributeInformation on the attributes of a Tag, available at translation time.
A set
of TagAttributes, usually representing all attributes on a Tag.
Passed to the constructor of
TagHandler subclass, it defines the document definition of the
handler we are instantiating.The (translation-time only) attribute/value information for a tag instance.
Provides the ability to completely
change the Tag before it's processed for compiling with the
associated
TagHandler.An Exception caused by a
TagOptional class provided by the tag library author to describe additional
translation-time information not described in the TLD.
Tag information for a tag file in a Tag Library;
This class is instantiated from the Tag Library Descriptor file (TLD)
and is available only at translation time.
Foundation class for
FaceletHandlers associated with a markup element in a
Facelet document.Abstract
class that defines methods
relating to helping tag handler instances.
Abstract
factory for creating instances of
TagHandlerDelegate.Tag information for a tag in a Tag Library;
This class is instantiated from the Tag Library Descriptor file (TLD)
and is available only at translation time.
This interface provides access to the
<taglib>
related configuration of a web application.Translation-time information associated with a taglib directive, and its
underlying TLD file.
Translation-time validator class for a JSP page.
A base class for defining new tag handlers implementing Tag.
Variable information for a tag in a Tag Library;
This class is instantiated from the Tag Library Descriptor file (TLD)
and is available only at translation time.
This annotation must be specified for persistent fields
or properties of type
java.util.Date and
java.util.Calendar.Type used to indicate a specific mapping of
java.util.Date
or java.util.Calendar.A
TemporaryQueue object is a unique Queue object
created for the duration of a Connection.A
TemporaryTopic object is a unique Topic object
created for the duration of a Connection.An interface that allows other code
to identify FaceletHandlers that may provide text (String) content.
A
TextMessage object is used to send a message containing a
java.lang.String.The
TimedObject interface contains a callback method
that is used to deliver timer expiration notifications.Designates a method on a stateless session bean class, a singleton
session bean class, a message driven bean class, or an EJB 2.x entity bean
class that should receive EJB timer expirations for that bean.
Asynchronous response suspend time-out handler.
The
Timer interface contains information about a timer
that was created through the EJB Timer Service.TimerConfig is used to specify additional timer configuration settings during
timer creation.
The TimerHandle interface allows the bean provider to obtain a
serializable timer handle that may be persisted.
The TimerService interface provides enterprise bean components with
access to the container-provided Timer Service.
Specifies standard timing measurements.
A
Topic object encapsulates a provider-specific topic name.A
TopicConnection object is an active connection to a
publish/subscribe JMS provider.A client uses a
TopicConnectionFactory object to create
TopicConnection objects with a publish/subscribe JMS provider.A client uses a
TopicPublisher object to publish messages on a
topic.The
TopicRequestor helper class simplifies
making service requests.A
TopicSession object provides methods for creating
TopicPublisher, TopicSubscriber, and
TemporaryTopic objects.A client uses a
TopicSubscriber object to receive messages that
have been published to a topic.The Transaction interface allows operations to be performed against
the transaction in the target Transaction object.
The javax.transaction.Transactional annotation provides the application
the ability to declaratively control transaction boundaries on CDI managed beans, as
well as classes defined as managed beans by the Java EE specification, at both the class
and method level where method level annotations override those at the class level.
The TxType element of the annotation indicates whether a bean method is to be
executed within a transaction context where the values provide the following
corresponding behavior.
The TransactionalException thrown from the Transactional interceptors
implementation contains the original exception as its nested exception
and is a RuntimeException, therefore, by default any
transaction that was started as a result of a Transactional annotation
earlier in the call stream will be marked for rollback as a result of
the TransactionalException being thrown by the Transactional interceptor
of the second bean.
The
TransactionAttribute annotation specifies whether
the container is to invoke a business method within a transaction
context.The enum
TransactionAttributeType is used with the
TransactionAttribute annotation to specify whether the
methods of a session bean or message driven bean are called with a
valid transaction context.A standard
WorkContext that allows a Work instance
to propagate transaction related context information from an EIS to an
application server. This exception is thrown when an
operation is invalid because a transaction is in progress.
This unchecked exception is thrown when an
operation is invalid because a transaction is in progress.
Specifies whether a session bean or message driven bean has
container managed transactions or bean managed transactions.
The enum
TransactionManagementType is used with the
TransactionManagement annotation to specify whether
container-managed or bean-managed transaction management is used.The TransactionManager interface defines the methods that allow an
application server to manage transaction boundaries.
Distinguishes the various kinds of transactional observer methods from regular
observer methods which are notified immediately.
Thrown by the persistence provider when a transaction is required but is not
active.
This exception indicates that a request carried a null transaction context,
but the target object requires an active transaction.
This exception is thrown to a local client to indicate that a
request carried a null transaction context, but the target object
requires an active transaction.
This exception indicates that the transaction associated with processing
of the request has been rolled back, or it has been marked to roll back.
This exception must be thrown when a
call to
Session.commit results in a rollback of the current
transaction.This exception is thrown to a local client to indicate that the
transaction associated with processing of the request has been
rolled back, or marked to roll back.
This unchecked exception must be thrown when a call to
JMSContext.commit results in a rollback of the current
transaction.The javax.transaction.TransactionScoped annotation provides the ability to
specify a standard CDI scope to define bean instances whose lifecycle is
scoped to the currently active JTA transaction.
This interface may be optionally implemented by a
ManagedConnectionFactory to provide its level of transaction
support at runtime.An enumerated type that represents the levels of transaction support
a resource adapter may support.
This interface is intended for use by system level application server
components such as persistence managers, resource adapters, as well as
EJB and Web application components.
Specifies that the property or field is not persistent.
If a parameter annotated with @TransientReference resolves to a dependent scoped bean, then the bean will be
destroyed after the invocation completes.
Supports inline instantiation of the
TransientReference annotation.Define a
Map-like contract
that makes it easier for components to implement TransientStateHolder.This interface is implemented by classes
that need to save state that is expected to be available only within the scope
of the current request.
An abstract class that models a message transport.
The adapter which receives Transport events.
This class models Transport events.
This is the Listener interface for Transport events
Contract determining if a property can be accessed by the Bean Validation provider.
Triggers allow application developers to plug in rules for when
and how often a task should run.
Callback for trusted certificate KeyStore.
The auxiliary interface of a Tag, IterationTag or BodyTag tag
handler that wants additional hooks for managing resources.
Interface for extracting the elements of a query result tuple.
The
TupleElement interface defines an element that is returned in
a query result tuple.Instances of the type
Type represent persistent object
or attribute types.A convenient class for writing an ELResolver to do custom type conversions.
Restricts the bean types of a bean.
Supports inline instantiation of the
Typed annotation.Interface used to control the execution of typed queries.
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
UIColumn is a
UIComponent that represents
a single column of data within a parent UIData component.UICommand is a
UIComponent that represents
a user interface component which, when activated by the user, triggers
an application specific "command" or "action".UIComponent is the base class for all
user interface components in JavaServer Faces.
UIComponentBase is a
convenience base class that implements the default concrete behavior
of all methods defined by
UIComponent.Deprecated.
All component tags now implement
BodyTag.UIComponentTagBase is the base class
for all JSP tags that use the "classic" JSP tag interface that
correspond to a UIComponent instance in
the view.UIComponentELTag specializes its superclass to allow for
properties that take their values from EL API expressions.Deprecated.
Use of this class has been replaced with
UIComponentELTag, which extends
UIComponentClassicTagBase to add properties that use the
EL API introduced as part of JSP 2.1.UIComponentTagBase is the base class
for all JSP tags that correspond to a UIComponent instance in the view.UIData is a
UIComponent that
supports data binding to a collection of data objects represented by
a DataModel instance, which is the current value of this
component itself (typically established via a ValueExpression).The
UIDFolder interface is implemented by Folders
that can support the "disconnected" mode of operation, by providing
unique-ids for messages in the folder.A fetch profile item for fetching UIDs.
UIForm is a
UIComponent that represents an input form to be presented to the
user, and whose child components represent (among other things) the
input fields to be included when the form is submitted.UIGraphic is a
UIComponent that displays
a graphical image to the user.UIInput is a
UIComponent that represents a component that both displays output to
the user (like UIOutput components do) and processes request
parameters on the subsequent request that need to be decoded.This component is
responsible for displaying messages for a specific
UIComponent, identified by a clientId or component id relative to the
closest ancestor NamingContainer.The renderer for this component is responsible for obtaining the
messages from the
FacesContext and displaying them to the
user.UINamingContainer is a
convenience base class for components that wish to implement
NamingContainer functionality.This
component is paired with the
javax.faces.Button or javax.faces.Link
renderers and encapsulates properties relating to the rendering of
outcomes directly to the response.UIOutput is a
UIComponent that has a value, optionally retrieved from a
model tier bean via a value expression, that is displayed to the
user.UIPanel is a
UIComponent that manages the
layout of its child components.UIParameter is a
UIComponent that represents
an optionally named configuration parameter for a parent component.UISelectItem is a component that
may be nested inside a
UISelectMany or UISelectOne
component, and causes the addition of a SelectItem instance
to the list of available options for the parent component.UISelectItems is a component that may be nested
inside a
UISelectMany or UISelectOne component, and
causes the addition of one or more SelectItem instances to the
list of available options in the parent component.UISelectMany is a
UIComponent that represents the user's choice of a zero or
more items from among a discrete set of available options.UISelectOne is a
UIComponent that represents the user's choice of zero or one
items from among a discrete set of available options.UIViewAction represents a
method invocation that occurs during the request processing
lifecycle, usually in response to an initial request, as opposed to a
postback.
UIViewParameter represents a
binding between a request parameter and a model property or
UIViewRoot
property.Inner class to encapsulate a
UIViewParameter instance so that it may be safely
referenced regardless of whether or not the current view is the
same as the view in which this UIViewParameter
resides.UIViewRoot
is the UIComponent that represents the root of the UIComponent tree.
The
<f:websocket> tag opens an one-way (server to client) websocket based push connection in client
side which can be reached from server side via PushContext interface injected in any CDI/container managed
artifact via @Push annotation.This is thrown to indicate that a service is unavailable.
Defines an exception that a servlet or filter throws to indicate
that it is permanently or temporarily unavailable.
Exception raised in the case that the constraint validator resolution
cannot determine a suitable validator for a given type.
Specifies that a unique constraint is to be included in
the generated DDL for a primary or secondary table.
UniqueIdVendor is an
interface implemented by
UIComponents that also
implement NamingContainer so that they can provide unique ids
based on their own clientId.
Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
Represents a non-contextual instance.
Indicates that a contextual reference for a bean with a normal scope and a certain bean type cannot be obtained because the
bean type cannot be proxied by the container.
Indicates that no bean matches a certain combination of required type and required qualifiers and is eligible for injection
into a certain class.
Components implementing this interface are ignored by the algorithm -
especially in the implementation of
@child(n), @next and @previous.Marks a
ValueExtractor definition so that it is applied automatically when
detecting constraints declared on the container type supported by the extractor, causing
the constraints to be applied to the container's elements instead of the container.Set of interfaces used in the
payload() of a constraint to indicate if a value
should be unwrapped before validation.Skip the unwrapping if it has been enabled on the
ValueExtractor by the
UnwrapByDefault
annotation.Unwrap the value before validation.
This exception indicates a failure to
update the model and is created to wrap any exception
that occurs during
UIInput.updateModel(javax.faces.context.FacesContext).URI template-aware utility class for building URIs from their components.
A runtime exception thrown by
UriBuilder.build(Object...) methods when
a URI cannot be constructed based on the current state of the
builder.An injectable interface that provides access to application and request
URI information.
The name of a URL.
Specifies the statistics provided by a URL resource.
Represents the credentials typically used by standard caller name/password authentication.
The UserTransaction interface defines the methods that allow an
application to explicitly manage transaction boundaries.
Marks a property, method parameter or method return type for validation cascading.
Expresses which executables (methods or constructors) should have their parameters
and return value validated upon execution.
The unwrapping behavior that can be applied to a specific constraint.
This interface is implemented by a
ManagedConnectionFactory
instance that supports the ability to validate
ManagedConnection objects.This class is the entry point for Bean Validation.
Base exception of all Bean Validation "unexpected" problems.
A validation message from either TagLibraryValidator or TagExtraInfo.
The validation mode to be used by the provider for the persistence
unit.
Contract between the validation bootstrap mechanism and the provider engine.
Determines the list of Bean Validation providers available in the runtime environment
List of possible targets for a
ConstraintValidator.A Validator
implementation is a class that can perform validation (correctness
checks) on a
EditableValueHolder.Validates bean instances.
Used in creating
ValidatorHandler
and all implementations.Represents the context that is used to create
Validator
instances.ValidatorELTag is a base class for all JSP custom actions
that create and register a
Validator instance on the
EditableValueHolder associated with our most immediate surrounding instance
of a tag whose implementation class is a subclass of UIComponentTag.A ValidatorException is an exception
thrown by the
validate() method of a
Validator to indicate that validation failed.Factory returning initialized
Validator instances.Handles setting a
Validator instance on an EditableValueHolder parent.Deprecated.
This has been partially replaced by
ValidatorELTag.Deprecated.
This has been replaced by
ValueExpression.A
ValueChangeEvent is a notification
that the local value of the source component has been change as a result of
user interface activity.A listener interface for receiving
ValueChangeEvents.An
Expression that can get or set a value.Defines the logic used to extract the values from a container object of type
T.Provides a set of methods receiving value extracted by the
ValueExtractor.Raised if the configuration of
ValueExtractor is illegal, e.g.Raised if a
ValueExtractor definition is illegal, e.g.ValueHolder is an
interface that may be implemented by any concrete
UIComponent
that wishes to support a local value, as well as access data in the
model tier via a value expression, and support conversion
between String and the model tier data's native data type.A VDL handler that exposes
Converter to a page author.A marker interface for VDL tags that
represent
<composite:valueHolder/> for use by the
composite component page author.This encapsulates a base model object and one of its properties.
Information on the scripting variables that are created/modified by
a tag (at run-time).
The interface to a map between EL variables and the EL expressions
they are associated with.
Deprecated.
Deprecated.
As of JSP 2.1, replaced by
ELResolverAbstraction for a resource representation variant.
A builder for a list of representation variants.
Specifies the version field or property of an entity class that
serves as its optimistic lock value.
Veto the processing of the class.
Supports inline instantiation of the
Vetoed annotation.Create a view node in the current
Flow.The contract that a view declaration
language must implement to interact with the JSF runtime.
ViewDeclarationLanguageFactory
is a factory object that creates (if needed) and returns a new
ViewDeclarationLanguage instance based on the VDL found in a
specific view.Provides a simple implementation of
ViewDeclarationLanguage that can
be subclassed by developers wishing to provide specialized behavior
to an existing ViewDeclarationLanguage instance.Implementations must throw this
FacesException when
attempting to restore the view StateManager.restoreView(javax.faces.context.FacesContext, String, String)
results in failure on postback.
ViewHandler is the
pluggablity mechanism for allowing implementations of or applications
using the JavaServer Faces specification to provide their own
handling of the activities in the Render Response and
Restore View phases of the request processing lifecycle.
Provides
a simple implementation of
ViewHandler that can
be subclassed by developers wishing to provide specialized behavior
to an existing ViewHandler instance.The presence of this annotation (along
with
@Inject) on a field of type Map<String,
Object> causes the map returned from UIViewRoot.getViewMap() to be
injected as the value of that field.Marker interface for
SystemEvents that indicate the view map has been created (PostConstructViewMapEvent, or destroyed (PreDestroyViewMapEvent).ViewMetadata is
reponsible for extracting and providing view parameter metadata from
VDL views.ViewNode is the class
that represents a VDL view in a faces flow graph.
Superclass of
Resource that is only
for use with views.Deprecated.
This has been replaced by
javax.faces.view.ViewScoped.When this annotation, along with
javax.inject.Named is found on a class, the runtime must place the
bean in a CDI scope such that it remains active as long as NavigationHandler.handleNavigation(javax.faces.context.FacesContext, java.lang.String, java.lang.String) does not
cause a navigation to a view with a viewId that is different than the
viewId of the current view.Defines the view traversal options.
A simple callback interface that enables
taking action on a specific UIComponent (either facet or child) during
a component tree visit.
A context object that is used to hold
state relating to performing a component tree visit.
Provide for separation of interface and
implementation for the
VisitContext contract.Provides
a simple implementation of
VisitContext that can be subclassed by developers wishing to
provide specialized behavior to an existing VisitContext
instance.An
enum that specifies hints that impact
the behavior of a component tree visit.
An enum that specifies the possible
results of a call to
VisitCallback.visit(javax.faces.component.visit.VisitContext, javax.faces.component.UIComponent).Runtime exception for applications.
This interface encapsulates the connection for an upgrade request.
Annotation used to declare a servlet filter.
This annotation is used on a Servlet or Filter implementation class
to specify an initialization parameter.
This annotation is used to declare a WebListener.
Class for Servlet web resource permissions.
Class for Servlet
isUserInRole (String reference)
permissions.Annotation used to declare a servlet.
A WebSocketContainer is an implementation provided object that provides applications
a view on the container running it.
This web socket event will be fired when a new
<f:websocket> has been
@WebsocketEvent.Opened or @WebsocketEvent.Closed.
Indicates that a
<f:websocket> has closed.
Indicates that a
<f:websocket> has opened.A resource target identified by the resource URI.
Class for Servlet Web user data permissions.
WithAnnotations may be applied to any portable extension observer method with an event parameter type of
ProcessAnnotatedType to filter the events delivered.This models a
Work instance that would be executed by a
WorkManager upon submission.This class is provided as a convenience for easily creating
WorkListener instances by extending this class
and overriding only those methods of interest.This exception is thrown by a
WorkManager to indicate that
a submitted Work instance has completed with an exception.This class serves as a standard mechanism for a resource adapter to propagate
an imported context from an enterprise information system to an application
server.
This class models the possible error conditions that might occur during
associating an
WorkContext with a Work instance.This class models the various events that occur during the processing of the
WorkContexts associated with a Work instance.This interface specifies the methods a
Work instance uses to
associate a List of WorkContext instances to
be set when the Work instance gets executed by a
WorkManager.This class models the various events that occur during the processing of
a
Work instance.A common base class for all
Work processing related exceptions.This models a
WorkListener instance which would be notified
by the WorkManager when the various Work
processing events (work accepted, work rejected, work started,
work completed) occur.This interface models a
WorkManager which provides a facility
to submit Work instances for execution.This exception is thrown by a
WorkManager to indicate
that a submitted Work instance has been rejected.Callback notification mechanism that signals to the developer it's possible
to write content without blocking.
Interface for message body writer interceptors that wrap around calls
to
MessageBodyWriter.writeTo(T, java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap<java.lang.String, java.lang.Object>, java.io.OutputStream).The
XAConnection interface extends the capability of
Connection by providing an XASession (optional).The
XAConnectionFactory interface is a base interface for the
XAQueueConnectionFactory and
XATopicConnectionFactory interfaces.The XAException is thrown by the Resource Manager (RM) to inform the
Transaction Manager of an error encountered by the involved
transaction.
The
XAJMSContext interface extends the capability of
JMSContext by adding access to a JMS provider's support for the Java
Transaction API (JTA) (optional).An
XAQueueConnection provides the same create options as
QueueConnection (optional).An
XAQueueConnectionFactory provides the same create options as
a QueueConnectionFactory (optional).An
XAQueueSession provides a regular QueueSession,
which can be used to
create QueueReceiver, QueueSender, and
QueueBrowser objects (optional).The XAResource interface is a Java mapping of the industry standard
XA interface based on the X/Open CAE Specification (Distributed
Transaction Processing: The XA Specification).
The
XASession interface extends the capability of
Session by adding access to a JMS provider's support for the
Java Transaction API (JTA) (optional).The XATerminator interface is used for transaction completion and
crash recovery flows.
An
XATopicConnection provides the same create options as
TopicConnection (optional).An
XATopicConnectionFactory provides the same create options as
a TopicConnectionFactory (optional).An
XATopicSession provides a regular TopicSession.The Xid interface is a Java mapping of the X/Open transaction identifier
XID structure.
javax.enterprise.context.ApplicationScoped, which is a CDI build-in scope with similar semantics.