All Classes and Interfaces
Class
Description
Builder
Abstract
FilterChain implementation, which redirects
Processor.process(org.glassfish.grizzly.Context) call to the
FilterChain.execute(org.glassfish.grizzly.filterchain.FilterChainContext)A
MemoryManager abstraction to provide utilities that may be useful across different MemoryManager
implementations.This is a marker interface indicating a particular
Buffer implementation can be trimmed.The
AsyncQueueReader implementation, based on the Java NIOThe
AsyncQueueWriter implementation, based on the Java NIOAbstract class, which provides transitive dependencies for overloaded
Reader methods.Abstract class simplifies the implementation of
SocketConnectorHandler interface by pre-implementing some of
its methods.Builder
Each method reads data from the current ByteBuffer.
Write the primitive Java type to the current ByteBuffer.
Abstract
ExecutorService implementation.Abstract
Transport.Abstract class, which provides transitive dependencies for overloaded
Writer methods.An interface defining an appender for Grizzly access logs entries.
A simple builder to configure access logging for Grizzly.
An interface defining a component capable of formatting
Responses into printable access log entries.A Grizzly probe used to provide access logs generation.
The Filter is responsible for tracking
Connection activity and closing Connection ones it becomes
idle for certain amount of time.The
HttpServer addon interface, responsible for adding features like WebSockets, Comet to HttpServer.The listener, which could be registered on a
Request using
Request.addAfterServiceListener(org.glassfish.grizzly.http.server.AfterServiceListener) and be notified once
the Request processing will be completed.AggregatorAddOn installs
AggregatorAddOn.AggregatorFilter into HttpServer FilterChain.Ajp
AddOn for the HttpServer.Common class for the AJP Protocol values
Filter is working as Codec between Ajp and Http packets.
HttpRequestPacket implementation, which also contains AJP related meta data.HttpResponsePacket implementation, which also contains AJP related meta data.Filter, responsible for parsing Ajp requests and making sure the request packets are complete and properly
constructed.
Called during the SSL handshake when the current
SSLEngine's
getUseClientMode has returned true.
Called during the SSL handshake when the current
SSLEngine's
getUseClientMode has returned false.Grizzly TLS Next Protocol Negotiation support class.
An
AccessLogFormat using a standard vaguely similar and heavily influenced by
Apache's own custom access log
formats.The thread safe set implementation, which uses array to hold its elements.
Set of utility methods to work with Arrays.
This class implements some basic ASCII character handling functions.
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.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.
Common interface for
AsyncQueue processors.Interface, which Transports should implement if they support AsyncQueues.
Class encapsulates asynchronous queue implementation:
AsyncQueueReader, AsyncQueueWriter.The
AsyncQueue, which implements asynchronous read queue.AsyncQueue element unitThe
AsyncQueue, which implements asynchronous write queue.AsyncQueue read element unitAsyncQueue write element unitClass used to define dynamic typed attributes on
AttributeHolder instances.AttributeBuilder is responsible for creating and indexing
Attributes.Interface declares common functionality for objects, which have associated
Attributes.AttributeStorage provides access to a
AttributeHolder, where application can store
Attributes.Efficient conversion of bytes to character .
Efficient conversion of bytes to character .
This configuration might be useful, when Grizzly HttpServer is running behind an HTTP gateway like reverse proxy,
load balancer etc...
Base
Provides empty implementation for
Filter processing methods.WebSocket
Filter implementation, which supposed to be placed into a FilterChain right after HTTP
Filter: HttpServerFilter, HttpClientFilter; depending whether it's server or client side.Adds the ability for binary based
InputSources to obtain the incoming
Buffer directly without having to use intermediate objects to copy the data to.Adds the ability for binary based
OutputSinks to write a Buffer instead of
having to convert to those types supported by OutputStream.BinTree
BitTreeDecoder
BitTreeEncoder
General Broadcaster API to send the same message to a set of clients.
JDK
ByteBuffer was taken as base for Grizzly Buffer interface, but Buffer has several
extensions: it's possible to prepend some data to a Buffer and release Buffer, when it's not required any more.Buffer chunk representation.InputStream implementation over Grizzly Buffer.OutputStream implementation to write to a Buffer.Class has useful methods to simplify the work with
Buffers.The simple Buffer manager implementation, which works as wrapper above
ByteBuffers.Buffer implementation, which uses the ByteBuffer underneath.This class is used to represent a chunk of bytes, and utilities to manipulate byte[].
Efficient conversion of character to bytes.
DataChunk implementation, which could be cached in the thread cache.ProcessorSelector implementation, which acts like wrapper for chain of ProcessorSelectors.Configurator responsible for initial
SelectableChannel configuration.Utilities to manipulate char chunks.
When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
Charset utility class.
General interface for
CharChunk and BufferChunk.Chunked transfer encoding implementation.
The Filter is responsible to break the incoming/outgoing data into chunks and pass them down/up by the
FilterChain.Simple
ClassLoader utility.Provides a set of callbacks that will be invoked when negotiation
NPN on the client side.
General asynchronous closable interface.
The listener, which is used to be notified, when Connection gets closed.
An object, describing the reason why
Connection was closed.HttpHandler, which processes requests to a static resources resolved by a given ClassLoader.Codec is able to transform the original message to a custom represantation and vise versa.
Interface, which will be used by Grizzly to notify about asynchronous I/O operations status updates.
Bulk Buffer operation, responsible for byte-by-byte Buffer processing.
The order in which internal
Buffers will be disposed.Setter.
The builder for compressed headers used by
HeadersFrame.Compression configuration class.
Common CompressionMode interface.
Deprecated.
pls.
Common interface, which represents any kind of connection.
Deprecated.
use
CloseListenerDeprecated.
use
CloseTypeMonitoring probe providing callbacks that may be invoked by Grizzly
Connection implementations.ConnectionProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.Client side connector handler API.
Constants.
Constants.
Content-Disposition representation.
Abstraction, which represents HTTP content-encoding.
This class serves as a Content-Type holder, plus it implements useful utility methods to work with content-type.
Mutable
ContentType object.Object, which is responsible for holding context during I/O event processing.
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.
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.
Cookie header generator based on RFC6265
Cookie header parser based on RFC6265
The set of Cookie utility methods for cookie parsing.
A collection of cookies - reusable and tuned for server side performance.
Cookies builder, which could be used to construct a set of cookies, either client or server.
The set of Cookie utility methods for cookie serialization.
The general set of Cookie utility methods.
Simple Wrapper around
Cookie.General interface for the objects, that could be copied/cloned.
CRC
Buffer chunk representation.In memory representation of a websocket frame.
Utility class, which may stores the current execution position to help tracking threading issues.
RangeDecoder
Decodes headers from their binary representation.
Delivers results of the
decoding operation.Default
AttributeBuilder implementation.Default Grizzly
ErrorPageGenerator.Default
FilterChain implementationAllows creation/customization of
MemoryManager implementation to be used as the
MemoryManager.DEFAULT_MEMORY_MANAGER.Default monitoring configuration, with no JMX support.
Default implementation of NIO
SelectorHandlerThis servlet will be invoked when no other servlet matches the request URI.
Default
SessionManager implementation.Default Grizzly worker thread implementation
Filter which pauses protocol chain processing for a certain time.
The directory service interface, containing methods for examining and updating attributes associated with objects,
and for searching the directory.
Thread-local Direct
ByteBuffer storage.Wrapper around a
jakarta.servlet.http.HttpServletRequest that transforms an application request object
(which might be the original one passed to a servlet.Wrapper around a
jakarta.servlet.http.HttpServletResponse that transforms an application response object
(which might be the original one passed to a servlet.Constants based on Servlet3.0 spec.
Interface simplifies by path or name mapping.
Enumeration of filter dispatcher types.
The default
Broadcaster, which iterates over set of clients and sends the same text of binary message
separately to each client.Echo
Filter implementationEmpty implementation for
CompletionHandler interface.RangeEncoder
Encodes headers to their binary representation.
HttpHandler class that wraps an
Enumeration around a Java2 collection classes object
Iterator so that existing APIs returning Enumerations can easily run on top of the new collections.Error codes enum
Error page generator interface, which is responsible for generating of an error page corresponding to the given
response status.
Exceptions utilities.
Expand out a jar.
Handler, responsible for processing Expect: header in a HTTP requests, for example "Expect: 100-Continue"
Interface, using which
ExpectationHandler may confirm or refuse client expectation.Representation of a WebSocket extension and its associated parameters.
Representation of extension parameters.
Fast date formatter that caches recently formatted date information and uses it to avoid too-frequent calls to the
underlying formatter.
Utility class to generate HTTP dates.
This class implements a file caching mechanism used to cache static resources.
The entry value in the file cache map.
The entry key in the file cache map.
Monitoring probe providing callbacks that may be invoked by Grizzly
FileCache.FileCacheProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.A simple class that abstracts
FileChannel.transferTo(long, long, java.nio.channels.WritableByteChannel) for
use with Grizzly 2.0 AsyncQueueWriter.
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 Filter encapsulates a unit of processing work to be performed, whose purpose is to examine and/or modify the state
of a transaction that is represented by a
FilterChainContext.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.
This class implement the "Chain of Responsibility" pattern (for more info, take a look at the classic "Gang of Four"
design patterns book).
FilterChainBuilder implementation, which is responsible for constructing FilterChains.FilterChain Context implementation.The interface, which represents a listener, which will be notified, once
FilterChainContext processing is
complete.The interface, which represents a listener, which will be notified, after
FilterChainContext.copy() is
called.Common interface for Transports, which support
FilterChains.FilterChainFactory is responsible for building a FilterChain instance with the
Filters that need to be invoked for a particular request URI.A filter configuration object used by a servlet container to pass information to a filter during initialization.
FilterConfig implementation.Representation of a filter mapping for a web application, as represented in a
<filter-mapping>
element in the deployment descriptor.Interface through which a
Filter may be further configured.Allows customization of a
Filter registered with the WebappContext.Interface through which a
Filter registered via one of the addFilter methods on
ServletContext may be further configured.Fixed length transfer encoding implementation.
Minimalistic fixed thread pool to allow for nice scalability if a good Queue impl is used.
Future interface, which has full control over the state.Set of
Future utilities.Generic Adapter interface.
Deprecated.
Defines a generic, protocol-independent filter.
Defines a generic, protocol-independent servlet.
Glassfish support class.
Global constants that are applicable to multiple packages within Catalina.
Interface to notify interested parties that a
Transport is being shutdown.Class contains information about Grizzly framework.
Grizzly
Future implementation.Grizzly JMX manager
Generic implementation of java.security.Principal that is used to represent principals authenticated
at the protocol handler level.
GZip
ContentEncoding implementation, which compresses/decompresses HTTP content using gzip algorithm.This class implements a
Transformer which decodes data represented in the GZIP format.This class implements a
Transformer which encodes plain data to the GZIP format.This class implements a
Filter which encodes/decodes data in the GZIP
format.This annotation is used to declare the class types that a
ServletContainerInitializer can handle.Enumeration of all headers as defined in
RFC 2616.HeaderBlockFragment.HeaderBlockFragmentBuilder<T extends HeaderBlockFragment.HeaderBlockFragmentBuilder>
This class serves as an HTTP header value holder, plus it implements useful utility methods to optimize headers
serialization.
Buffer implementation, which uses the ByteBuffer underneath.Library of utility methods useful in dealing with converting byte arrays to and from strings of hexadecimal digits.
The object holder, which might be used for lazy object initialization.
Set of holder interfaces, which help to bind Servlet and Grizzly HttpServer abstractions.
Utility class used to generate HTML pages.
FilterChain after being processed by
Http2AddOn:The
Filter serves as a bridge between HTTP2 frames and upper-level HTTP
layers by converting Http2Frames into HttpPackets and passing them up/down by the
FilterChain.Configuration information for HTTP/2
Filter implementations.The HTTP2 session abstraction.
HTTP/2 session exception.
Class represents an output sink associated with specific
Http2Session
and is responsible for session (connection) level flow control.The abstraction representing HTTP2 stream.
HTTP/2 Stream exception.
Base HTTP Filter.
HttpContent message, which represents broken HTTP content.HttpTrailer message builder.
RuntimeException, means something wrong happened during HTTP message content parsing.Client side
HttpCodecFilter implementation, which is responsible for decoding HttpResponsePacket and
encoding HttpRequestPacket messages.The
Filter, responsible for transforming Buffer into
HttpPacket and vice versa in asynchronous mode.General HttpCodec utility methods.
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.Object represents HTTP message content: complete or part.
HttpContent message builder.
Represents a single logical HTTP transaction.
The class contains a set of standard HTTP events sent on FilterChain during HTTP packets processing.
Provides an abstract class to be subclassed to create an HTTP filter suitable for a Web site.
Base class to use when Request/Response/InputStream/OutputStream are needed to implement a customized HTTP
container/extension to the HTTP module.
The HttpHandlerChain class allows the invocation of multiple
HttpHandlers every time a new HTTP request is
ready to be handled.Class representing
HttpHandler registration information on a HttpServer.HttpPacket, which represents HTTP message header.HttpHeader message builder.
This annotation is used within the
ServletSecurity annotation to represent security constraints on specific
HTTP protocol messages.Java Class representation of an
HttpMethodConstraint annotation value.Abstraction, which represents any type of HTTP message:
HttpRequestPacket, HttpResponsePacket,
HttpContent.The plugin, that optimizes processing of pipelined HTTP requests by buffering HTTP responses and then writing them as
one operation.
Monitoring probe providing callbacks that may be invoked by Grizzly Http filters.
HttpProbe adapter that provides no-op implementations for all interface methods allowing easy extension by
the developer.A
ProtocolFinder implementation that parse the available SocketChannel bytes looking for the 'http' bytes.The
HttpHeader object, which represents HTTP request message.HttpRequestPacket message builder.
Utility class that make sure an HTTP url defined inside a
MessageBytes is normalized, converted and valid.The
HttpHeader object, which represents HTTP response message.HttpResponsePacket message builder.
Server side
HttpCodecFilter implementation, which is responsible for decoding HttpRequestPacket and
encoding HttpResponsePacket messages.Filter implementation to provide high-level HTTP request/response processing.
Grizzly web server monitoring config.
Monitoring probe providing callbacks that may be invoked by Grizzly
HttpServerFilter.HttpServerProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.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.Facade class that wraps a
Request request object.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.Facade class that wraps a
Response object.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 an 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.
This is the class representing event notifications for changes to sessions within a web application.
Interface for receiving notification events about HttpSession id changes.
Basic
HttpSession based on Session support.Interface for receiving notification events about HttpSession lifecycle changes.
This
enum encapsulates the HTTP response status and reason phrases as defined by RFC 2616.HttpContent message, which represents HTTP trailer message.HttpTrailer message builder.
This interface encapsulates the upgrade protocol processing.
Utility class.
Huffman coding table.
Deprecated.
The Filter is responsible for tracking
Connection activity and closing Connection once it becomes
idle for certain amount of time.The interface declares, that
AttributeHolder supports indexed Attribute access.AttributeHolder, which supports indexed access to stored Attributes.Abstraction exposing both byte and character methods to read content from the HTTP messaging system in Grizzly.
This interface defines methods to allow an
InputStream or Reader to notify the developer
when and how much data is ready to be read without blocking.Handler, which is used to finer control
Readable.InWindow
Enumeration represents the I/O events, occurred on a
Connection.Empty
IOEventLifeCycleListener implementation.strategy is responsible for making decision how
Runnable task will be run: in current thread, worker
thread.Notify implementations when JMX is enabled on a
HttpServer instance.This interface provides access to the
<jsp-config> related configuration of a web application.This interface provides access to the
<jsp-property-group> related configuration of a web
application.Web container configuration for keep-alive HTTP connections.
Monitoring probe providing callbacks that may be invoked by Grizzly
KeepAlive.KeepAliveProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.Lazy cookie implementation, which is based on preparsed Grizzly
Buffers.Lazy
FileCacheKey object.IOStrategy, which executes Processors in a current
threads, and resumes selector thread logic in separate thread.FilterChain facade, which implements all the List related methods.Localizable message.
Localizes the
Localizable into a message by using a configured Locale.Simple log
FilterFormat the record to include the Thread that logged the record.
Defines string formatting method for each constant in the resource file
Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules).
Mapping data.
Enumeration of Servlet mapping types.
MemoryManager, responsible for allocating and releasing memory, required during application runtime.
MemoryManager monitoring probe.MemoryProbe adapter that provides no-op implementations for all interface methods allowing easy extension by
the developer.Class has useful methods to simplify the work with
Buffers.This class is used to represent a subarray of bytes in an HTTP message.
Cloner, which will be called by
AsyncQueueWriter, when message could not be written directly, and will be
added to the queue.Predefined HTTP methods
Memory-efficient repository for Mime Headers.
Common interface for
HttpPackets, which contain mimeheaders.Hardcoded mime-type supported by default.
Interface that allows arbitrary entities to provide a
JmxObject that can be registered with the
org.glassfish.grizzly.monitoring.jmx.GrizzlyJmxManager.General interface for the objects, which could be monitored during the lifecycle.
General monitoring configuration interface.
The class, which contains utility methods for monitoring support.
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.Contains auxiliary information about multipart processing.
Abstraction represents single multipart entry, its functionality is pretty similar to
Request.General interface for processing
MultipartEntrys, one by one.ReadHandler, which implements the miltipart message parsing logic and delegates control to a
MultipartEntryHandler, when MultipartEntry data becomes available.Entry point for the multipart message processing.
This interface represents a naming context, which consists of a set of name-to-object bindings.
This is the superclass of all exceptions thrown by operations in the Context and DirContext interfaces.
Utility class to register, obtain, and/or remove Client/Server NPN/ALPN
negotiator instances.
The interface defines the instruction for a
FilterChain, how it should continue filter chain execution.Common
Connection implementation for Java NIO Connections.Stream implementation to read binary request content.
Stream implementation for writing binary content to an HTTP user-agent.
Character stream implementation used to read character-based request content.
This builder is responsible for creating
NIOTransport implementations as well as providing basic
configuration for IOStrategies and thread pools.Stream implementation for writing character content to an HTTP user-agent.
N-ary tree node implementation to support HTTP/2 stream hierarchies.
The Note value associated with HttpRequestPacket.
Basic interface for object pool implementations
The default
Broadcaster optimized to send the same text to a set of clients.Abstraction exposing both byte and character methods to write content to the HTTP messaging system in Grizzly.
This interface defines methods to allow an
OutputStream or Writer to allow the
developer to check with the runtime whether or not it's possible to write a certain amount of data, or if it's not
possible, to be notified when it is.OutWindow
Key : Value pair implementation.
Extended implementation of LinkedHashMap that includes a
locked property.DataFrame parse result.Class, which represents result of
TransferEncoding or ContentEncoding parsing.
This class represents a part or form item that was received within a
multipart/form-data POST request.Thrown when an attempt is made to add a record that exceeds the configured maximum queue size.
A
MemoryManager implementation based on a series of shared memory pools.Immutable class representing a port range.
Maintains semantic state necessary to proper HTTP processing.
Processor implementations are responsible for processing I/O events, which occur on connection.
The interface represents the result of
Processor execution.Enumeration represents the status/code of
ProcessorResult.Implementations of the interface will be responsible to find correct
Processor, which will process
IOEvent, occurred on the ConnectionPredefined HTTP protocol versions
General interface for protocol finders, responsible to figure out, whether incoming bytes belong to the specific
protocol.
Protocol discovering context, passed to the
ProtocolFinder.Port unification filter.
The wrapper class, which holds protocol finder and correspondent protocol, represented by
FilterChain.Deprecated.
push back logic is deprecated.
Deprecated.
push back logic is deprecated.
Build a request to be pushed.
Build a request to be pushed.
A
FilterChainEvent to trigger an HTTP/2 push promise and trigger a new request to be sent upstream to
generate a response for said push promise.Construct a new
PushEvent.An
appender enqueueing log entries into a LinkedBlockingQueue and using a
secondary, separate Thread to forward them to a configured nested appender.RangeDecoder
RangeEncoder
Implementations of this interface are able to read data from internal source to a
Buffer.Implementations of this interface are able to read data from
Connection to a Buffer.Deprecated.
please use
ReadHandler
This class represents a call-back mechanism that will notify implementations as more input data becomes available to
read without blocking.
This class represents a call-back mechanism that will notify implementations as HTTP request data becomes available
to be read without blocking.
Result of read operation, returned by
Readable.Future implementation with the specific unmodifiable result.Read result associated with a
AsyncWriteQueueRecord.Write result associated with a
AsyncWriteQueueRecord.Base class for all complex registrable components within a web application.
Interface through which a
Servlet or Filter registered via one of the addServlet or
addFilter methods, respectively, on ServletContext may be further configured.Wrapper object for the Coyote request.
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.
An implementation of this interface will be responsible for executing user's code in
HttpHandler.service(org.glassfish.grizzly.http.server.Request, org.glassfish.grizzly.http.server.Response)
and notifying ReadHandler, WriteHandler registered by the user.The
RequestExecutorProvider implementation, which always returns null to force the user code to be
executed on the current Thread.The
RequestExecutorProvider implementation, which checks if the current Thread is a service
Thread (see Threads.isService()).Request URI holder.
Wrapper object for the Coyote response.
Common I/O result interface.
RoundRobin NIOConnectionDistributor implementation, which allocates one SelectorRunner for OP_ACCEPT events and other
event will be assign to a next SelectorRunner from the array.
Safe
FutureImpl implementation.IOStrategy, which executes Processors in a current
thread.Class represents
WebSocket's security key, used during the handshake phase.SelectionKeyHandler implementations are responsible for handling SelectionKey life cycle events.Task, which may be registered on
SelectorHandler and executed in a Selector thread.Class is responsible for processing certain (single)
SelectorHandlerUtility class for
Selector related operations.Configuration options for a particular
HttpServer instance.HttpServerFilter configuration.Server-side implementation of the
InputBuffer.Provides a set of callbacks that will be invoked when negotiation
NPN on the server side.
Error thrown when something goes wrong while looking up service providers.
A simple service-provider lookup mechanism.
Defines methods that all servlets must implement.
A servlet configuration object used by a servlet container to pass information to a servlet during initialization.
Basic
ServletConfig implementation.Provides information about the connection made to the Servlet container.
Trivial implementation of the
ServletConnectionInterface 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.
HttpHandler implementation that provides an entry point for processing a Servlet request.
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.Allows customization of a
Servlet registered with the WebappContext.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.The Servlet-aware
SessionManager implementation.Grizzly Servlet utilities.
Simple session object.
Class that may be used to configure various properties of cookies used for session tracking purposes.
Class that may be used to configure various properties of cookies used for session tracking purposes.
HTTP session manager abstraction responsible for keeping track of HTTP session associated with a user
Request.Enumeration of session tracking modes.
TODO: Need to implement handling of per-setting flags.
This class will be passed to
GracefulShutdownListener instances registered against a Transport.An event that
Filter implementations may listen for if special processing is required during a graceful
shutdown.Handler, which will be called, once Ajp shutdown message received.
Filter, which determines silent connections and closes them.
Simple dynamic strategy, which switches I/O processing strategies, basing on statistics.
Generic WebSocket implementation.
Common interface for SocketAcceptor implementations.
Socket based client side connector.
SSL
Filter to operate with SSL encrypted data.SSL Codec, which contains SSL encoder and decoder
Transformers.SSL context associated with a
Connection.Utility class, which helps to configure
SSLContext.Transformer, which decodes SSL encrypted data, contained in the input Buffer, to the output Buffer.
Transformer, which encrypts plain data, contained in the input Buffer, into SSL/TLS data and puts the result
to the output Buffer.
Utility class, which helps to configure
SSLEngine.The factory responsible for creating
SSLEngine.SSL
Filter to operate with SSL encrypted data.SSL aware
StreamReader implementation, which work like a wrapper over existing StreamReader.SSL aware
StreamWriter implementation, which work like a wrapper over existing StreamWriter.SSLSupport
Interface for SSL-specific functions
Simple data class that represents the cipher being used, along with the corresponding effective key size.
Utility class, which implements the set of useful SSL related operations.
Processor, which is not interested in processing I/O events.Class, which holds the state.
HttpHandler, which processes requests to a static resources.The basic class for
HttpHandler implementations, which processes requests to a static resources.Common interface for Stream readers and writers.
An
appender writing log entries to an OutputStream.Interface that defines methods for reading primitive types and arrays of primitive types from a stream.
Write the primitive Java types and arrays of primitives to some data sink.
This class implements a String cache for ByteChunk and CharChunk.
StringFilter implementation, which performs Buffer <-> String transformation.
An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes
care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
Utility class for string parsing that is higher performance than StringParser for simple delimited text cases.
Interface represents a context of the suspended
Response.The request/response suspend status bound to a specific thread.
ExecutorService implementation, which function the similar way as former Grizzly 1.x Pipeline based thread
pools.This interface provides access to the
<taglib> related configuration of a web application.Class represents common implementation of asynchronous processing queue.
The TCP transport
AsyncQueueReader implementation, based on the Java NIOThe TCP transport
AsyncQueueWriter implementation, based on the Java NIOThis class may be used to apply a custom
Processor and/or
ProcessorSelector atomically within a bind operation - not something that can normally
be done using the TCPNIOTransport alone.Connection implementation for the TCPNIOTransportThis interface implementations can be used to be notified about the TCPNIOConnection connect state.
TCP NIO transport client side ConnectorHandler implementation
TCP Transport NIO implementation
NIOTransportBuilder implementation for TCP.The
TCPNIOTransport's transport Filter implementationTCP NIO Transport utils
Common interface for Transports, which will use temporary selectors technics
A thread local pool used by a
MemoryManager to create and modify BuffersThis interface may be implemented by custom
MemoryManager implementations in order to provide per-thread
memory management.Grizzly thread-pool configuration, which might be used to create and initialize a thread-pool via
GrizzlyExecutorService.createInstance(org.glassfish.grizzly.threadpool.ThreadPoolConfig).Monitoring probe providing callbacks that may be invoked by Grizzly
AbstractThreadPool implementations.ThreadPoolProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.Set of
Thread utilities.Handler, which processes suspended
Response timeout and is able to either confirm it or reset.Main tool for object expiry.
Abstraction, which represents HTTP transfer-encoding.
A
BlockingQueue in which producers may wait for consumers to receive elements.Describes the problem, occured during original message transformation.
Represents the result of message encoding/decoding.
Transformer interface, which knows how to transform the original data to some custom representation.
Transport interface describes the transport unit used in Grizzly.
Monitoring probe providing callbacks that may be invoked by Grizzly
Transport implementations.TransportProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.All URL decoding happens here.
The UDP transport
AsyncQueueReader implementation, based on the Java NIOThe UDP transport
AsyncQueueWriter implementation, based on the Java NIOThis class may be used to apply a custom
Processor and/or
ProcessorSelector atomically within a bind operation - not something that can normally
be done using the UDPNIOTransport alone.Connection implementation for the UDPNIOTransportUDP NIO transport client side ConnectorHandler implementation
Server
Connection implementation for the UDPNIOTransportUDP NIO transport implementation
NIOTransportBuilder implementation for UDP.The
UDPNIOTransport's transport Filter implementationEfficient implementation for encoders.
Defines an exception that a servlet or filter throws to indicate that it is permanently or temporarily unavailable.
Holder class when we encounter frames of an unknown type.
Simple thread-unsafe
Future implementation.The
StreamOutputSink implementation, which is used when upgrading HTTP -> HTTP/2 connections.
This class acts as the foundation for registering listeners, servlets, and filters in an embedded environment.
This interface encapsulates the connection for an upgrade request.
Implementation of WebConnection for Servlet 3.1
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.
Annotation used to declare a servlet.
General WebSocket unit interface.
WebSockets
AddOn for the HttpServer.WebSockets engine implementation (singleton), which handles
WebSocketApplications registration, responsible
for client and server handshake validation.WebSocketHolder object, which gets associated with the Grizzly
Connection.Interface to allow notification of events occurring on specific
WebSocket instances.Mapping information to be filled out during the
WebSocketApplication discovery.Interface, which Grizzly thread pool threads should implement.
IOStrategy, which executes Processors in worker thread.Strategy implementations may implement this interface to signify they have certain thread pool configuration
requirements that could be used when building the runtime.
MemoryManagers, which implement this interface, are able to convert frequently used Java buffer types to
Grizzly Buffer.Common interface for entities that may be written to a
Channel.Implementations of this interface are able to write data from a
Buffer.Deprecated.
please use
WriteHandlerCallback notification mechanism that signals the developer it's possible to write content.
Callback notification mechanism that signals to the developer it's possible to write content without blocking.
Implementations of this interface are able to write data from a
Buffer to Connection.Write reentrants counter
Result of write operation, returned by
Writeable.