jakarta.servlet.ServletRequest Maven / Gradle / Ivy
/*
* Copyright (c) 1997, 2024 Oracle and/or its affiliates and others.
* All rights reserved.
* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package jakarta.servlet;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;
/**
* Defines an object to provide client request information to a servlet. The servlet container creates a
* ServletRequest object and passes it as an argument to the servlet's service method.
*
*
* A ServletRequest object provides data including parameter name and values, attributes, and an input
* stream. Interfaces that extend ServletRequest can provide additional protocol-specific data (for
* example, HTTP data is provided by {@link jakarta.servlet.http.HttpServletRequest}.
*
* @author Various
*
* @see jakarta.servlet.http.HttpServletRequest
*
*/
public interface ServletRequest {
/**
* Returns the value of the named attribute as an Object, or null if no attribute of the given
* name exists.
*
*
* Attributes can be set two ways. The servlet container may set attributes to make available custom information about a
* request. For example, for requests made using HTTPS, the attribute
* jakarta.servlet.request.X509Certificate can be used to retrieve information on the certificate of the
* client. Attributes can also be set programmatically using {@link ServletRequest#setAttribute}. This allows
* information to be embedded into a request before a {@link RequestDispatcher} call.
*
*
* Attribute names should follow the same conventions as package names. The Jakarta Servlet specification reserves names
* matching jakarta.*.
*
* @param name a String specifying the name of the attribute
*
* @return an Object containing the value of the attribute, or null if the attribute does not
* exist
*/
Object getAttribute(String name);
/**
* Returns an Enumeration containing the names of the attributes available to this request. This method
* returns an empty Enumeration if the request has no attributes available to it.
*
* @return an Enumeration of strings containing the names of the request's attributes
*/
Enumeration getAttributeNames();
/**
* Returns the name of the character encoding used in the body of this request. This method returns null if
* no request encoding character encoding has been specified. The following methods for specifying the request character
* encoding are consulted, in decreasing order of priority: per request, per web app (using
* {@link ServletContext#setRequestCharacterEncoding}, deployment descriptor), and per container (for all web
* applications deployed in that container, using vendor specific configuration).
*
* @return a String containing the name of the character encoding, or null if the request does
* not specify a character encoding
*/
String getCharacterEncoding();
/**
* Overrides the name of the character encoding used in the body of this request. This method must be called prior to
* reading request parameters or reading input using getReader(). Otherwise, it has no effect.
*
* @param encoding String containing the name of the character encoding.
*
* @throws UnsupportedEncodingException if this ServletRequest is still in a state where a character encoding may be
* set, but the specified encoding is invalid
*/
void setCharacterEncoding(String encoding) throws UnsupportedEncodingException;
/**
* Overrides the character encoding used in the body of this request. This method must be called prior to reading
* request parameters or reading input using getReader(). Otherwise, it has no effect.
*
* Implementations are strongly encouraged to override this default method and provide a more efficient implementation.
*
* @param encoding Charset representing the character encoding.
*
* @since Servlet 6.1
*/
default void setCharacterEncoding(Charset encoding) {
try {
setCharacterEncoding(encoding.name());
} catch (UnsupportedEncodingException e) {
// Unreachable code
}
}
/**
* Returns the length, in bytes, of the request body and made available by the input stream, or -1 if the length is not
* known or is greater than Integer.MAX_VALUE.
*
* @return an integer containing the length of the request body or -1 if the length is not known or is greater than
* Integer.MAX_VALUE.
*/
int getContentLength();
/**
* Returns the length, in bytes, of the request body and made available by the input stream, or -1 if the length is not
* known.
*
* @return a long containing the length of the request body or -1L if the length is not known
*
* @since Servlet 3.1
*/
long getContentLengthLong();
/**
* Returns the MIME type of the body of the request, or null if the type is not known.
*
* @return a String containing the name of the MIME type of the request, or null if the type is not known
*/
String getContentType();
/**
* Retrieves the body of the request as binary data using a {@link ServletInputStream}. Either this method or
* {@link #getReader} may be called to read the body, not both.
*
* @return a {@link ServletInputStream} object containing the body of the request
*
* @exception IllegalStateException if the {@link #getReader} method has already been called for this request
*
* @exception IOException if an input or output exception occurred
*/
ServletInputStream getInputStream() throws IOException;
/**
* Returns the value of a request parameter as a String, or null if the parameter does not
* exist. Request parameters are extra information sent with the request. For HTTP servlets, parameters are contained in
* the query string or posted form data.
*
*
* You should only use this method when you are sure the parameter has only one value. If the parameter might have more
* than one value, use {@link #getParameterValues}.
*
*
* If you use this method with a multivalued parameter, the value returned is equal to the first value in the array
* returned by getParameterValues.
*
*
* If the parameter data was sent in the request body, such as occurs with an HTTP POST request, then reading the body
* directly via {@link #getInputStream} or {@link #getReader} can interfere with the execution of this method.
*
*
* If not already parsed, calling this method will trigger the parsing of the query string, POSTed form data where the
* request body has content type is application/x-www-form-urlencoded and POSTed form data where the
* request body has content-type multipart/form-data and the Servlet is configured with a
* {@link jakarta.servlet.annotation.MultipartConfig} annotation or a multipart-config element in the
* deployment descriptor.
*
* @param name a String specifying the name of the parameter
*
* @return a String representing the single value of the parameter
*
* @throws IllegalStateException if parameter parsing is triggered and a problem is encountered parsing the parameters
* including, but not limited to: invalid percent (%nn) encoding; invalid byte sequence for the specified character set;
* I/O errors reading the request body; and triggering a container defined limit related to parameter parsing.
* Containers may provide container specific options to handle some or all of these errors in an alternative manner that
* may include not throwing an exception.
*
* @see #getParameterValues
*/
String getParameter(String name);
/**
*
* Returns an Enumeration of String objects containing the names of the parameters contained
* in this request. If the request has no parameters, the method returns an empty Enumeration.
*
*
* If not already parsed, calling this method will trigger the parsing of the query string, POSTed form data where the
* request body has content type is application/x-www-form-urlencoded and POSTed form data where the
* request body has content-type multipart/form-data and the Servlet is configured with a
* {@link jakarta.servlet.annotation.MultipartConfig} annotation or a multipart-config element in the
* deployment descriptor.
*
* @return an Enumeration of String objects, each String containing the name of a
* request parameter; or an empty Enumeration if the request has no parameters
*
* @throws IllegalStateException if parameter parsing is triggered and a problem is encountered parsing the parameters
* including, but not limited to: invalid percent (%nn) encoding; invalid byte sequence for the specified character set;
* I/O errors reading the request body; and triggering a container defined limit related to parameter parsing.
* Containers may provide container specific options to handle some or all of these errors in an alternative manner that
* may include not throwing an exception.
*/
Enumeration getParameterNames();
/**
* Returns an array of String objects containing all of the values the given request parameter has, or
* null if the parameter does not exist.
*
*
* If the parameter has a single value, the array has a length of 1.
*
*
* If not already parsed, calling this method will trigger the parsing of the query string, POSTed form data where the
* request body has content type is application/x-www-form-urlencoded and POSTed form data where the
* request body has content-type multipart/form-data and the Servlet is configured with a
* {@link jakarta.servlet.annotation.MultipartConfig} annotation or a multipart-config element in the
* deployment descriptor.
*
* @param name a String containing the name of the parameter whose value is requested
*
* @return an array of String objects containing the parameter's values
*
* @throws IllegalStateException if parameter parsing is triggered and a problem is encountered parsing the parameters
* including, but not limited to: invalid percent (%nn) encoding; invalid byte sequence for the specified character set;
* I/O errors reading the request body; and triggering a container defined limit related to parameter parsing.
* Containers may provide container specific options to handle some or all of these errors in an alternative manner that
* may include not throwing an exception.
*
* @see #getParameter
*/
String[] getParameterValues(String name);
/**
* Returns a java.util.Map of the parameters of this request.
*
*
* Request parameters are extra information sent with the request. For HTTP servlets, parameters are contained in the
* query string or posted form data.
*
*
* If not already parsed, calling this method will trigger the parsing of the query string, POSTed form data where the
* request body has content type is application/x-www-form-urlencoded and POSTed form data where the
* request body has content-type multipart/form-data and the Servlet is configured with a
* {@link jakarta.servlet.annotation.MultipartConfig} annotation or a multipart-config element in the
* deployment descriptor.
*
* @return an immutable java.util.Map containing parameter names as keys and parameter values as map values. The keys in
* the parameter map are of type String. The values in the parameter map are of type String array.
*
* @throws IllegalStateException if parameter parsing is triggered and a problem is encountered parsing the parameters
* including, but not limited to: invalid percent (%nn) encoding; invalid byte sequence for the specified character set;
* I/O errors reading the request body; and triggering a container defined limit related to parameter parsing.
* Containers may provide container specific options to handle some or all of these errors in an alternative manner that
* may include not throwing an exception.
*/
Map getParameterMap();
/**
* Returns the name and version of the protocol the request uses in the form protocol/majorVersion.minorVersion,
* for example, HTTP/1.1.
*
* @return a String containing the protocol name and version number
*/
String getProtocol();
/**
* Returns the name of the scheme used to make this request, for example, http, https, or
* ftp. Different schemes have different rules for constructing URLs, as noted in RFC 1738.
*
* @return a String containing the name of the scheme used to make this request
*/
String getScheme();
/**
* Returns the host name of the server to which the request was sent. It may be derived from a protocol specific
* mechanism, such as the Host header, or the HTTP/2 authority, or
* RFC 7239, otherwise the resolved server name or the server IP
* address.
*
* @return a String containing the name of the server
*/
String getServerName();
/**
* Returns the port number to which the request was sent. It may be derived from a protocol specific mechanism, such as
* the Host header, or HTTP authority, or RFC 7239,
* otherwise the server port where the client connection was accepted on.
*
* @return an integer specifying the port number
*/
int getServerPort();
/**
* Retrieves the body of the request as character data using a BufferedReader. The reader translates the
* character data according to the character encoding used on the body. Either this method or {@link #getInputStream}
* may be called to read the body, not both.
*
* @return a BufferedReader containing the body of the request
*
* @exception UnsupportedEncodingException if the character set encoding used is not supported and the text cannot be
* decoded
*
* @exception IllegalStateException if {@link #getInputStream} method has been called on this request
*
* @exception IOException if an input or output exception occurred
*
* @see #getInputStream
*/
BufferedReader getReader() throws IOException;
/**
* Returns the Internet Protocol (IP) of the remote end of the connection on which the request was received. By default
* this is either the address of the client or last proxy that sent the request. In some cases a protocol specific
* mechanism, such as RFC 7239, may be used to obtain an address
* different to that of the actual TCP/IP connection.
*
* @return a String containing an IP address
*/
String getRemoteAddr();
/**
* Returns the fully qualified name of the address returned by {@link #getRemoteAddr()}. If the engine cannot or chooses
* not to resolve the hostname (to improve performance), this method returns the IP address.
*
* @return a String containing a fully qualified name or IP address.
*/
String getRemoteHost();
/**
* Stores an attribute in this request. Attributes are reset between requests. This method is most often used in
* conjunction with {@link RequestDispatcher}.
*
*
* Attribute names should follow the same conventions as package names.
* If the object passed in is null, the effect is the same as calling {@link #removeAttribute}.
* It is warned that when the request is dispatched from the servlet resides in a different web application by
* RequestDispatcher, the object set by this method may not be correctly retrieved in the caller servlet.
*
* @param name a String specifying the name of the attribute
*
* @param o the Object to be stored
*
*/
void setAttribute(String name, Object o);
/**
*
* Removes an attribute from this request. This method is not generally needed as attributes only persist as long as the
* request is being handled.
*
*
* Attribute names should follow the same conventions as package names. Names beginning with jakarta.* are
* reserved for use by the Jakarta Servlet specification.
*
* @param name a String specifying the name of the attribute to remove
*/
void removeAttribute(String name);
/**
* Returns the preferred Locale that the client will accept content in, based on the Accept-Language
* header. If the client request doesn't provide an Accept-Language header, this method returns the default locale for
* the server.
*
* @return the preferred Locale for the client
*/
Locale getLocale();
/**
* Returns an Enumeration of Locale objects indicating, in decreasing order starting with the
* preferred locale, the locales that are acceptable to the client based on the Accept-Language header. If the client
* request doesn't provide an Accept-Language header, this method returns an Enumeration containing one
* Locale, the default locale for the server.
*
* @return an Enumeration of preferred Locale objects for the client
*/
Enumeration getLocales();
/**
*
* Returns a boolean indicating whether this request was made using a secure channel, such as HTTPS.
*
* @return a boolean indicating if the request was made using a secure channel
*/
boolean isSecure();
/**
*
* Returns a {@link RequestDispatcher} object that acts as a wrapper for the resource located at the given path. A
* RequestDispatcher object can be used to forward a request to the resource or to include the resource in
* a response. The resource can be dynamic or static.
*
*
* The pathname specified may be relative, although it cannot extend outside the current servlet context. If the path
* begins with a "/" it is interpreted as relative to the current context root. This method returns null if
* the servlet container cannot return a RequestDispatcher.
*
*
* Using a RequestDispatcher, requests may be dispatched to any part of the web application bypassing both implicit (no
* direct access to WEB-INF or META-INF) and explicit (defined by the web application) security constraints. Unsanitized
* user provided data must not be used to construct the path passed to the RequestDispatcher as it is very likely to
* create a security vulnerability in the application.
*
*
* The difference between this method and {@link ServletContext#getRequestDispatcher} is that this method can take a
* relative path.
*
*
* The provided {@code path} parameter is canonicalized as per Servlet 6.0,
* 3.5.2 before being used to match resources.
*
* @param path a String specifying the pathname to the resource. If it is relative, it must be relative
* against the current servlet.
*
* @return a RequestDispatcher object that acts as a wrapper for the resource at the specified path, or
* null if the servlet container cannot return a RequestDispatcher
*
* @see RequestDispatcher
* @see ServletContext#getRequestDispatcher
*/
RequestDispatcher getRequestDispatcher(String path);
/**
* Returns the Internet Protocol (IP) source port the remote end of the connection on which the request was received. By
* default this is either the port of the client or last proxy that sent the request. In some cases, protocol specific
* mechanisms such as RFC 7239 may be used to obtain a port different
* to that of the actual TCP/IP connection.
*
* @return an integer specifying the port number
*
* @since Servlet 2.4
*/
int getRemotePort();
/**
* Returns the fully qualified name of the address returned by {@link #getLocalAddr()}. If the engine cannot or chooses
* not to resolve the hostname (to improve performance), this method returns the IP address.
*
* @return a String containing the host name of the IP on which the request was received.
*
* @since Servlet 2.4
*/
String getLocalName();
/**
* Returns the Internet Protocol (IP) address representing the interface on which the request was received. In some
* cases a protocol specific mechanism, such as RFC 7239, may be used
* to obtain an address different to that of the actual TCP/IP connection.
*
* @return a String containing an IP address.
*
* @since Servlet 2.4
*/
String getLocalAddr();
/**
* Returns the Internet Protocol (IP) port number representing the interface on which the request was received. In some
* cases, a protocol specific mechanism such as RFC 7239 may be used
* to obtain an address different to that of the actual TCP/IP connection.
*
* @return an integer specifying a port number
*
* @since Servlet 2.4
*/
int getLocalPort();
/**
* Gets the servlet context to which this ServletRequest was last dispatched.
*
* @return the servlet context to which this ServletRequest was last dispatched
*
* @since Servlet 3.0
*/
ServletContext getServletContext();
/**
* Puts this request into asynchronous mode, and initializes its {@link AsyncContext} with the original (unwrapped)
* ServletRequest and ServletResponse objects.
*
*
* Calling this method will cause committal of the associated response to be delayed until {@link AsyncContext#complete}
* is called on the returned {@link AsyncContext}, or the asynchronous operation has timed out.
*
*
* Calling {@link AsyncContext#hasOriginalRequestAndResponse()} on the returned AsyncContext will return
* true. Any filters invoked in the outbound direction after this request was put into asynchronous
* mode may use this as an indication that any request and/or response wrappers that they added during their
* inbound invocation need not stay around for the duration of the asynchronous operation, and therefore any of
* their associated resources may be released.
*
*
* This method clears the list of {@link AsyncListener} instances (if any) that were registered with the AsyncContext
* returned by the previous call to one of the startAsync methods, after calling each AsyncListener at its
* {@link AsyncListener#onStartAsync onStartAsync} method.
*
*
* Subsequent invocations of this method, or its overloaded variant, will return the same AsyncContext instance,
* reinitialized as appropriate.
*
* @return the (re)initialized AsyncContext
*
* @throws IllegalStateException if this request is within the scope of a filter or servlet that does not support
* asynchronous operations (that is, {@link #isAsyncSupported} returns false), or if this method is called again without
* any asynchronous dispatch (resulting from one of the {@link AsyncContext#dispatch} methods), is called outside the
* scope of any such dispatch, or is called again within the scope of the same dispatch, or if the response has already
* been closed
*
* @see AsyncContext#dispatch()
* @since Servlet 3.0
*/
AsyncContext startAsync() throws IllegalStateException;
/**
* Puts this request into asynchronous mode, and initializes its {@link AsyncContext} with the given request and
* response objects.
*
*
* The ServletRequest and ServletResponse arguments must be the same instances, or instances of
* {@link ServletRequestWrapper} and {@link ServletResponseWrapper} that wrap them, that were passed to the
* {@link Servlet#service service} method of the Servlet or the {@link Filter#doFilter doFilter} method of the Filter,
* respectively, in whose scope this method is being called.
*
*
* Calling this method will cause committal of the associated response to be delayed until {@link AsyncContext#complete}
* is called on the returned {@link AsyncContext}, or the asynchronous operation has timed out.
*
*
* Calling {@link AsyncContext#hasOriginalRequestAndResponse()} on the returned AsyncContext will return
* false, unless the passed in ServletRequest and ServletResponse arguments are the original ones or do not
* carry any application-provided wrappers. Any filters invoked in the outbound direction after this request was
* put into asynchronous mode may use this as an indication that some of the request and/or response wrappers that they
* added during their inbound invocation may need to stay in place for the duration of the asynchronous
* operation, and their associated resources may not be released. A ServletRequestWrapper applied during the
* inbound invocation of a filter may be released by the outbound invocation of the filter only if the
* given servletRequest, which is used to initialize the AsyncContext and will be returned by a call to
* {@link AsyncContext#getRequest()}, does not contain said ServletRequestWrapper. The same holds true for
* ServletResponseWrapper instances.
*
*
* This method clears the list of {@link AsyncListener} instances (if any) that were registered with the AsyncContext
* returned by the previous call to one of the startAsync methods, after calling each AsyncListener at its
* {@link AsyncListener#onStartAsync onStartAsync} method.
*
*
* Subsequent invocations of this method, or its zero-argument variant, will return the same AsyncContext instance,
* reinitialized as appropriate. If a call to this method is followed by a call to its zero-argument variant, the
* specified (and possibly wrapped) request and response objects will remain locked in on the returned
* AsyncContext.
*
* @param servletRequest the ServletRequest used to initialize the AsyncContext
* @param servletResponse the ServletResponse used to initialize the AsyncContext
*
* @return the (re)initialized AsyncContext
*
* @throws IllegalStateException if this request is within the scope of a filter or servlet that does not support
* asynchronous operations (that is, {@link #isAsyncSupported} returns false), or if this method is called again without
* any asynchronous dispatch (resulting from one of the {@link AsyncContext#dispatch} methods), is called outside the
* scope of any such dispatch, or is called again within the scope of the same dispatch, or if the response has already
* been closed
*
* @since Servlet 3.0
*/
AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse)
throws IllegalStateException;
/**
* Checks if this request has been put into asynchronous mode.
*
*
* A ServletRequest is put into asynchronous mode by calling {@link #startAsync} or
* {@link #startAsync(ServletRequest,ServletResponse)} on it.
*
*
* This method returns false if this request was put into asynchronous mode, but has since been dispatched
* using one of the {@link AsyncContext#dispatch} methods or released from asynchronous mode via a call to
* {@link AsyncContext#complete}. If {@link AsyncContext#dispatch} or {@link AsyncContext#complete} is called before the
* container-initiated dispatch that called {@link ServletRequest#startAsync()} has returned to the container then this
* method must return {@code true} until the container-initiated dispatch that called
* {@link ServletRequest#startAsync()} has returned to the container.
*
* @return true if this request has been put into asynchronous mode, false otherwise
*
* @since Servlet 3.0
*/
boolean isAsyncStarted();
/**
* Checks if this request supports asynchronous operation.
*
*
* Asynchronous operation is disabled for this request if this request is within the scope of a filter or servlet that
* has not been annotated or flagged in the deployment descriptor as being able to support asynchronous handling.
*
* @return true if this request supports asynchronous operation, false otherwise
*
* @since Servlet 3.0
*/
boolean isAsyncSupported();
/**
* Gets the AsyncContext that was created or reinitialized by the most recent invocation of {@link #startAsync} or
* {@link #startAsync(ServletRequest,ServletResponse)} on this request.
*
* @return the AsyncContext that was created or reinitialized by the most recent invocation of {@link #startAsync} or
* {@link #startAsync(ServletRequest,ServletResponse)} on this request
*
* @throws IllegalStateException if this request has not been put into asynchronous mode, i.e., if neither
* {@link #startAsync} nor {@link #startAsync(ServletRequest,ServletResponse)} has been called
*
* @since Servlet 3.0
*/
AsyncContext getAsyncContext();
/**
* Gets the dispatcher type of this request.
*
*
* The dispatcher type of a request is used by the container to select the filters that need to be applied to the
* request: Only filters with matching dispatcher type and url patterns will be applied.
*
*
* Allowing a filter that has been configured for multiple dispatcher types to query a request for its dispatcher type
* allows the filter to process the request differently depending on its dispatcher type.
*
*
* The initial dispatcher type of a request is defined as DispatcherType.REQUEST. The dispatcher type of a
* request dispatched via {@link RequestDispatcher#forward(ServletRequest, ServletResponse)} or
* {@link RequestDispatcher#include(ServletRequest, ServletResponse)} is given as DispatcherType.FORWARD or
* DispatcherType.INCLUDE, respectively, while the dispatcher type of an asynchronous request dispatched
* via one of the {@link AsyncContext#dispatch} methods is given as DispatcherType.ASYNC. Finally, the
* dispatcher type of a request dispatched to an error page by the container's error handling mechanism is given as
* DispatcherType.ERROR.
*
* @return the dispatcher type of this request
*
* @see DispatcherType
*
* @since Servlet 3.0
*/
DispatcherType getDispatcherType();
/**
* Obtain a unique (within the lifetime of the Servlet container) identifier string for this request.
*
* There is no defined format for this string. The format is implementation dependent.
*
* @return A unique identifier for the request
*
* @since Servlet 6.0
*/
String getRequestId();
/**
* Obtain the request identifier for this request as defined by the protocol in use. Note that some protocols do not
* define such an identifier.
*
* Examples of protocol provided request identifiers include:
*
* - HTTP 1.x
* - None, so the empty string should be returned
* - HTTP 2
* - The stream identifier
* - HTTP 3
* - The stream identifier
* - AJP
* - None, so the empty string should be returned
*
*
* @return The request identifier if one is defined, otherwise an empty string
*
* @since Servlet 6.0
*/
String getProtocolRequestId();
/**
* Obtain details of the network connection to the Servlet container that is being used by this request. The information
* presented may differ from information presented elsewhere in the Servlet API as raw information is presented without
* adjustments for, example, use of reverse proxies that may be applied elsewhere in the Servlet API.
*
* @return The network connection details.
*
* @since Servlet 6.0
*/
ServletConnection getServletConnection();
}