You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@struts.apache.org by lu...@apache.org on 2015/06/23 17:14:41 UTC
[3/4] struts git commit: WW-4518 Moves results to dedicated package
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java b/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
index 82d2a55..f10cd48 100644
--- a/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
+++ b/core/src/main/java/org/apache/struts2/interceptor/MessageStoreInterceptor.java
@@ -27,7 +27,7 @@ import com.opensymphony.xwork2.interceptor.ValidationAware;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
-import org.apache.struts2.dispatcher.ServletRedirectResult;
+import org.apache.struts2.result.ServletRedirectResult;
import java.util.ArrayList;
import java.util.Collection;
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java b/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
new file mode 100644
index 0000000..4745475
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/HttpHeaderResult.java
@@ -0,0 +1,210 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.Result;
+import com.opensymphony.xwork2.util.TextParseUtil;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ * <p/>
+ * A custom Result type for setting HTTP headers and status by optionally evaluating against the ValueStack.
+ * This result can also be used to send and error to the client. All the parameters can be evaluated against the ValueStack.
+ * <p/>
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ * <p/>
+ * <!-- START SNIPPET: params -->
+ * <p/>
+ * <ul>
+ * <p/>
+ * <li><b>status</b> - the http servlet response status code that should be set on a response.</li>
+ * <p/>
+ * <li><b>parse</b> - true by default. If set to false, the headers param will not be parsed for Ognl expressions.</li>
+ * <p/>
+ * <li><b>headers</b> - header values.</li>
+ * <p/>
+ * <li><b>error</b> - the http servlet response error code that should be set on a response.</li>
+ * <p/>
+ * <li><b>errorMessage</b> - error message to be set on response if 'error' is set.</li>
+ * </ul>
+ * <p/>
+ * <!-- END SNIPPET: params -->
+ * <p/>
+ * <b>Example:</b>
+ * <p/>
+ * <pre><!-- START SNIPPET: example -->
+ * <result name="success" type="httpheader">
+ * <param name="status">204</param>
+ * <param name="headers.a">a custom header value</param>
+ * <param name="headers.b">another custom header value</param>
+ * </result>
+ * <p/>
+ * <result name="proxyRequired" type="httpheader">
+ * <param name="error">305</param>
+ * <param name="errorMessage">this action must be accessed through a prozy</param>
+ * </result>
+ * <!-- END SNIPPET: example --></pre>
+ */
+public class HttpHeaderResult implements Result {
+
+ private static final long serialVersionUID = 195648957144219214L;
+ private static final Logger LOG = LogManager.getLogger(HttpHeaderResult.class);
+
+ /**
+ * This result type doesn't have a default param, null is ok to reduce noise in logs
+ */
+ public static final String DEFAULT_PARAM = null;
+
+ private boolean parse = true;
+ private Map<String, String> headers;
+ private int status = -1;
+ private String error = null;
+ private String errorMessage;
+
+ public HttpHeaderResult() {
+ super();
+ headers = new HashMap<>();
+ }
+
+ public HttpHeaderResult(int status) {
+ this();
+ this.status = status;
+ this.parse = false;
+ }
+
+ /**
+ * Sets the http servlet error code that should be set on the response
+ *
+ * @param error the Http error code
+ * @see javax.servlet.http.HttpServletResponse#sendError(int)
+ */
+ public void setError(String error) {
+ this.error = error;
+ }
+
+ /**
+ * Sets the error message that should be set on the reponse
+ *
+ * @param errorMessage error message send to the client
+ * @see javax.servlet.http.HttpServletResponse#sendError(int, String)
+ */
+ public void setErrorMessage(String errorMessage) {
+ this.errorMessage = errorMessage;
+ }
+
+ /**
+ * Returns a Map of all HTTP headers.
+ *
+ * @return a Map of all HTTP headers.
+ */
+ public Map<String, String> getHeaders() {
+ return headers;
+ }
+
+ /**
+ * Sets whether or not the HTTP header values should be evaluated against the ValueStack (by default they are).
+ *
+ * @param parse <tt>true</tt> if HTTP header values should be evaluated against the ValueStack, <tt>false</tt>
+ * otherwise.
+ */
+ public void setParse(boolean parse) {
+ this.parse = parse;
+ }
+
+ /**
+ * Sets the http servlet response status code that should be set on a response.
+ *
+ * @param status the Http status code
+ * @see javax.servlet.http.HttpServletResponse#setStatus(int)
+ */
+ public void setStatus(int status) {
+ this.status = status;
+ }
+
+ public int getStatus() {
+ return status;
+ }
+
+ /**
+ * Adds an HTTP header to the response
+ *
+ * @param name header name
+ * @param value header value
+ */
+ public void addHeader(String name, String value) {
+ headers.put(name, value);
+ }
+
+ /**
+ * Sets the optional HTTP response status code and also re-sets HTTP headers after they've
+ * been optionally evaluated against the ValueStack.
+ *
+ * @param invocation an encapsulation of the action execution state.
+ * @throws Exception if an error occurs when re-setting the headers.
+ */
+ public void execute(ActionInvocation invocation) throws Exception {
+ HttpServletResponse response = ServletActionContext.getResponse();
+ ValueStack stack = ActionContext.getContext().getValueStack();
+
+ if (status != -1) {
+ response.setStatus(status);
+ }
+
+ if (headers != null) {
+ for (Map.Entry<String, String> entry : headers.entrySet()) {
+ String value = entry.getValue();
+ String finalValue = parse ? TextParseUtil.translateVariables(value, stack) : value;
+ response.addHeader(entry.getKey(), finalValue);
+ }
+ }
+
+ if (status == -1 && error != null) {
+ int errorCode = -1;
+ try {
+ errorCode = Integer.parseInt(parse ? TextParseUtil.translateVariables(error, stack) : error);
+ } catch (Exception e) {
+ LOG.error("Cannot parse errorCode [{}] value as Integer!", error, e);
+ }
+ if (errorCode != -1) {
+ if (errorMessage != null) {
+ String finalMessage = parse ? TextParseUtil.translateVariables(errorMessage, stack) : errorMessage;
+ response.sendError(errorCode, finalMessage);
+ } else {
+ response.sendError(errorCode);
+ }
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/PlainTextResult.java b/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
new file mode 100644
index 0000000..44d9302
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/PlainTextResult.java
@@ -0,0 +1,183 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * A result that send the content out as plain text. Useful typically when needed
+ * to display the raw content of a JSP or Html file for example.
+ *
+ * <!-- END SNIPPET: description -->
+ *
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ * <li>location (default) = location of the file (jsp/html) to be displayed as plain text.</li>
+ * <li>charSet (optional) = character set to be used. This character set will be used to set the
+ * response type (eg. Content-Type=text/plain; charset=UTF-8) and when reading
+ * using a Reader. Some example of charSet would be UTF-8, ISO-8859-1 etc.
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ *
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ *
+ * <action name="displayJspRawContent" >
+ * <result type="plainText">/myJspFile.jsp</result>
+ * </action>
+ *
+ *
+ * <action name="displayJspRawContent" >
+ * <result type="plainText">
+ * <param name="location">/myJspFile.jsp</param>
+ * <param name="charSet">UTF-8</param>
+ * </result>
+ * </action>
+ *
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ *
+ */
+public class PlainTextResult extends StrutsResultSupport {
+
+ public static final int BUFFER_SIZE = 1024;
+
+ private static final Logger LOG = LogManager.getLogger(PlainTextResult.class);
+
+ private static final long serialVersionUID = 3633371605905583950L;
+
+ private String charSet;
+
+ public PlainTextResult() {
+ super();
+ }
+
+ public PlainTextResult(String location) {
+ super(location);
+ }
+
+ /**
+ * Set the character set
+ *
+ * @return The character set
+ */
+ public String getCharSet() {
+ return charSet;
+ }
+
+ /**
+ * Set the character set
+ *
+ * @param charSet The character set
+ */
+ public void setCharSet(String charSet) {
+ this.charSet = charSet;
+ }
+
+ /* (non-Javadoc)
+ * @see org.apache.struts2.result.StrutsResultSupport#doExecute(java.lang.String, com.opensymphony.xwork2.ActionInvocation)
+ */
+ protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+ // verify charset
+ Charset charset = readCharset();
+
+ HttpServletResponse response = (HttpServletResponse) invocation.getInvocationContext().get(HTTP_RESPONSE);
+
+ applyCharset(charset, response);
+ applyAdditionalHeaders(response);
+ String location = adjustLocation(finalLocation);
+
+ try (PrintWriter writer = response.getWriter();
+ InputStream resourceAsStream = readStream(invocation, location);
+ InputStreamReader reader = new InputStreamReader(resourceAsStream, charset == null ? Charset.defaultCharset() : charset)) {
+ logWrongStream(finalLocation, resourceAsStream);
+ sendStream(writer, reader);
+ }
+ }
+
+ protected InputStream readStream(ActionInvocation invocation, String location) {
+ ServletContext servletContext = (ServletContext) invocation.getInvocationContext().get(SERVLET_CONTEXT);
+ return servletContext.getResourceAsStream(location);
+ }
+
+ protected void logWrongStream(String finalLocation, InputStream resourceAsStream) {
+ if (resourceAsStream == null) {
+ LOG.warn("Resource at location [{}] cannot be obtained (return null) from ServletContext !!!", finalLocation);
+ }
+ }
+
+ protected void sendStream(PrintWriter writer, InputStreamReader reader) throws IOException {
+ char[] buffer = new char[BUFFER_SIZE];
+ int charRead;
+ while((charRead = reader.read(buffer)) != -1) {
+ writer.write(buffer, 0, charRead);
+ }
+ }
+
+ protected String adjustLocation(String location) {
+ if (location.charAt(0) != '/') {
+ return "/" + location;
+ }
+ return location;
+ }
+
+ protected void applyAdditionalHeaders(HttpServletResponse response) {
+ response.setHeader("Content-Disposition", "inline");
+ }
+
+ protected void applyCharset(Charset charset, HttpServletResponse response) {
+ if (charset != null) {
+ response.setContentType("text/plain; charset=" + charSet);
+ } else {
+ response.setContentType("text/plain");
+ }
+ }
+
+ protected Charset readCharset() {
+ Charset charset = null;
+ if (charSet != null) {
+ if (Charset.isSupported(charSet)) {
+ charset = Charset.forName(charSet);
+ } else {
+ LOG.warn("charset [{}] is not recognized", charset);
+ charset = null;
+ }
+ }
+ return charset;
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/PostbackResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/PostbackResult.java b/core/src/main/java/org/apache/struts2/result/PostbackResult.java
new file mode 100644
index 0000000..ee14384
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/PostbackResult.java
@@ -0,0 +1,232 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.Map;
+
+/**
+ * <!-- START SNIPPET: description -->
+ * A result that renders the current request parameters as a form which
+ * immediately submits a <a href="http://en.wikipedia.org/wiki/Postback">postback</a>
+ * to the specified destination.
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>Parameters:</b>
+ * <!-- START SNIPPET: params -->
+ * <ul>
+ * <li>location - http location to post the form</li>
+ * <li>prependServletContext (true|false) - when location is relative, controls if to add Servlet Context, default "true"</li>
+ * <li>actionName - action name to post the form (resolved as an expression)</li>
+ * <li>namespace - action's namespace to use (resolved as an expression)</li>
+ * <li>method - actions' method to use (resolved as an expression)</li>
+ * <li>cache (true|false) - when set to true adds cache control headers, default "true"</li>
+ * <li>parse (true|false) - when set to true actionName, namespace and method are parsed, default "true"</li>
+ * </ul>
+ * <!-- END SNIPPET: params -->
+ * <p/>
+ * <b>Examples:</b>
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * <action name="registerThirdParty" >
+ * <result type="postback">https://www.example.com/register</result>
+ * </action>
+ *
+ * <action name="registerThirdParty" >
+ * <result type="postback">
+ * <param name="namespace">/secure</param>
+ * <param name="actionName">register2</param>
+ * </result>
+ * </action>
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ */
+public class PostbackResult extends StrutsResultSupport {
+
+ private String actionName;
+ private String namespace;
+ private String method;
+ private boolean prependServletContext = true;
+ private boolean cache = true;
+
+ protected ActionMapper actionMapper;
+
+ @Override
+ protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+ ActionContext ctx = invocation.getInvocationContext();
+ HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+ HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);
+
+ // Cache?
+ if (!cache) {
+ response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // HTTP 1.1
+ response.setHeader("Pragma", "no-cache"); // HTTP 1.0
+ response.setDateHeader("Expires", 0); // Proxies
+ }
+
+ // Render
+ PrintWriter pw = new PrintWriter(response.getOutputStream());
+ pw.write("<!DOCTYPE html><html><body><form action=\"" + finalLocation + "\" method=\"POST\">");
+ writeFormElements(request, pw);
+ writePrologueScript(pw);
+ pw.write("</html>");
+ pw.flush();
+ }
+
+ @Override
+ public void execute(ActionInvocation invocation) throws Exception {
+ String postbackUri = makePostbackUri(invocation);
+ setLocation(postbackUri);
+ super.execute(invocation);
+ }
+
+ /**
+ * Determines if the specified form input element should be included.
+ *
+ * @param name the input element name
+ * @param values the input element values
+ * @return {@code true} if included; otherwise {@code false}
+ */
+ protected boolean isElementIncluded(String name, String[] values) {
+ return !name.startsWith("action:");
+ }
+
+ protected String makePostbackUri(ActionInvocation invocation) {
+ ActionContext ctx = invocation.getInvocationContext();
+ HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+ String postbackUri;
+
+ if (actionName != null) {
+ actionName = conditionalParse(actionName, invocation);
+ if (namespace == null) {
+ namespace = invocation.getProxy().getNamespace();
+ } else {
+ namespace = conditionalParse(namespace, invocation);
+ }
+ if (method == null) {
+ method = "";
+ } else {
+ method = conditionalParse(method, invocation);
+ }
+ postbackUri = request.getContextPath() + actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
+ } else {
+ String location = getLocation();
+ // Do not prepend if the URL is a FQN
+ if (!location.matches("^([a-zA-z]+:)?//.*")) {
+ // If the URL is relative to the servlet context, prepend the servlet context path
+ if (prependServletContext && (request.getContextPath() != null) && (request.getContextPath().length() > 0)) {
+ location = request.getContextPath() + location;
+ }
+ }
+ postbackUri = location;
+ }
+
+ return postbackUri;
+ }
+
+ @Inject
+ public final void setActionMapper(ActionMapper mapper) {
+ this.actionMapper = mapper;
+ }
+
+ /**
+ * Sets the name of the destination action.
+ *
+ * @param actionName the action name
+ */
+ public final void setActionName(String actionName) {
+ this.actionName = actionName;
+ }
+
+ /**
+ * Stores the option to cache the rendered intermediate page. The default
+ * is {@code true}.
+ *
+ * @return {@code true} to cache; otherwise {@code false}
+ */
+ public final void setCache(boolean cache) {
+ this.cache = cache;
+ }
+
+ /**
+ * Sets the method of the destination action.
+ *
+ * @param method the method
+ */
+ public final void setMethod(String method) {
+ this.method = method;
+ }
+
+ /**
+ * Sets the namespace of the destination action.
+ *
+ * @param namespace the namespace
+ */
+ public final void setNamespace(String namespace) {
+ this.namespace = namespace;
+ }
+
+ public final void setPrependServletContext(boolean prependServletContext) {
+ this.prependServletContext = prependServletContext;
+ }
+
+ protected void writeFormElement(PrintWriter pw, String name, String[] values) throws UnsupportedEncodingException {
+ for (String value : values) {
+ String encName = URLEncoder.encode(name, "UTF-8");
+ String encValue = URLEncoder.encode(value, "UTF-8");
+ pw.write("<input type=\"hidden\" name=\"" + encName + "\" value=\"" + encValue + "\"/>");
+ }
+ }
+
+ private void writeFormElements(HttpServletRequest request, PrintWriter pw) throws UnsupportedEncodingException {
+ Map<String, String[]> params = request.getParameterMap();
+ for (String name : params.keySet()) {
+ String[] values = params.get(name);
+ if (isElementIncluded(name, values)) {
+ writeFormElement(pw, name, values);
+ }
+ }
+ }
+
+ /**
+ * Outputs the script after the form has been emitted. The default script
+ * is to submit the form using a JavaScript time out that immediately expires.
+ *
+ * @param pw the print writer
+ */
+ protected void writePrologueScript(PrintWriter pw) {
+ pw.write("<script>");
+ pw.write("setTimeout(function(){document.forms[0].submit();},0);");
+ pw.write("</script>");
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java b/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
new file mode 100644
index 0000000..2d12606
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletActionRedirectResult.java
@@ -0,0 +1,227 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.util.reflection.ReflectionExceptionHandler;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * This result uses the {@link ActionMapper} provided by the
+ * {@link ActionMapperFactory} to redirect the browser to a URL that invokes the
+ * specified action and (optional) namespace. This is better than the
+ * {@link ServletRedirectResult} because it does not require you to encode the
+ * URL patterns processed by the {@link ActionMapper} in to your struts.xml
+ * configuration files. This means you can change your URL patterns at any point
+ * and your application will still work. It is strongly recommended that if you
+ * are redirecting to another action, you use this result rather than the
+ * standard redirect result.
+ *
+ * See examples below for an example of how request parameters could be passed
+ * in.
+ *
+ * <!-- END SNIPPET: description -->
+ *
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>actionName (default)</b> - The name of the action that will be
+ * redirected to.</li>
+ *
+ * <li><b>namespace</b> - Used to determine which namespace the action is in
+ * that we're redirecting to. If namespace is null, the default will be the
+ * current namespace.</li>
+ *
+ * <li><b>suppressEmptyParameters</b> - Optional boolean (defaults to false) that
+ * can prevent parameters with no values from being included in the redirect
+ * URL.</li>
+ *
+ * <li><b>parse</b> - Boolean, true by default. If set to false, the actionName
+ * param will not be parsed for Ognl expressions.</li>
+ *
+ * <li><b>anchor</b> - Optional. Also known as "fragment" or colloquially as
+ * "hash". You can specify an anchor for a result.</li>
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * <package name="public" extends="struts-default">
+ * <action name="login" class="...">
+ * <!-- Redirect to another namespace -->
+ * <result type="redirectAction">
+ * <param name="actionName">dashboard</param>
+ * <param name="namespace">/secure</param>
+ * </result>
+ * </action>
+ * </package>
+ *
+ * <package name="secure" extends="struts-default" namespace="/secure">
+ * <-- Redirect to an action in the same namespace -->
+ * <action name="dashboard" class="...">
+ * <result>dashboard.jsp</result>
+ * <result name="error" type="redirectAction">error</result>
+ * </action>
+ *
+ * <action name="error" class="...">
+ * <result>error.jsp</result>
+ * </action>
+ * </package>
+ *
+ * <package name="passingRequestParameters" extends="struts-default" namespace="/passingRequestParameters">
+ * <!-- Pass parameters (reportType, width and height) -->
+ * <!--
+ * The redirectAction url generated will be :
+ * /genReport/generateReport.action?reportType=pie&width=100&height=100#summary
+ * -->
+ * <action name="gatherReportInfo" class="...">
+ * <result name="showReportResult" type="redirectAction">
+ * <param name="actionName">generateReport</param>
+ * <param name="namespace">/genReport</param>
+ * <param name="reportType">pie</param>
+ * <param name="width">100</param>
+ * <param name="height">100</param>
+ * <param name="empty"></param>
+ * <param name="suppressEmptyParameters">true</param>
+ * <param name="anchor">summary</param>
+ * </result>
+ * </action>
+ * </package>
+ *
+ *
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ *
+ * @see ActionMapper
+ */
+public class ServletActionRedirectResult extends ServletRedirectResult implements ReflectionExceptionHandler {
+
+ private static final long serialVersionUID = -9042425229314584066L;
+
+ /* The default parameter */
+ public static final String DEFAULT_PARAM = "actionName";
+
+ protected String actionName;
+ protected String namespace;
+ protected String method;
+
+ public ServletActionRedirectResult() {
+ super();
+ }
+
+ public ServletActionRedirectResult(String actionName) {
+ this(null, actionName, null, null);
+ }
+
+ public ServletActionRedirectResult(String actionName, String method) {
+ this(null, actionName, method, null);
+ }
+
+ public ServletActionRedirectResult(String namespace, String actionName, String method) {
+ this(namespace, actionName, method, null);
+ }
+
+ public ServletActionRedirectResult(String namespace, String actionName, String method, String anchor) {
+ super(null, anchor);
+ this.namespace = namespace;
+ this.actionName = actionName;
+ this.method = method;
+ }
+
+ /**
+ * @see com.opensymphony.xwork2.Result#execute(com.opensymphony.xwork2.ActionInvocation)
+ */
+ public void execute(ActionInvocation invocation) throws Exception {
+ actionName = conditionalParse(actionName, invocation);
+ if (namespace == null) {
+ namespace = invocation.getProxy().getNamespace();
+ } else {
+ namespace = conditionalParse(namespace, invocation);
+ }
+ if (method == null) {
+ method = "";
+ } else {
+ method = conditionalParse(method, invocation);
+ }
+
+ String tmpLocation = actionMapper.getUriFromActionMapping(new ActionMapping(actionName, namespace, method, null));
+
+ setLocation(tmpLocation);
+
+ super.execute(invocation);
+ }
+
+ /**
+ * Sets the action name
+ *
+ * @param actionName The name
+ */
+ public void setActionName(String actionName) {
+ this.actionName = actionName;
+ }
+
+ /**
+ * Sets the namespace
+ *
+ * @param namespace The namespace
+ */
+ public void setNamespace(String namespace) {
+ this.namespace = namespace;
+ }
+
+ /**
+ * Sets the method
+ *
+ * @param method The method
+ */
+ public void setMethod(String method) {
+ this.method = method;
+ }
+
+ protected List<String> getProhibitedResultParams() {
+ return Arrays.asList(
+ DEFAULT_PARAM,
+ "namespace",
+ "method",
+ "encode",
+ "parse",
+ "location",
+ "prependServletContext",
+ "suppressEmptyParameters",
+ "anchor",
+ "statusCode"
+ );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java b/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
new file mode 100644
index 0000000..8d20e99
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletDispatcherResult.java
@@ -0,0 +1,174 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.StrutsStatics;
+import org.apache.struts2.views.util.UrlHelper;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.jsp.PageContext;
+import java.util.Map;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * Includes or forwards to a view (usually a jsp). Behind the scenes Struts
+ * will use a RequestDispatcher, where the target servlet/JSP receives the same
+ * request/response objects as the original servlet/JSP. Therefore, you can pass
+ * data between them using request.setAttribute() - the Struts action is
+ * available.
+ * <p/>
+ * There are three possible ways the result can be executed:
+ *
+ * <ul>
+ *
+ * <li>If we are in the scope of a JSP (a PageContext is available), PageContext's
+ * {@link PageContext#include(String) include} method is called.</li>
+ *
+ * <li>If there is no PageContext and we're not in any sort of include (there is no
+ * "javax.servlet.include.servlet_path" in the request attributes), then a call to
+ * {@link RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse) forward}
+ * is made.</li>
+ *
+ * <li>Otherwise, {@link RequestDispatcher#include(javax.servlet.ServletRequest, javax.servlet.ServletResponse) include}
+ * is called.</li>
+ *
+ * </ul>
+ * <!-- END SNIPPET: description -->
+ *
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>location (default)</b> - the location to go to after execution (ex. jsp).</li>
+ *
+ * <li><b>parse</b> - true by default. If set to false, the location param will not be parsed for Ognl expressions.</li>
+ *
+ * </ul>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * <result name="success" type="dispatcher">
+ * <param name="location">foo.jsp</param>
+ * </result>
+ * <!-- END SNIPPET: example --></pre>
+ *
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ *
+ * @see javax.servlet.RequestDispatcher
+ */
+public class ServletDispatcherResult extends StrutsResultSupport {
+
+ private static final long serialVersionUID = -1970659272360685627L;
+
+ private static final Logger LOG = LogManager.getLogger(ServletDispatcherResult.class);
+
+ private UrlHelper urlHelper;
+
+ public ServletDispatcherResult() {
+ super();
+ }
+
+ public ServletDispatcherResult(String location) {
+ super(location);
+ }
+
+ @Inject
+ public void setUrlHelper(UrlHelper urlHelper) {
+ this.urlHelper = urlHelper;
+ }
+
+ /**
+ * Dispatches to the given location. Does its forward via a RequestDispatcher. If the
+ * dispatch fails a 404 error will be sent back in the http response.
+ *
+ * @param finalLocation the location to dispatch to.
+ * @param invocation the execution state of the action
+ * @throws Exception if an error occurs. If the dispatch fails the error will go back via the
+ * HTTP request.
+ */
+ public void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+ LOG.debug("Forwarding to location: {}", finalLocation);
+
+ PageContext pageContext = ServletActionContext.getPageContext();
+
+ if (pageContext != null) {
+ pageContext.include(finalLocation);
+ } else {
+ HttpServletRequest request = ServletActionContext.getRequest();
+ HttpServletResponse response = ServletActionContext.getResponse();
+ RequestDispatcher dispatcher = request.getRequestDispatcher(finalLocation);
+
+ //add parameters passed on the location to #parameters
+ // see WW-2120
+ if (StringUtils.isNotEmpty(finalLocation) && finalLocation.indexOf("?") > 0) {
+ String queryString = finalLocation.substring(finalLocation.indexOf("?") + 1);
+ Map<String, Object> parameters = getParameters(invocation);
+ Map<String, Object> queryParams = urlHelper.parseQueryString(queryString, true);
+ if (queryParams != null && !queryParams.isEmpty())
+ parameters.putAll(queryParams);
+ }
+
+ // if the view doesn't exist, let's do a 404
+ if (dispatcher == null) {
+ response.sendError(404, "result '" + finalLocation + "' not found");
+ return;
+ }
+
+ //if we are inside an action tag, we always need to do an include
+ Boolean insideActionTag = (Boolean) ObjectUtils.defaultIfNull(request.getAttribute(StrutsStatics.STRUTS_ACTION_TAG_INVOCATION), Boolean.FALSE);
+
+ // If we're included, then include the view
+ // Otherwise do forward
+ // This allow the page to, for example, set content type
+ if (!insideActionTag && !response.isCommitted() && (request.getAttribute("javax.servlet.include.servlet_path") == null)) {
+ request.setAttribute("struts.view_uri", finalLocation);
+ request.setAttribute("struts.request_uri", request.getRequestURI());
+
+ dispatcher.forward(request, response);
+ } else {
+ dispatcher.include(request, response);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map<String, Object> getParameters(ActionInvocation invocation) {
+ return (Map<String, Object>) invocation.getInvocationContext().getContextMap().get("parameters");
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java b/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
new file mode 100644
index 0000000..c3fe70b
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/ServletRedirectResult.java
@@ -0,0 +1,323 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.config.entities.ResultConfig;
+import com.opensymphony.xwork2.inject.Inject;
+import com.opensymphony.xwork2.util.reflection.ReflectionException;
+import com.opensymphony.xwork2.util.reflection.ReflectionExceptionHandler;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.dispatcher.Dispatcher;
+import org.apache.struts2.dispatcher.mapper.ActionMapper;
+import org.apache.struts2.dispatcher.mapper.ActionMapping;
+import org.apache.struts2.views.util.UrlHelper;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.util.*;
+
+import static javax.servlet.http.HttpServletResponse.SC_FOUND;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * Calls the {@link HttpServletResponse#sendRedirect(String) sendRedirect}
+ * method to the location specified. The response is told to redirect the
+ * browser to the specified location (a new request from the client). The
+ * consequence of doing this means that the action (action instance, action
+ * errors, field errors, etc) that was just executed is lost and no longer
+ * available. This is because actions are built on a single-thread model. The
+ * only way to pass data is through the session or with web parameters
+ * (url?name=value) which can be OGNL expressions.
+ *
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>location (default)</b> - the location to go to after execution.</li>
+ *
+ * <li><b>parse</b> - true by default. If set to false, the location param will
+ * not be parsed for Ognl expressions.</li>
+ *
+ * <li><b>anchor</b> - Optional. Also known as "fragment" or colloquially as
+ * "hash". You can specify an anchor for a result.</li>
+ * </ul>
+ *
+ * <p>
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ * </p>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre>
+ * <!-- START SNIPPET: example -->
+ * <!--
+ * The redirect URL generated will be:
+ * /foo.jsp#FRAGMENT
+ * -->
+ * <result name="success" type="redirect">
+ * <param name="location">foo.jsp</param>
+ * <param name="parse">false</param>
+ * <param name="anchor">FRAGMENT</param>
+ * </result>
+ * <!-- END SNIPPET: example -->
+ * </pre>
+ *
+ */
+public class ServletRedirectResult extends StrutsResultSupport implements ReflectionExceptionHandler {
+
+ private static final long serialVersionUID = 6316947346435301270L;
+
+ private static final Logger LOG = LogManager.getLogger(ServletRedirectResult.class);
+
+ protected boolean prependServletContext = true;
+ protected ActionMapper actionMapper;
+ protected int statusCode = SC_FOUND;
+ protected boolean suppressEmptyParameters = false;
+ protected Map<String, Object> requestParameters = new LinkedHashMap<>();
+ protected String anchor;
+
+ private UrlHelper urlHelper;
+
+ public ServletRedirectResult() {
+ super();
+ }
+
+ public ServletRedirectResult(String location) {
+ this(location, null);
+ }
+
+ public ServletRedirectResult(String location, String anchor) {
+ super(location);
+ this.anchor = anchor;
+ }
+
+ @Inject
+ public void setActionMapper(ActionMapper mapper) {
+ this.actionMapper = mapper;
+ }
+
+ @Inject
+ public void setUrlHelper(UrlHelper urlHelper) {
+ this.urlHelper = urlHelper;
+ }
+
+ public void setStatusCode(int code) {
+ this.statusCode = code;
+ }
+
+ /**
+ * Set the optional anchor value.
+ *
+ * @param anchor
+ */
+ public void setAnchor(String anchor) {
+ this.anchor = anchor;
+ }
+
+ /**
+ * Sets whether or not to prepend the servlet context path to the redirected
+ * URL.
+ *
+ * @param prependServletContext <tt>true</tt> to prepend the location with the servlet context path, <tt>false</tt> otherwise.
+ */
+ public void setPrependServletContext(boolean prependServletContext) {
+ this.prependServletContext = prependServletContext;
+ }
+
+ public void execute(ActionInvocation invocation) throws Exception {
+ if (anchor != null) {
+ anchor = conditionalParse(anchor, invocation);
+ }
+ super.execute(invocation);
+ }
+
+ /**
+ * Redirects to the location specified by calling
+ * {@link HttpServletResponse#sendRedirect(String)}.
+ *
+ * @param finalLocation the location to redirect to.
+ * @param invocation an encapsulation of the action execution state.
+ * @throws Exception if an error occurs when redirecting.
+ */
+ protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+ ActionContext ctx = invocation.getInvocationContext();
+ HttpServletRequest request = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
+ HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);
+
+ if (isPathUrl(finalLocation)) {
+ if (!finalLocation.startsWith("/")) {
+ ActionMapping mapping = actionMapper.getMapping(request, Dispatcher.getInstance().getConfigurationManager());
+ String namespace = null;
+ if (mapping != null) {
+ namespace = mapping.getNamespace();
+ }
+
+ if ((namespace != null) && (namespace.length() > 0) && (!"/".equals(namespace))) {
+ finalLocation = namespace + "/" + finalLocation;
+ } else {
+ finalLocation = "/" + finalLocation;
+ }
+ }
+
+ // if the URL's are relative to the servlet context, append the servlet context path
+ if (prependServletContext && (request.getContextPath() != null) && (request.getContextPath().length() > 0)) {
+ finalLocation = request.getContextPath() + finalLocation;
+ }
+ }
+ ResultConfig resultConfig = invocation.getProxy().getConfig().getResults().get(invocation.getResultCode());
+ if (resultConfig != null) {
+ Map<String, String> resultConfigParams = resultConfig.getParams();
+
+ List<String> prohibitedResultParams = getProhibitedResultParams();
+ for (Map.Entry<String, String> e : resultConfigParams.entrySet()) {
+ if (!prohibitedResultParams.contains(e.getKey())) {
+ Collection<String> values = conditionalParseCollection(e.getValue(), invocation, suppressEmptyParameters);
+ if (!suppressEmptyParameters || !values.isEmpty()) {
+ requestParameters.put(e.getKey(), values);
+ }
+ }
+ }
+ }
+
+ StringBuilder tmpLocation = new StringBuilder(finalLocation);
+ urlHelper.buildParametersString(requestParameters, tmpLocation, "&");
+
+ // add the anchor
+ if (anchor != null) {
+ tmpLocation.append('#').append(anchor);
+ }
+
+ finalLocation = response.encodeRedirectURL(tmpLocation.toString());
+
+ LOG.debug("Redirecting to finalLocation: {}", finalLocation);
+
+ sendRedirect(response, finalLocation);
+ }
+
+ protected List<String> getProhibitedResultParams() {
+ return Arrays.asList(
+ DEFAULT_PARAM,
+ "namespace",
+ "method",
+ "encode",
+ "parse",
+ "location",
+ "prependServletContext",
+ "suppressEmptyParameters",
+ "anchor",
+ "statusCode"
+ );
+ }
+
+ /**
+ * Sends the redirection. Can be overridden to customize how the redirect is
+ * handled (i.e. to use a different status code)
+ *
+ * @param response The response
+ * @param finalLocation The location URI
+ * @throws IOException
+ */
+ protected void sendRedirect(HttpServletResponse response, String finalLocation) throws IOException {
+ if (SC_FOUND == statusCode) {
+ response.sendRedirect(finalLocation);
+ } else {
+ response.setStatus(statusCode);
+ response.setHeader("Location", finalLocation);
+ response.getWriter().write(finalLocation);
+ response.getWriter().close();
+ }
+
+ }
+
+ /**
+ * Checks if url is simple path or either full url
+ *
+ * @param url string
+ * @return true if it's just a path not a full url
+ */
+ protected boolean isPathUrl(String url) {
+ try {
+ String rawUrl = url;
+ if (url.contains("?")) {
+ rawUrl = url.substring(0, url.indexOf("?"));
+ }
+ URI uri = URI.create(rawUrl.replaceAll(" ", "%20"));
+ if (uri.isAbsolute()) {
+ URL validUrl = uri.toURL();
+ LOG.debug("[{}] is full url, not a path", url);
+ return validUrl.getProtocol() == null;
+ } else {
+ LOG.debug("[{}] isn't absolute URI, assuming it's a path", url);
+ return true;
+ }
+ } catch (IllegalArgumentException e) {
+ LOG.debug("[{}] isn't a valid URL, assuming it's a path", url, e);
+ return true;
+ } catch (MalformedURLException e) {
+ LOG.debug("[{}] isn't a valid URL, assuming it's a path", url, e);
+ return true;
+ }
+ }
+
+ /**
+ * Sets the suppressEmptyParameters option
+ *
+ * @param suppressEmptyParameters The new value for this option
+ */
+ public void setSuppressEmptyParameters(boolean suppressEmptyParameters) {
+ this.suppressEmptyParameters = suppressEmptyParameters;
+ }
+
+ /**
+ * Adds a request parameter to be added to the redirect url
+ *
+ * @param key The parameter name
+ * @param value The parameter value
+ */
+ public ServletRedirectResult addParameter(String key, Object value) {
+ requestParameters.put(key, String.valueOf(value));
+ return this;
+ }
+
+ public void handle(ReflectionException ex) {
+ // Only log as debug as they are probably parameters to be appended to the url
+ if (LOG.isDebugEnabled()) {
+ LOG.debug(ex.getMessage(), ex);
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/StreamResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/StreamResult.java b/core/src/main/java/org/apache/struts2/result/StreamResult.java
new file mode 100644
index 0000000..5574cc1
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/StreamResult.java
@@ -0,0 +1,329 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * A custom Result type for sending raw data (via an InputStream) directly to the
+ * HttpServletResponse. Very useful for allowing users to download content.
+ *
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>contentType</b> - the stream mime-type as sent to the web browser
+ * (default = <code>text/plain</code>).</li>
+ *
+ * <li><b>contentLength</b> - the stream length in bytes (the browser displays a
+ * progress bar).</li>
+ *
+ * <li><b>contentDisposition</b> - the content disposition header value for
+ * specifing the file name (default = <code>inline</code>, values are typically
+ * <i>attachment;filename="document.pdf"</i>.</li>
+ *
+ * <li><b>inputName</b> - the name of the InputStream property from the chained
+ * action (default = <code>inputStream</code>).</li>
+ *
+ * <li><b>bufferSize</b> - the size of the buffer to copy from input to output
+ * (default = <code>1024</code>).</li>
+ *
+ * <li><b>allowCaching</b> if set to 'false' it will set the headers 'Pragma' and 'Cache-Control'
+ * to 'no-cahce', and prevent client from caching the content. (default = <code>true</code>)
+ *
+ * <li><b>contentCharSet</b> if set to a string, ';charset=value' will be added to the
+ * content-type header, where value is the string set. If set to an expression, the result
+ * of evaluating the expression will be used. If not set, then no charset will be set on
+ * the header</li>
+ * </ul>
+ *
+ * <p>These parameters can also be set by exposing a similarly named getter method on your Action. For example, you can
+ * provide <code>getContentType()</code> to override that parameter for the current action.</p>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * <result name="success" type="stream">
+ * <param name="contentType">image/jpeg</param>
+ * <param name="inputName">imageStream</param>
+ * <param name="contentDisposition">attachment;filename="document.pdf"</param>
+ * <param name="bufferSize">1024</param>
+ * </result>
+ * <!-- END SNIPPET: example --></pre>
+ *
+ */
+public class StreamResult extends StrutsResultSupport {
+
+ private static final long serialVersionUID = -1468409635999059850L;
+
+ protected static final Logger LOG = LogManager.getLogger(StreamResult.class);
+
+ public static final String DEFAULT_PARAM = "inputName";
+
+ protected String contentType = "text/plain";
+ protected String contentLength;
+ protected String contentDisposition = "inline";
+ protected String contentCharSet ;
+ protected String inputName = "inputStream";
+ protected InputStream inputStream;
+ protected int bufferSize = 1024;
+ protected boolean allowCaching = true;
+
+ public StreamResult() {
+ super();
+ }
+
+ public StreamResult(InputStream in) {
+ this.inputStream = in;
+ }
+
+ /**
+ * @return Returns the whether or not the client should be requested to allow caching of the data stream.
+ */
+ public boolean getAllowCaching() {
+ return allowCaching;
+ }
+
+ /**
+ * Set allowCaching to <tt>false</tt> to indicate that the client should be requested not to cache the data stream.
+ * This is set to <tt>false</tt> by default
+ *
+ * @param allowCaching Enable caching.
+ */
+ public void setAllowCaching(boolean allowCaching) {
+ this.allowCaching = allowCaching;
+ }
+
+
+ /**
+ * @return Returns the bufferSize.
+ */
+ public int getBufferSize() {
+ return (bufferSize);
+ }
+
+ /**
+ * @param bufferSize The bufferSize to set.
+ */
+ public void setBufferSize(int bufferSize) {
+ this.bufferSize = bufferSize;
+ }
+
+ /**
+ * @return Returns the contentType.
+ */
+ public String getContentType() {
+ return (contentType);
+ }
+
+ /**
+ * @param contentType The contentType to set.
+ */
+ public void setContentType(String contentType) {
+ this.contentType = contentType;
+ }
+
+ /**
+ * @return Returns the contentLength.
+ */
+ public String getContentLength() {
+ return contentLength;
+ }
+
+ /**
+ * @param contentLength The contentLength to set.
+ */
+ public void setContentLength(String contentLength) {
+ this.contentLength = contentLength;
+ }
+
+ /**
+ * @return Returns the Content-disposition header value.
+ */
+ public String getContentDisposition() {
+ return contentDisposition;
+ }
+
+ /**
+ * @param contentDisposition the Content-disposition header value to use.
+ */
+ public void setContentDisposition(String contentDisposition) {
+ this.contentDisposition = contentDisposition;
+ }
+
+ /**
+ * @return Returns the charset specified by the user
+ */
+ public String getContentCharSet() {
+ return contentCharSet;
+ }
+
+ /**
+ * @param contentCharSet the charset to use on the header when sending the stream
+ */
+ public void setContentCharSet(String contentCharSet) {
+ this.contentCharSet = contentCharSet;
+ }
+
+ /**
+ * @return Returns the inputName.
+ */
+ public String getInputName() {
+ return (inputName);
+ }
+
+ /**
+ * @param inputName The inputName to set.
+ */
+ public void setInputName(String inputName) {
+ this.inputName = inputName;
+ }
+
+ /**
+ * @see StrutsResultSupport#doExecute(java.lang.String, com.opensymphony.xwork2.ActionInvocation)
+ */
+ protected void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+
+ // Override any parameters using values on the stack
+ resolveParamsFromStack(invocation.getStack(), invocation);
+
+ // Find the Response in context
+ HttpServletResponse oResponse = (HttpServletResponse) invocation.getInvocationContext().get(HTTP_RESPONSE);
+ try (OutputStream oOutput = oResponse.getOutputStream()) {
+ if (inputStream == null) {
+ // Find the inputstream from the invocation variable stack
+ inputStream = (InputStream) invocation.getStack().findValue(conditionalParse(inputName, invocation));
+ }
+
+ if (inputStream == null) {
+ String msg = ("Can not find a java.io.InputStream with the name [" + inputName + "] in the invocation stack. " +
+ "Check the <param name=\"inputName\"> tag specified for this action.");
+ LOG.error(msg);
+ throw new IllegalArgumentException(msg);
+ }
+
+ // Set the content type
+ if (contentCharSet != null && ! contentCharSet.equals("")) {
+ oResponse.setContentType(conditionalParse(contentType, invocation)+";charset="+contentCharSet);
+ }
+ else {
+ oResponse.setContentType(conditionalParse(contentType, invocation));
+ }
+
+ // Set the content length
+ if (contentLength != null) {
+ String _contentLength = conditionalParse(contentLength, invocation);
+ int _contentLengthAsInt = -1;
+ try {
+ _contentLengthAsInt = Integer.parseInt(_contentLength);
+ if (_contentLengthAsInt >= 0) {
+ oResponse.setContentLength(_contentLengthAsInt);
+ }
+ }
+ catch(NumberFormatException e) {
+ LOG.warn("failed to recognize {} as a number, contentLength header will not be set", _contentLength, e);
+ }
+ }
+
+ // Set the content-disposition
+ if (contentDisposition != null) {
+ oResponse.addHeader("Content-Disposition", conditionalParse(contentDisposition, invocation));
+ }
+
+ // Set the cache control headers if neccessary
+ if (!allowCaching) {
+ oResponse.addHeader("Pragma", "no-cache");
+ oResponse.addHeader("Cache-Control", "no-cache");
+ }
+
+ LOG.debug("Streaming result [{}] type=[{}] length=[{}] content-disposition=[{}] charset=[{}]",
+ inputName, contentType, contentLength, contentDisposition, contentCharSet);
+
+ // Copy input to output
+ LOG.debug("Streaming to output buffer +++ START +++");
+ byte[] oBuff = new byte[bufferSize];
+ int iSize;
+ while (-1 != (iSize = inputStream.read(oBuff))) {
+ oOutput.write(oBuff, 0, iSize);
+ }
+ LOG.debug("Streaming to output buffer +++ END +++");
+
+ // Flush
+ oOutput.flush();
+ }
+ }
+
+ /**
+ * Tries to lookup the parameters on the stack. Will override any existing parameters
+ *
+ * @param stack The current value stack
+ */
+ protected void resolveParamsFromStack(ValueStack stack, ActionInvocation invocation) {
+ String disposition = stack.findString("contentDisposition");
+ if (disposition != null) {
+ setContentDisposition(disposition);
+ }
+
+ String contentType = stack.findString("contentType");
+ if (contentType != null) {
+ setContentType(contentType);
+ }
+
+ String inputName = stack.findString("inputName");
+ if (inputName != null) {
+ setInputName(inputName);
+ }
+
+ String contentLength = stack.findString("contentLength");
+ if (contentLength != null) {
+ setContentLength(contentLength);
+ }
+
+ Integer bufferSize = (Integer) stack.findValue("bufferSize", Integer.class);
+ if (bufferSize != null) {
+ setBufferSize(bufferSize);
+ }
+
+ if (contentCharSet != null ) {
+ contentCharSet = conditionalParse(contentCharSet, invocation);
+ }
+ else {
+ contentCharSet = stack.findString("contentCharSet");
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java b/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
new file mode 100644
index 0000000..bdb1b93
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/StrutsResultSupport.java
@@ -0,0 +1,266 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.Result;
+import com.opensymphony.xwork2.util.TextParseUtil;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.StrutsStatics;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collection;
+
+
+/**
+ * <!-- START SNIPPET: javadoc -->
+ *
+ * A base class for all Struts action execution results.
+ * The "location" param is the default parameter, meaning the most common usage of this result would be:
+ * <p/>
+ * This class provides two common parameters for any subclass:
+ * <ul>
+ * <li>location - the location to go to after execution (could be a jsp page or another action).
+ * It can be parsed as per the rules definied in the
+ * {@link TextParseUtil#translateVariables(java.lang.String, com.opensymphony.xwork2.util.ValueStack) translateVariables}
+ * method</li>
+ * <li>parse - true by default. If set to false, the location param will not be parsed for expressions</li>
+ * <li>encode - false by default. If set to false, the location param will not be url encoded. This only have effect when parse is true</li>
+ * </ul>
+ *
+ * <b>NOTE:</b>
+ * The encode param will only have effect when parse is true
+ *
+ * <!-- END SNIPPET: javadoc -->
+ *
+ * <p/>
+ *
+ * <!-- START SNIPPET: example -->
+ *
+ * <p/>
+ * In the struts.xml configuration file, these would be included as:
+ * <p/>
+ * <pre>
+ * <result name="success" type="redirect">
+ * <param name="<b>location</b>">foo.jsp</param>
+ * </result></pre>
+ * <p/>
+ * or
+ * <p/>
+ * <pre>
+ * <result name="success" type="redirect" >
+ * <param name="<b>location</b>">foo.jsp?url=${myUrl}</param>
+ * <param name="<b>parse</b>">true</param>
+ * <param name="<b>encode</b>">true</param>
+ * </result></pre>
+ * <p/>
+ * In the above case, myUrl will be parsed against Ognl Value Stack and then
+ * URL encoded.
+ * <p/>
+ * or when using the default parameter feature
+ * <p/>
+ * <pre>
+ * <result name="success" type="redirect"><b>foo.jsp</b></result></pre>
+ * <p/>
+ * You should subclass this class if you're interested in adding more parameters or functionality
+ * to your Result. If you do subclass this class you will need to
+ * override {@link #doExecute(String, ActionInvocation)}.<p>
+ * <p/>
+ * Any custom result can be defined in struts.xml as:
+ * <p/>
+ * <pre>
+ * <result-types>
+ * ...
+ * <result-type name="myresult" class="com.foo.MyResult" />
+ * </result-types></pre>
+ * <p/>
+ * Please see the {@link com.opensymphony.xwork2.Result} class for more info on Results in general.
+ *
+ * <!-- END SNIPPET: example -->
+ *
+ * @see com.opensymphony.xwork2.Result
+ */
+public abstract class StrutsResultSupport implements Result, StrutsStatics {
+
+ private static final Logger LOG = LogManager.getLogger(StrutsResultSupport.class);
+
+ /** The default parameter */
+ public static final String DEFAULT_PARAM = "location";
+
+ /** use UTF-8 as this is the recommended encoding by W3C to avoid incompatibilities. */
+ public static final String DEFAULT_URL_ENCODING = "UTF-8";
+
+ private boolean parse;
+ private boolean encode;
+ private String location;
+ private String lastFinalLocation;
+
+ public StrutsResultSupport() {
+ this(null, true, false);
+ }
+
+ public StrutsResultSupport(String location) {
+ this(location, true, false);
+ }
+
+ public StrutsResultSupport(String location, boolean parse, boolean encode) {
+ this.location = location;
+ this.parse = parse;
+ this.encode = encode;
+ }
+
+ /**
+ * The location to go to after action execution. This could be a JSP page or another action.
+ * The location can contain OGNL expressions which will be evaulated if the <tt>parse</tt>
+ * parameter is set to <tt>true</tt>.
+ *
+ * @param location the location to go to after action execution.
+ * @see #setParse(boolean)
+ */
+ public void setLocation(String location) {
+ this.location = location;
+ }
+
+ /**
+ * Gets the location it was created with, mainly for testing
+ */
+ public String getLocation() {
+ return location;
+ }
+
+ /**
+ * Returns the last parsed and encoded location value
+ */
+ public String getLastFinalLocation() {
+ return lastFinalLocation;
+ }
+
+ /**
+ * Set parse to <tt>true</tt> to indicate that the location should be parsed as an OGNL expression. This
+ * is set to <tt>true</tt> by default.
+ *
+ * @param parse <tt>true</tt> if the location parameter is an OGNL expression, <tt>false</tt> otherwise.
+ */
+ public void setParse(boolean parse) {
+ this.parse = parse;
+ }
+
+ /**
+ * Set encode to <tt>true</tt> to indicate that the location should be url encoded. This is set to
+ * <tt>true</tt> by default
+ *
+ * @param encode <tt>true</tt> if the location parameter should be url encode, <tt>false</tt> otherwise.
+ */
+ public void setEncode(boolean encode) {
+ this.encode = encode;
+ }
+
+ /**
+ * Implementation of the <tt>execute</tt> method from the <tt>Result</tt> interface. This will call
+ * the abstract method {@link #doExecute(String, ActionInvocation)} after optionally evaluating the
+ * location as an OGNL evaluation.
+ *
+ * @param invocation the execution state of the action.
+ * @throws Exception if an error occurs while executing the result.
+ */
+ public void execute(ActionInvocation invocation) throws Exception {
+ lastFinalLocation = conditionalParse(location, invocation);
+ doExecute(lastFinalLocation, invocation);
+ }
+
+ /**
+ * Parses the parameter for OGNL expressions against the valuestack
+ *
+ * @param param The parameter value
+ * @param invocation The action invocation instance
+ * @return The resulting string
+ */
+ protected String conditionalParse(String param, ActionInvocation invocation) {
+ if (parse && param != null && invocation != null) {
+ return TextParseUtil.translateVariables(
+ param,
+ invocation.getStack(),
+ new EncodingParsedValueEvaluator());
+ } else {
+ return param;
+ }
+ }
+
+ /**
+ * As {@link #conditionalParse(String, ActionInvocation)} but does not
+ * convert found object into String. If found object is a collection it is
+ * returned if found object is not a collection it is wrapped in one.
+ *
+ * @param param
+ * @param invocation
+ * @param excludeEmptyElements
+ * @return
+ */
+ protected Collection<String> conditionalParseCollection(String param, ActionInvocation invocation, boolean excludeEmptyElements) {
+ if (parse && param != null && invocation != null) {
+ return TextParseUtil.translateVariablesCollection(
+ param,
+ invocation.getStack(),
+ excludeEmptyElements,
+ new EncodingParsedValueEvaluator());
+ } else {
+ Collection<String> collection = new ArrayList<>(1);
+ collection.add(param);
+ return collection;
+ }
+ }
+
+ /**
+ * {@link com.opensymphony.xwork2.util.TextParseUtil.ParsedValueEvaluator} to do URL encoding for found values. To be
+ * used for single strings or collections.
+ *
+ */
+ private final class EncodingParsedValueEvaluator implements TextParseUtil.ParsedValueEvaluator {
+ public Object evaluate(String parsedValue) {
+ if (encode) {
+ if (parsedValue != null) {
+ try {
+ return URLEncoder.encode(parsedValue, DEFAULT_URL_ENCODING);
+ }
+ catch(UnsupportedEncodingException e) {
+ LOG.warn("error while trying to encode [{}]", parsedValue, e);
+ }
+ }
+ }
+ return parsedValue;
+ }
+ }
+
+ /**
+ * Executes the result given a final location (jsp page, action, etc) and the action invocation
+ * (the state in which the action was executed). Subclasses must implement this class to handle
+ * custom logic for result handling.
+ *
+ * @param finalLocation the location (jsp page, action, etc) to go to.
+ * @param invocation the execution state of the action.
+ * @throws Exception if an error occurs while executing the result.
+ */
+ protected abstract void doExecute(String finalLocation, ActionInvocation invocation) throws Exception;
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/result/VelocityResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/result/VelocityResult.java b/core/src/main/java/org/apache/struts2/result/VelocityResult.java
new file mode 100644
index 0000000..810d191
--- /dev/null
+++ b/core/src/main/java/org/apache/struts2/result/VelocityResult.java
@@ -0,0 +1,233 @@
+/*
+ * $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.struts2.result;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.inject.Inject;
+import com.opensymphony.xwork2.util.ValueStack;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.struts2.ServletActionContext;
+import org.apache.struts2.StrutsConstants;
+import org.apache.struts2.views.JspSupportServlet;
+import org.apache.struts2.views.velocity.VelocityManager;
+import org.apache.velocity.Template;
+import org.apache.velocity.app.VelocityEngine;
+import org.apache.velocity.context.Context;
+
+import javax.servlet.Servlet;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.jsp.JspFactory;
+import javax.servlet.jsp.PageContext;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+
+/**
+ * <!-- START SNIPPET: description -->
+ *
+ * Using the Servlet container's {@link JspFactory}, this result mocks a JSP
+ * execution environment and then displays a Velocity template that will be
+ * streamed directly to the servlet output.
+ *
+ * <!-- END SNIPPET: description -->
+ * <p/>
+ * <b>This result type takes the following parameters:</b>
+ *
+ * <!-- START SNIPPET: params -->
+ *
+ * <ul>
+ *
+ * <li><b>location (default)</b> - the location of the template to process.</li>
+ *
+ * <li><b>parse</b> - true by default. If set to false, the location param will
+ * not be parsed for Ognl expressions.</li>
+ *
+ * </ul>
+ * <p>
+ * This result follows the same rules from {@link StrutsResultSupport}.
+ * </p>
+ *
+ * <!-- END SNIPPET: params -->
+ *
+ * <b>Example:</b>
+ *
+ * <pre><!-- START SNIPPET: example -->
+ * <result name="success" type="velocity">
+ * <param name="location">foo.vm</param>
+ * </result>
+ * <!-- END SNIPPET: example --></pre>
+ *
+ */
+public class VelocityResult extends StrutsResultSupport {
+
+ private static final long serialVersionUID = 7268830767762559424L;
+
+ private static final Logger LOG = LogManager.getLogger(VelocityResult.class);
+
+ private String defaultEncoding;
+ private VelocityManager velocityManager;
+ private JspFactory jspFactory = JspFactory.getDefaultFactory();
+
+ public VelocityResult() {
+ super();
+ }
+
+ public VelocityResult(String location) {
+ super(location);
+ }
+
+ @Inject(StrutsConstants.STRUTS_I18N_ENCODING)
+ public void setDefaultEncoding(String val) {
+ defaultEncoding = val;
+ }
+
+ @Inject
+ public void setVelocityManager(VelocityManager mgr) {
+ this.velocityManager = mgr;
+ }
+
+ /**
+ * Creates a Velocity context from the action, loads a Velocity template and executes the
+ * template. Output is written to the servlet output stream.
+ *
+ * @param finalLocation the location of the Velocity template
+ * @param invocation an encapsulation of the action execution state.
+ * @throws Exception if an error occurs when creating the Velocity context, loading or executing
+ * the template or writing output to the servlet response stream.
+ */
+ public void doExecute(String finalLocation, ActionInvocation invocation) throws Exception {
+ ValueStack stack = ActionContext.getContext().getValueStack();
+
+ HttpServletRequest request = ServletActionContext.getRequest();
+ HttpServletResponse response = ServletActionContext.getResponse();
+ ServletContext servletContext = ServletActionContext.getServletContext();
+ Servlet servlet = JspSupportServlet.jspSupportServlet;
+
+ velocityManager.init(servletContext);
+
+ boolean usedJspFactory = false;
+ PageContext pageContext = (PageContext) ActionContext.getContext().get(ServletActionContext.PAGE_CONTEXT);
+
+ if (pageContext == null && servlet != null) {
+ pageContext = jspFactory.getPageContext(servlet, request, response, null, true, 8192, true);
+ ActionContext.getContext().put(ServletActionContext.PAGE_CONTEXT, pageContext);
+ usedJspFactory = true;
+ }
+
+ try {
+ String encoding = getEncoding(finalLocation);
+ String contentType = getContentType(finalLocation);
+
+ if (encoding != null) {
+ contentType = contentType + ";charset=" + encoding;
+ }
+
+ Template t = getTemplate(stack, velocityManager.getVelocityEngine(), invocation, finalLocation, encoding);
+
+ Context context = createContext(velocityManager, stack, request, response, finalLocation);
+ Writer writer = new OutputStreamWriter(response.getOutputStream(), encoding);
+
+
+ response.setContentType(contentType);
+
+ t.merge(context, writer);
+
+ // always flush the writer (we used to only flush it if this was a jspWriter, but someone asked
+ // to do it all the time (WW-829). Since Velocity support is being deprecated, we'll oblige :)
+ writer.flush();
+ } catch (Exception e) {
+ LOG.error("Unable to render velocity template: '{}'", finalLocation, e);
+ throw e;
+ } finally {
+ if (usedJspFactory) {
+ jspFactory.releasePageContext(pageContext);
+ }
+ }
+ }
+
+ /**
+ * Retrieve the content type for this template.
+ * <p/>
+ * People can override this method if they want to provide specific content types for specific templates (eg text/xml).
+ *
+ * @return The content type associated with this template (default "text/html")
+ */
+ protected String getContentType(String templateLocation) {
+ return "text/html";
+ }
+
+ /**
+ * Retrieve the encoding for this template.
+ * <p/>
+ * People can override this method if they want to provide specific encodings for specific templates.
+ *
+ * @return The encoding associated with this template (defaults to the value of 'struts.i18n.encoding' property)
+ */
+ protected String getEncoding(String templateLocation) {
+ String encoding = defaultEncoding;
+ if (encoding == null) {
+ encoding = System.getProperty("file.encoding");
+ }
+ if (encoding == null) {
+ encoding = "UTF-8";
+ }
+ return encoding;
+ }
+
+ /**
+ * Given a value stack, a Velocity engine, and an action invocation, this method returns the appropriate
+ * Velocity template to render.
+ *
+ * @param stack the value stack to resolve the location again (when parse equals true)
+ * @param velocity the velocity engine to process the request against
+ * @param invocation an encapsulation of the action execution state.
+ * @param location the location of the template
+ * @param encoding the charset encoding of the template
+ * @return the template to render
+ * @throws Exception when the requested template could not be found
+ */
+ protected Template getTemplate(ValueStack stack, VelocityEngine velocity, ActionInvocation invocation, String location, String encoding) throws Exception {
+ if (!location.startsWith("/")) {
+ location = invocation.getProxy().getNamespace() + "/" + location;
+ }
+
+ Template template = velocity.getTemplate(location, encoding);
+
+ return template;
+ }
+
+ /**
+ * Creates the VelocityContext that we'll use to render this page.
+ *
+ * @param velocityManager a reference to the velocityManager to use
+ * @param stack the value stack to resolve the location against (when parse equals true)
+ * @param location the name of the template that is being used
+ * @return the a minted Velocity context.
+ */
+ protected Context createContext(VelocityManager velocityManager, ValueStack stack, HttpServletRequest request, HttpServletResponse response, String location) {
+ return velocityManager.createContext(stack, request, response);
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java b/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
index e5258e6..0775f55 100644
--- a/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
+++ b/core/src/main/java/org/apache/struts2/views/freemarker/FreemarkerResult.java
@@ -38,7 +38,7 @@ import freemarker.template.TemplateModelException;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.StrutsStatics;
-import org.apache.struts2.dispatcher.StrutsResultSupport;
+import org.apache.struts2.result.StrutsResultSupport;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/main/resources/struts-default.xml
----------------------------------------------------------------------
diff --git a/core/src/main/resources/struts-default.xml b/core/src/main/resources/struts-default.xml
index 5b82fe0..33057cb 100644
--- a/core/src/main/resources/struts-default.xml
+++ b/core/src/main/resources/struts-default.xml
@@ -168,16 +168,16 @@
<package name="struts-default" abstract="true">
<result-types>
<result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
- <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>
+ <result-type name="dispatcher" class="org.apache.struts2.result.ServletDispatcherResult" default="true"/>
<result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>
- <result-type name="httpheader" class="org.apache.struts2.dispatcher.HttpHeaderResult"/>
- <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
- <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>
- <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>
- <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>
+ <result-type name="httpheader" class="org.apache.struts2.result.HttpHeaderResult"/>
+ <result-type name="redirect" class="org.apache.struts2.result.ServletRedirectResult"/>
+ <result-type name="redirectAction" class="org.apache.struts2.result.ServletActionRedirectResult"/>
+ <result-type name="stream" class="org.apache.struts2.result.StreamResult"/>
+ <result-type name="velocity" class="org.apache.struts2.result.VelocityResult"/>
<result-type name="xslt" class="org.apache.struts2.views.xslt.XSLTResult"/>
- <result-type name="plainText" class="org.apache.struts2.dispatcher.PlainTextResult" />
- <result-type name="postback" class="org.apache.struts2.dispatcher.PostbackResult" />
+ <result-type name="plainText" class="org.apache.struts2.result.PlainTextResult" />
+ <result-type name="postback" class="org.apache.struts2.result.PostbackResult" />
</result-types>
<interceptors>
http://git-wip-us.apache.org/repos/asf/struts/blob/6bc99ab9/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java b/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
index 1806573..aee8473 100644
--- a/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
+++ b/core/src/test/java/org/apache/struts2/TestConfigurationProvider.java
@@ -39,7 +39,7 @@ import com.opensymphony.xwork2.security.DefaultExcludedPatternsChecker;
import com.opensymphony.xwork2.security.ExcludedPatternsChecker;
import com.opensymphony.xwork2.util.location.LocatableProperties;
import com.opensymphony.xwork2.validator.ValidationInterceptor;
-import org.apache.struts2.dispatcher.ServletDispatcherResult;
+import org.apache.struts2.result.ServletDispatcherResult;
import org.apache.struts2.interceptor.TokenInterceptor;
import org.apache.struts2.interceptor.TokenSessionStoreInterceptor;
import org.apache.struts2.views.jsp.ui.DoubleValidationAction;