Java tutorial
/* * Copyright 2010 Lincoln Baxter, III * * 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 com.ocpsoft.pretty; import java.io.IOException; import java.io.Serializable; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.faces.context.FacesContext; import javax.servlet.ServletRequest; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.ocpsoft.pretty.faces.config.PrettyConfig; import com.ocpsoft.pretty.faces.config.PrettyConfigurator; import com.ocpsoft.pretty.faces.config.mapping.UrlMapping; import com.ocpsoft.pretty.faces.url.QueryString; import com.ocpsoft.pretty.faces.url.URL; import com.ocpsoft.pretty.faces.util.Assert; /** * @author Lincoln Baxter, III <lincoln@ocpsoft.com> */ public class PrettyContext implements Serializable { private static final String DEFAULT_ENCODING = "UTF-8"; public static final String CONFIG_KEY = "com.ocpsoft.pretty.CONFIG_FILES"; private static final Log log = LogFactory.getLog(PrettyContext.class); private static final long serialVersionUID = -4593906924975844541L; public static final String PRETTY_PREFIX = "pretty:"; private static final String CONTEXT_REQUEST_KEY = "prettyContext"; private static final Pattern JSESSIONID_PATTERN = Pattern.compile("(?i)^(.*);jsessionid=[\\w\\.\\-]+(.*)"); private static final String JSESSIONID_REPLACEMENT = "$1$2"; private PrettyConfig config; private final String contextPath; private URL requestURL; private final QueryString requestQuery; private UrlMapping currentMapping; private boolean dynaviewProcessed = false; private boolean inNavigation = false; /** * Must create instance through the initialize() method */ protected PrettyContext(final HttpServletRequest request) { Assert.notNull(request, "HttpServletRequest argument was null"); // attribute is set by PrettyFacesRewriteLifecycleListener before config = (PrettyConfig) request.getAttribute(CONFIG_KEY); // not sure if this can happen any more, but we'll keep it for now if (config == null) { config = new PrettyConfig(); } contextPath = request.getContextPath(); String requestUrl = stripContextPath(request.getRequestURI()); Matcher sessionIdMatcher = JSESSIONID_PATTERN.matcher(requestUrl); if (sessionIdMatcher.matches()) { requestUrl = sessionIdMatcher.replaceFirst(JSESSIONID_REPLACEMENT); } String encoding = request.getCharacterEncoding() == null ? DEFAULT_ENCODING : request.getCharacterEncoding(); requestURL = new URL(requestUrl); requestURL.setEncoding(encoding); requestURL = requestURL.decode(); requestQuery = QueryString.build(request.getQueryString()); log.trace("Initialized PrettyContext"); } /** * Get the current PrettyFaces context object, or construct a new one if it * does not yet exist for this request. (Delegates to * {@link FacesContext#getCurrentInstance()} to retrieve the current * {@link HttpServletRequest} object) * * @return current context instance */ public static PrettyContext getCurrentInstance() { FacesContext context = FacesContext.getCurrentInstance(); return getCurrentInstance(context); } /** * Get the current PrettyFaces context object, or construct a new one if it * does not yet exist for this request. (Delegates to {@link FacesContext} to * retrieve the current {@link HttpServletRequest} object) * * @return current context instance */ public static PrettyContext getCurrentInstance(final FacesContext context) { Assert.notNull(context, "FacesContext argument was null."); return getCurrentInstance((HttpServletRequest) context.getExternalContext().getRequest()); } /** * Get the current {@link PrettyContext}, or construct a new one if it does * not yet exist for this request. * * @return current context instance */ public static PrettyContext getCurrentInstance(final HttpServletRequest request) { Assert.notNull(request, "HttpServletRequest argument was null"); PrettyContext prettyContext = (PrettyContext) request.getAttribute(CONTEXT_REQUEST_KEY); if (prettyContext instanceof PrettyContext) { log.trace("Retrieved PrettyContext from Request"); return prettyContext; } else { Assert.notNull(request, "HttpServletRequest argument was null"); prettyContext = newDetachedInstance(request); log.trace("PrettyContext not found in Request - building new instance"); setCurrentContext(request, prettyContext); return prettyContext; } } /** * Return true if there is an instantiated {@link PrettyContext} contained in * the current given request object. */ public static boolean isInstantiated(final ServletRequest request) { Assert.notNull(request, "HttpServletRequest argument was null"); PrettyContext prettyContext = (PrettyContext) request.getAttribute(CONTEXT_REQUEST_KEY); if (prettyContext instanceof PrettyContext) { return true; } else { return false; } } /** * Package private -- only {@link PrettyFilter} should be calling this method * -- it does not overwrite existing contexts in Request object */ public static PrettyContext newDetachedInstance(final HttpServletRequest request) { Assert.notNull(request, "HttpServletRequest argument was null"); PrettyContext prettyContext = new PrettyContext(request); return prettyContext; } /** * Package private -- only PrettyFilter or this class should be calling this * method -- it overwrites existing contexts in Request object */ public static void setCurrentContext(final HttpServletRequest request, final PrettyContext prettyContext) { request.setAttribute(CONTEXT_REQUEST_KEY, prettyContext); } /** * Return the {@link URL} representing the path with which this request was * populated. (Does not include context-path.) */ public URL getRequestURL() { return requestURL; } /** * Return the {@link QueryString} representing the query-string with which * this request was populated. * * @return */ public QueryString getRequestQueryString() { return requestQuery; } /** * Determine if this request URL is mapped by PrettyFaces */ public boolean isPrettyRequest() { return getCurrentMapping() != null; } public String getContextPath() { return contextPath; } /** * If the given URL is prefixed with this request's context-path, return the * URI without the context path. Otherwise return the URI unchanged. */ public String stripContextPath(String uri) { if (uri.startsWith(contextPath)) { uri = uri.substring(contextPath.length()); } return uri; } /** * Get the pretty-config.xml configurations as loaded by * {@link PrettyConfigurator} (This can be dynamically manipulated at runtime * in order to change or add any mappings. */ public PrettyConfig getConfig() { return config; } void setConfig(final PrettyConfig config) { this.config = config; } /** * Get the {@link UrlMapping} representing the current request. */ public UrlMapping getCurrentMapping() { if (currentMapping == null) { currentMapping = config.getMappingForUrl(requestURL); } return currentMapping; } /** * Called once from PrettyFilter to initialize the currentMapping property. * This leads to better performance because the filter already knows the mapping * and we won't have to do the mapping identification again in the getter for * the property. */ void setCurrentMapping(UrlMapping mapping) { currentMapping = mapping; } /** * Return the current viewId to which the current request will be forwarded * to JSF. */ public String getCurrentViewId() { if (getCurrentMapping() != null) { return currentMapping.getViewId(); } return ""; } /** * Return whether or not this faces application is in the Navigation State */ public boolean isInNavigation() { return inNavigation; } /** * Set whether or not to treat this request as if it is in the Navigation * State */ public void setInNavigation(final boolean value) { inNavigation = value; } /** * @return True if the current mapping and request should trigger DynaView * capabilities. */ public boolean shouldProcessDynaview() { if (isPrettyRequest()) { return getCurrentMapping().isDynaView() && !isDynaviewProcessed(); } return false; } /** * Return true if the current request has already processed the DynaView * life-cycle. */ public boolean isDynaviewProcessed() { return dynaviewProcessed; } public void setDynaviewProcessed(final boolean value) { dynaviewProcessed = value; } public String getDynaViewId() { return config.getDynaviewId(); } /** * <p> * Sends an error response to the client using the specified HTTP status * code. * </p> * <p> * Please note that this method can only be called from within the JSF * lifecycle as it needs the {@link FacesContext} to obtain the * {@link HttpServletResponse}. Please use * {@link #sendError(int, String, HttpServletResponse)} in all other * cases. * </p> * * @param code the error status code * @see HttpServletResponse#sendError(int, String) */ public void sendError(int code) { sendError(code, null); } /** * <p> * Sends an error response to the client using the specified HTTP status * code. * </p> * <p> * Please note that this method can only be called from within the JSF * lifecycle as it needs the {@link FacesContext} to obtain the * {@link HttpServletResponse}. Please use * {@link #sendError(int, String, HttpServletResponse)} in all other * cases. * </p> * * @param code the error status code * @param message the descriptive message * @see HttpServletResponse#sendError(int, String) */ public void sendError(int code, String message) { FacesContext facesContext = FacesContext.getCurrentInstance(); Assert.notNull(facesContext, "FacesContext argument was null."); Object response = facesContext.getExternalContext().getResponse(); if (response instanceof HttpServletResponse) { sendError(code, message, (HttpServletResponse) response); facesContext.responseComplete(); } } /** * Sends an error response to the client using the specified HTTP status * code. * * @param code the error status code * @param message the descriptive message * @param response * @see HttpServletResponse#sendError(int, String) */ public void sendError(int code, String message, HttpServletResponse response) { Assert.notNull(response, "HttpServletResponse argument was null"); try { if (message != null) { response.sendError(code, message); } else { response.sendError(code); } } catch (IOException e) { throw new IllegalStateException("Failed to send error code: " + code, e); } } }