/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* 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 javax.servlet;
import java.io.*;
import java.util.*;
/**
* Defines an object to provide client request information to a servlet. The
* servlet container creates a <code>ServletRequest</code> object and passes
* it as an argument to the servlet's <code>service</code> method.
*
* <p>A <code>ServletRequest</code> object provides data including
* parameter name and values, attributes, and an input stream.
* Interfaces that extend <code>ServletRequest</code> can provide
* additional protocol-specific data (for example, HTTP data is
* provided by {@link javax.servlet.http.HttpServletRequest}.
*
* @author Various
*
* @see javax.servlet.http.HttpServletRequest
*
*/
public interface ServletRequest {
/**
*
* Returns the value of the named attribute as an <code>Object</code>,
* or <code>null</code> if no attribute of the given name exists.
*
* <p> 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
* <code>javax.servlet.request.X509Certificate</code> can be used to
* retrieve information on the certificate of the client. Attributes
* can also be set programatically using
* {@link ServletRequest#setAttribute}. This allows information to be
* embedded into a request before a {@link RequestDispatcher} call.
*
* <p>Attribute names should follow the same conventions as package
* names. This specification reserves names matching <code>java.*</code>,
* <code>javax.*</code>, and <code>sun.*</code>.
*
* @param name a <code>String</code> specifying the name of
* the attribute
*
* @return an <code>Object</code> containing the value
* of the attribute, or <code>null</code> if
* the attribute does not exist
*
*/
public Object getAttribute(String name);
/**
* Returns an <code>Enumeration</code> containing the
* names of the attributes available to this request.
* This method returns an empty <code>Enumeration</code>
* if the request has no attributes available to it.
*
*
* @return an <code>Enumeration</code> of strings
* containing the names
* of the request's attributes
*
*/
public Enumeration<String> getAttributeNames();
/**
* Returns the name of the character encoding used in the body of this
* request. This method returns <code>null</code> if the request
* does not specify a character encoding
*
*
* @return a <code>String</code> containing the name of
* the character encoding, or <code>null</code>
* if the request does not specify a character encoding
*
*/
public 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 env <code>String</code> 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
*/
public void setCharacterEncoding(String env) throws UnsupportedEncodingException;
/**
* Returns the length, in bytes, of the request body
* and made available by the input stream, or -1 if the
* length is not known. For HTTP servlets, same as the value
* of the CGI variable CONTENT_LENGTH.
*
* @return an integer containing the length of the
* request body or -1 if the length is not known
*
*/
public int getContentLength();
/**
* Returns the MIME type of the body of the request, or
* <code>null</code> if the type is not known. For HTTP servlets,
* same as the value of the CGI variable CONTENT_TYPE.
*
* @return a <code>String</code> containing the name
* of the MIME type of
* the request, or null if the type is not known
*
*/
public 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
*/
public ServletInputStream getInputStream() throws IOException;
/**
* Returns the value of a request parameter as a <code>String</code>,
* or <code>null</code> 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.
*
* <p>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}.
*
* <p>If you use this method with a multivalued
* parameter, the value returned is equal to the first value
* in the array returned by <code>getParameterValues</code>.
*
* <p>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.
*
* @param name a <code>String</code> specifying the
* name of the parameter
*
* @return a <code>String</code> representing the
* single value of the parameter
*
* @see #getParameterValues
*/
public String getParameter(String name);
/**
*
* Returns an <code>Enumeration</code> of <code>String</code>
* objects containing the names of the parameters contained
* in this request. If the request has
* no parameters, the method returns an
* empty <code>Enumeration</code>.
*
* @return an <code>Enumeration</code> of <code>String</code>
* objects, each <code>String</code> containing
* the name of a request parameter; or an
* empty <code>Enumeration</code> if the
* request has no parameters
*/
public Enumeration<String> getParameterNames();
/**
* Returns an array of <code>String</code> objects containing
* all of the values the given request parameter has, or
* <code>null</code> if the parameter does not exist.
*
* <p>If the parameter has a single value, the array has a length
* of 1.
*
* @param name a <code>String</code> containing the name of
* the parameter whose value is requested
*
* @return an array of <code>String</code> objects
* containing the parameter's values
*
* @see #getParameter
*/
public String[] getParameterValues(String name);
/**
* Returns a java.util.Map of the parameters of this request.
*
* <p>Request parameters are extra information sent with the request.
* For HTTP servlets, parameters are contained in the query string or
* posted form data.
*
* @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.
*/
public Map<String, String[]> getParameterMap();
/**
* Returns the name and version of the protocol the request uses
* in the form <i>protocol/majorVersion.minorVersion</i>, for
* example, HTTP/1.1. For HTTP servlets, the value
* returned is the same as the value of the CGI variable
* <code>SERVER_PROTOCOL</code>.
*
* @return a <code>String</code> containing the protocol
* name and version number
*/
public String getProtocol();
/**
* Returns the name of the scheme used to make this request,
* for example,
* <code>http</code>, <code>https</code>, or <code>ftp</code>.
* Different schemes have different rules for constructing URLs,
* as noted in RFC 1738.
*
* @return a <code>String</code> containing the name
* of the scheme used to make this request
*/
public String getScheme();
/**
* Returns the host name of the server to which the request was sent.
* It is the value of the part before ":" in the <code>Host</code>
* header value, if any, or the resolved server name, or the server IP
* address.
*
* @return a <code>String</code> containing the name
* of the server
*/
public String getServerName();
/**
* Returns the port number to which the request was sent.
* It is the value of the part after ":" in the <code>Host</code>
* header value, if any, or the server port where the client connection
* was accepted on.
*
* @return an integer specifying the port number
*
*/
public int getServerPort();
/**
* Retrieves the body of the request as character data using
* a <code>BufferedReader</code>. 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 <code>BufferedReader</code>
* 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
*
*/
public BufferedReader getReader() throws IOException;
/**
* Returns the Internet Protocol (IP) address of the client
* or last proxy that sent the request.
* For HTTP servlets, same as the value of the
* CGI variable <code>REMOTE_ADDR</code>.
*
* @return a <code>String</code> containing the
* IP address of the client that sent the request
*
*/
public String getRemoteAddr();
/**
* Returns the fully qualified name of the client
* or the last proxy that sent the request.
* If the engine cannot or chooses not to resolve the hostname
* (to improve performance), this method returns the dotted-string form of
* the IP address. For HTTP servlets, same as the value of the CGI variable
* <code>REMOTE_HOST</code>.
*
* @return a <code>String</code> containing the fully
* qualified name of the client
*
*/
public String getRemoteHost();
/**
*
* Stores an attribute in this request.
* Attributes are reset between requests. This method is most
* often used in conjunction with {@link RequestDispatcher}.
*
* <p>Attribute names should follow the same conventions as
* package names. Names beginning with <code>java.*</code>,
* <code>javax.*</code>, and <code>com.sun.*</code>, are
* reserved for use by Sun Microsystems.
*<br> If the object passed in is null, the effect is the same as
* calling {@link #removeAttribute}.
* <br> It is warned that when the request is dispatched from the
* servlet resides in a different web application by
* <code>RequestDispatcher</code>, the object set by this method
* may not be correctly retrieved in the caller servlet.
*
*
* @param name a <code>String</code> specifying
* the name of the attribute
*
* @param o the <code>Object</code> to be stored
*
*/
public 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.
*
* <p>Attribute names should follow the same conventions as
* package names. Names beginning with <code>java.*</code>,
* <code>javax.*</code>, and <code>com.sun.*</code>, are
* reserved for use by Sun Microsystems.
*
*
* @param name a <code>String</code> specifying
* the name of the attribute to remove
*
*/
public void removeAttribute(String name);
/**
* Returns the preferred <code>Locale</code> 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 <code>Locale</code> for the client
*/
public Locale getLocale();
/**
* Returns an <code>Enumeration</code> of <code>Locale</code> 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 <code>Enumeration</code> containing one
* <code>Locale</code>, the default locale for the server.
*
* @return an <code>Enumeration</code> of preferred
* <code>Locale</code> objects for the client
*/
public Enumeration<Locale> 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
*
*/
public boolean isSecure();
/**
*
* Returns a {@link RequestDispatcher} object that acts as a wrapper for
* the resource located at the given path.
* A <code>RequestDispatcher</code> 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.
*
* <p>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 <code>null</code> if the servlet container
* cannot return a <code>RequestDispatcher</code>.
*
* <p>The difference between this method and {@link
* ServletContext#getRequestDispatcher} is that this method can take a
* relative path.
*
* @param path a <code>String</code> specifying the pathname
* to the resource. If it is relative, it must be
* relative against the current servlet.
*
* @return a <code>RequestDispatcher</code> object
* that acts as a wrapper for the resource
* at the specified path, or <code>null</code>
* if the servlet container cannot return a
* <code>RequestDispatcher</code>
*
* @see RequestDispatcher
* @see ServletContext#getRequestDispatcher
*/
public RequestDispatcher getRequestDispatcher(String path);
/**
* @deprecated As of Version 2.1 of the Java Servlet API,
* use {@link ServletContext#getRealPath} instead.
*/
public String getRealPath(String path);
/**
* Returns the Internet Protocol (IP) source port of the client
* or last proxy that sent the request.
*
* @return an integer specifying the port number
*
* @since Servlet 2.4
*/
public int getRemotePort();
/**
* Returns the host name of the Internet Protocol (IP) interface on
* which the request was received.
*
* @return a <code>String</code> containing the host
* name of the IP on which the request was received.
*
* @since Servlet 2.4
*/
public String getLocalName();
/**
* Returns the Internet Protocol (IP) address of the interface on
* which the request was received.
*
* @return a <code>String</code> containing the
* IP address on which the request was received.
*
* @since Servlet 2.4
*
*/
public String getLocalAddr();
/**
* Returns the Internet Protocol (IP) port number of the interface
* on which the request was received.
*
* @return an integer specifying the port number
*
* @since Servlet 2.4
*/
public 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
*/
public ServletContext getServletContext();
/**
* Puts this request into asynchronous mode, and initializes its
* {@link AsyncContext} with the original (unwrapped) ServletRequest
* and ServletResponse objects.
*
* <p>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.
*
* <p>Calling {@link AsyncContext#hasOriginalRequestAndResponse()} on
* the returned AsyncContext will return <code>true</code>. Any filters
* invoked in the <i>outbound</i> 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 <i>inbound</i>
* invocation need not stay around for the duration of the asynchronous
* operation, and therefore any of their associated resources may be
* released.
*
* <p>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.
*
* <p>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
*
* @since Servlet 3.0
*/
public AsyncContext startAsync() throws IllegalStateException;
/**
* Puts this request into asynchronous mode, and initializes its
* {@link AsyncContext} with the given request and response objects.
*
* <p>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.
*
* <p>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.
*
* <p>Calling {@link AsyncContext#hasOriginalRequestAndResponse()} on
* the returned AsyncContext will return <code>false</code>,
* 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 <i>outbound</i> 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 <i>inbound</i> 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 <i>inbound</i>
* invocation of a filter may be released by the <i>outbound</i>
* invocation of the filter only if the given <code>servletRequest</code>,
* 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.
*
* <p>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.
*
* <p>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 <i>locked in</i> 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
*/
public AsyncContext startAsync(ServletRequest servletRequest,
ServletResponse servletResponse)
throws IllegalStateException;
/**
* Checks if this request has been put into asynchronous mode.
*
* <p>A ServletRequest is put into asynchronous mode by calling
* {@link #startAsync} or
* {@link #startAsync(ServletRequest,ServletResponse)} on it.
*
* <p>This method returns <tt>false</tt> 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}.
*
* @return true if this request has been put into asynchronous mode,
* false otherwise
*
* @since Servlet 3.0
*/
public boolean isAsyncStarted();
/**
* Checks if this request supports asynchronous operation.
*
* <p>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
*/
public 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
*/
public AsyncContext getAsyncContext();
/**
* Gets the dispatcher type of this request.
*
* <p>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.
*
* <p>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.
*
* <p>The initial dispatcher type of a request is defined as
* <code>DispatcherType.REQUEST</code>. The dispatcher type of a request
* dispatched via {@link RequestDispatcher#forward(ServletRequest,
* ServletResponse)} or {@link RequestDispatcher#include(ServletRequest,
* ServletResponse)} is given as <code>DispatcherType.FORWARD</code> or
* <code>DispatcherType.INCLUDE</code>, respectively, while the
* dispatcher type of an asynchronous request dispatched via
* one of the {@link AsyncContext#dispatch} methods is given as
* <code>DispatcherType.ASYNC</code>. Finally, the dispatcher type of a
* request dispatched to an error page by the container's error handling
* mechanism is given as <code>DispatcherType.ERROR</code>.
*
* @return the dispatcher type of this request
*
* @see DispatcherType
*
* @since Servlet 3.0
*/
public DispatcherType getDispatcherType();
}