Glassfish example source code file (ApplicationHttpRequest.java)
The Glassfish ApplicationHttpRequest.java source code/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. 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_1_1.html
* or packager/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 packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [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 org.apache.catalina.core;
import org.apache.catalina.Context;
import org.apache.catalina.Globals;
import org.apache.catalina.Manager;
import org.apache.catalina.Session;
import org.apache.catalina.connector.RequestFacade;
import org.apache.catalina.connector.SessionTracker;
import org.apache.catalina.session.StandardSession;
import org.apache.catalina.util.Enumerator;
import org.apache.catalina.util.RequestUtil;
import org.apache.catalina.util.StringManager;
import javax.servlet.AsyncContext;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.*;
// END GlassFish 896
/**
* Wrapper around a <code>javax.servlet.http.HttpServletRequest
* that transforms an application request object (which might be the original
* one passed to a servlet, or might be based on the 2.3
* <code>javax.servlet.http.HttpServletRequestWrapper class)
* back into an internal <code>org.apache.catalina.HttpRequest.
*
* @author Craig R. McClanahan
* @author Remy Maucherat
* @version $Revision: 1.15 $ $Date: 2007/05/03 21:58:54 $
*/
public class ApplicationHttpRequest extends HttpServletRequestWrapper {
// ------------------------------------------------------- Static Variables
/**
* The string manager for this package.
*/
protected static final StringManager sm =
StringManager.getManager(Constants.Package);
/**
* The set of attribute names that are special for request dispatchers
*/
private static final HashSet<String> specials = new HashSet(15);
static {
specials.add(RequestDispatcher.INCLUDE_REQUEST_URI);
specials.add(RequestDispatcher.INCLUDE_CONTEXT_PATH);
specials.add(RequestDispatcher.INCLUDE_SERVLET_PATH);
specials.add(RequestDispatcher.INCLUDE_PATH_INFO);
specials.add(RequestDispatcher.INCLUDE_QUERY_STRING);
specials.add(RequestDispatcher.FORWARD_REQUEST_URI);
specials.add(RequestDispatcher.FORWARD_CONTEXT_PATH);
specials.add(RequestDispatcher.FORWARD_SERVLET_PATH);
specials.add(RequestDispatcher.FORWARD_PATH_INFO);
specials.add(RequestDispatcher.FORWARD_QUERY_STRING);
specials.add(AsyncContext.ASYNC_REQUEST_URI);
specials.add(AsyncContext.ASYNC_CONTEXT_PATH);
specials.add(AsyncContext.ASYNC_SERVLET_PATH);
specials.add(AsyncContext.ASYNC_PATH_INFO);
specials.add(AsyncContext.ASYNC_QUERY_STRING);
}
// ----------------------------------------------------------- Constructors
/**
* Construct a new wrapped request around the specified servlet request.
*
* @param request the servlet request being wrapped
* @param context the target context of the request dispatch
* @param crossContext true if this is a cross-context dispatch, false
* otherwise
* @param dispatcherType the dispatcher type
*/
public ApplicationHttpRequest(HttpServletRequest request,
Context context,
boolean crossContext,
DispatcherType dispatcherType) {
super(request);
this.context = context;
this.crossContext = crossContext;
this.dispatcherType = dispatcherType;
setRequest(request);
if (context.getManager() != null) {
isSessionVersioningSupported =
context.getManager().isSessionVersioningSupported();
if (isSessionVersioningSupported) {
HashMap<String, String> sessionVersions =
(HashMap<String, String>) getAttribute(
Globals.SESSION_VERSIONS_REQUEST_ATTRIBUTE);
if (sessionVersions != null) {
requestedSessionVersion = sessionVersions.get(
context.getPath());
}
}
}
}
// ----------------------------------------------------- Instance Variables
/**
* The context for this request.
*/
protected Context context = null;
/**
* The context path for this request.
*/
protected String contextPath = null;
/**
* If this request is cross context, since this changes session access
* behavior.
*/
protected boolean crossContext = false;
/**
* The dispatcher type.
*/
protected DispatcherType dispatcherType;
/**
* The request parameters for this request. This is initialized from the
* wrapped request, but updates are allowed.
*/
protected Map<String, String[]> parameters = null;
/**
* Have the parameters for this request already been parsed?
*/
private boolean parsedParams = false;
/**
* The path information for this request.
*/
protected String pathInfo = null;
/**
* The query parameters for the current request.
*/
private String queryParamString = null;
/**
* The query string for this request.
*/
protected String queryString = null;
/**
* The current request dispatcher path.
*/
protected Object requestDispatcherPath = null;
/**
* The request URI for this request.
*/
protected String requestURI = null;
/**
* The servlet path for this request.
*/
protected String servletPath = null;
/**
* The currently active session for this request.
*/
protected Session session = null;
/**
* Special attributes.
*/
private HashMap specialAttributes = null;
private String requestedSessionVersion = null;
private boolean isSessionVersioningSupported = false;
// ------------------------------------------------- ServletRequest Methods
/**
* Override the <code>getAttribute() method of the wrapped request.
*
* @param name Name of the attribute to retrieve
*/
@Override
public Object getAttribute(String name) {
if (name.equals(Globals.DISPATCHER_REQUEST_PATH_ATTR)) {
if ( requestDispatcherPath != null ){
return requestDispatcherPath.toString();
} else {
return null;
}
}
if (!isSpecial(name)) {
return getRequest().getAttribute(name);
} else {
Object value = null;
if (specialAttributes != null) {
value = specialAttributes.get(name);
}
if (value == null && name.startsWith("javax.servlet.forward")) {
/*
* If it's a forward special attribute, and null, delegate
* to the wrapped request. This will allow access to the
* forward special attributes from a request that was first
* forwarded and then included, or forwarded multiple times
* in a row.
* Notice that forward special attributes are set only on
* the wrapper that was created for the initial forward
* (i.e., the top-most wrapper for a request that was
* forwarded multiple times in a row, and never included,
* will not contain any specialAttributes!).
* This is different from an include, where the special
* include attributes are set on every include wrapper.
*/
value = getRequest().getAttribute(name);
}
return value;
}
}
/**
* Override the <code>getAttributeNames() method of the wrapped
* request.
*/
@Override
public Enumeration<String> getAttributeNames() {
return (new AttributeNamesEnumerator());
}
/**
* Override the <code>removeAttribute() method of the
* wrapped request.
*
* @param name Name of the attribute to remove
*/
@Override
public void removeAttribute(String name) {
if (isSpecial(name)) {
if (specialAttributes != null) {
specialAttributes.remove(name);
}
} else {
getRequest().removeAttribute(name);
}
}
/**
* Override the <code>setAttribute() method of the
* wrapped request.
*
* @param name Name of the attribute to set
* @param value Value of the attribute to set
*/
@Override
public void setAttribute(String name, Object value) {
if (name.equals(Globals.DISPATCHER_REQUEST_PATH_ATTR)) {
requestDispatcherPath = value;
return;
}
if (isSpecial(name)) {
if (specialAttributes != null) {
specialAttributes.put(name, value);
}
} else {
getRequest().setAttribute(name, value);
}
}
/**
* Return a RequestDispatcher that wraps the resource at the specified
* path, which may be interpreted as relative to the current request path.
*
* @param path Path of the resource to be wrapped
*/
@Override
public RequestDispatcher getRequestDispatcher(String path) {
if (context == null)
return (null);
// If the path is already context-relative, just pass it through
if (path == null)
return (null);
else if (path.startsWith("/"))
return (context.getServletContext().getRequestDispatcher(path));
// Convert a request-relative path to a context-relative one
String servletPath =
(String) getAttribute(RequestDispatcher.INCLUDE_SERVLET_PATH);
if (servletPath == null)
servletPath = getServletPath();
// Add the path info, if there is any
String pathInfo = getPathInfo();
String requestPath = null;
if (pathInfo == null) {
requestPath = servletPath;
} else {
requestPath = servletPath + pathInfo;
}
int pos = requestPath.lastIndexOf('/');
String relative = null;
if (pos >= 0) {
relative = requestPath.substring(0, pos + 1) + path;
} else {
relative = requestPath + path;
}
return (context.getServletContext().getRequestDispatcher(relative));
}
@Override
public DispatcherType getDispatcherType() {
return dispatcherType;
}
// --------------------------------------------- HttpServletRequest Methods
/**
* Override the <code>getContextPath() method of the wrapped
* request.
*/
@Override
public String getContextPath() {
return (this.contextPath);
}
/**
* Override the <code>getParameter() method of the wrapped request.
*
* @param name Name of the requested parameter
*/
@Override
public String getParameter(String name) {
parseParameters();
synchronized (parameters) {
Object value = parameters.get(name);
if (value == null)
return (null);
else if (value instanceof String[])
return (((String[]) value)[0]);
else if (value instanceof String)
return ((String) value);
else
return (value.toString());
}
}
/**
* Override the <code>getParameterMap() method of the
* wrapped request.
*/
@Override
public Map<String, String[]> getParameterMap() {
parseParameters();
return (parameters);
}
/**
* Override the <code>getParameterNames() method of the
* wrapped request.
*/
@Override
public Enumeration<String> getParameterNames() {
parseParameters();
synchronized (parameters) {
return (new Enumerator<String>(parameters.keySet()));
}
}
/**
* Override the <code>getParameterValues() method of the
* wrapped request.
*
* @param name Name of the requested parameter
*/
@Override
public String[] getParameterValues(String name) {
parseParameters();
synchronized (parameters) {
Object value = parameters.get(name);
if (value == null)
return ((String[]) null);
else if (value instanceof String[])
return ((String[]) value);
else if (value instanceof String) {
String values[] = new String[1];
values[0] = (String) value;
return (values);
} else {
String values[] = new String[1];
values[0] = value.toString();
return (values);
}
}
}
/**
* Override the <code>getPathInfo() method of the wrapped request.
*/
@Override
public String getPathInfo() {
return (this.pathInfo);
}
/**
* Override the <code>getQueryString() method of the wrapped
* request.
*/
@Override
public String getQueryString() {
return (this.queryString);
}
/**
* Override the <code>getRequestURI() method of the wrapped
* request.
*/
@Override
public String getRequestURI() {
return (this.requestURI);
}
/**
* Override the <code>getRequestURL() method of the wrapped
* request.
*/
@Override
public StringBuffer getRequestURL() {
StringBuffer url = new StringBuffer();
String scheme = getScheme();
int port = getServerPort();
if (port < 0)
port = 80; // Work around java.net.URL bug
url.append(scheme);
url.append("://");
url.append(getServerName());
if ((scheme.equals("http") && (port != 80))
|| (scheme.equals("https") && (port != 443))) {
url.append(':');
url.append(port);
}
url.append(getRequestURI());
return (url);
}
/**
* Override the <code>getServletPath() method of the wrapped
* request.
*/
@Override
public String getServletPath() {
return (this.servletPath);
}
/**
* Return the session associated with this Request, creating one
* if necessary.
*/
@Override
public HttpSession getSession() {
return (getSession(true));
}
/**
* Return the session associated with this Request, creating one
* if necessary and requested.
*
* @param create Create a new session if one does not exist
*/
@Override
public HttpSession getSession(boolean create) {
if (crossContext) {
// There cannot be a session if no context has been assigned yet
if (context == null)
return (null);
// Return the current session if it exists and is valid
if (session != null && session.isValid()) {
return (session.getSession());
}
HttpSession other = super.getSession(false);
if (create && (other == null)) {
// First create a session in the first context: the problem is
// that the top level request is the only one which can
// create the cookie safely
other = super.getSession(true);
}
if (other != null) {
Session localSession = null;
try {
if (isSessionVersioningSupported) {
localSession =
context.getManager().findSession(
other.getId(),
requestedSessionVersion);
//XXX need to revisit
if (localSession instanceof StandardSession) {
incrementSessionVersion((StandardSession) localSession,
context);
}
} else {
localSession =
context.getManager().findSession(other.getId());
}
} catch (IOException e) {
// Ignore
}
if ((localSession != null) && !localSession.isValid()) {
localSession = null;
} else if (localSession == null && create) {
//START OF 6364900
localSession =
context.getManager().createSession(other.getId());
//XXX need to revisit
if (isSessionVersioningSupported &&
localSession instanceof StandardSession) {
incrementSessionVersion((StandardSession) localSession,
context);
}
//END OF 6364900
/* CR 6364900
localSession = context.getManager().createEmptySession();
localSession.setNew(true);
localSession.setValid(true);
localSession.setCreationTime(System.currentTimeMillis());
localSession.setMaxInactiveInterval
(context.getManager().getMaxInactiveIntervalSeconds());
localSession.setId(other.getId());
*/
// START GlassFish 896
SessionTracker sessionTracker = (SessionTracker)
getRequestFacade().getNote(Globals.SESSION_TRACKER);
if (sessionTracker != null) {
sessionTracker.track(localSession);
}
// END GlassFish 896
}
if (localSession != null) {
localSession.access();
session = localSession;
return session.getSession();
}
}
return null;
} else {
return super.getSession(create);
}
}
/**
* Returns true if the request specifies a JSESSIONID that is valid within
* the context of this ApplicationHttpRequest, false otherwise.
*
* @return true if the request specifies a JSESSIONID that is valid within
* the context of this ApplicationHttpRequest, false otherwise.
*/
@Override
public boolean isRequestedSessionIdValid() {
if (crossContext) {
String requestedSessionId = getRequestedSessionId();
if (requestedSessionId == null)
return (false);
if (context == null)
return (false);
if (session != null
&& requestedSessionId.equals(session.getIdInternal())) {
return session.isValid();
}
Manager manager = context.getManager();
if (manager == null)
return (false);
Session localSession = null;
try {
if (isSessionVersioningSupported) {
localSession = manager.findSession(requestedSessionId,
requestedSessionVersion);
} else {
localSession = manager.findSession(requestedSessionId);
}
} catch (IOException e) {
localSession = null;
}
if ((localSession != null) && localSession.isValid()) {
return (true);
} else {
return (false);
}
} else {
return super.isRequestedSessionIdValid();
}
}
// -------------------------------------------------------- Package Methods
/**
* Recycle this request
*/
public void recycle() {
if (session != null) {
session.endAccess();
}
}
/**
* Perform a shallow copy of the specified Map, and return the result.
*
* @param orig Origin Map to be copied
*/
Map<String, String[]> copyMap(Map
Other Glassfish examples (source code examples)Here is a short list of links related to this Glassfish ApplicationHttpRequest.java source code file: |
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
