`
cppmayi
  • 浏览: 25793 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Struts2学习笔记4

freemarkerJSPvelocityApacheHibernate 
阅读更多

Struts2将Result列为一个独立的层次，可以说是整个Struts2的Action层架构设计中的另外一个精华所在。Result之所以成为一个层次，其实是为了解决MVC框架中，如何从Control层转向View层这样一个问题而存在的。所以，接下来我们详细讨论一下Result的方方面面。

Result的职责

Result作为一个独立的层次存在，必然有其存在的价值，它也必须完成它所在的层次的职责。Result是为了解决如何从Control层转向View层这样一个问题而存在的，那么Result最大的职责，就是架起Action到View的桥梁。具体来说，我把这些职责大概分成以下几个方面：

封装跳转逻辑

Result的首要职责，是封装Action层到View层的跳转逻辑。之前我们已经反复提到，Struts2的Action是一个与Web容器无关的POJO。所以，在Action执行完毕之后，框架需要把代码的执行权重新交还给Web容器，并转向到相应的页面或者其他类型的View层。
而这个跳转逻辑，就由Result来完成。这样，好处也是显而易见的，对Action屏蔽任何Web容器的相关信息，使得每个层次更加清晰。

View层的显示类型非常多，有最常见的JSP、当下非常流行的Freemarker/Velocity模板、Redirect到一个新的地址、文本流、图片流、甚至是JSON对象等等。所以Result层的独立存在，就能够对这些显示类型进行区分，并封装合理的跳转逻辑。

以JSP转向为例，在Struts2自带的ServletDispatcherResult中就存在着核心的JSP跳转逻辑：

Java代码 复制代码
  1. HttpServletRequest request = ServletActionContext.getRequest();   
  2. RequestDispatcher dispatcher = request.getRequestDispatcher(finalLocation);   
  3.   
  4. ....   
  5.   
  6. dispatcher.forward(request, response);  
HttpServletRequest request = ServletActionContext.getRequest();
RequestDispatcher dispatcher = request.getRequestDispatcher(finalLocation);

....

dispatcher.forward(request, response);



再以Redirect重定向为例，在Struts2自带的ServletRedirectResult中，也同样存在着重定向的核心代码：

Java代码 复制代码
  1. HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);   
  2.   
  3. ....   
  4.   
  5. response.sendRedirect(finalLocation);  
HttpServletResponse response = (HttpServletResponse) ctx.get(ServletActionContext.HTTP_RESPONSE);

....

response.sendRedirect(finalLocation);



由此可见，绝大多数的Result，都封装了与Web容器相关的跳转逻辑，由于这些逻辑往往需要和Servlet对象打交道，所以，遵循Struts2的基本原则，将它作为一个独立的层次，从而将Action从Web容器中解放出来。

准备显示数据

之前提到，View层的展现方式很多，除了传统的JSP以外，还有类似Freemarker/Velocity这样的模板。根据模板显示的基本原理，需要将预先定义好的模板（Template）和需要展示的数据（Model）组织起来，交给模板引擎，才能够正确显示。而这部分工作，就由Result层来完成。

以Struts2自带的FreemarkerResult为例，在Result中，就存在着为模板准备数据的逻辑代码：

Java代码 复制代码
  1. protected TemplateModel createModel() throws TemplateModelException {   
  2.     ServletContext servletContext = ServletActionContext.getServletContext();   
  3.     HttpServletRequest request = ServletActionContext.getRequest();   
  4.     HttpServletResponse response = ServletActionContext.getResponse();   
  5.     ValueStack stack = ServletActionContext.getContext().getValueStack();   
  6.   
  7.     Object action = null;   
  8.     if(invocation!= null ) action = invocation.getAction(); //Added for NullPointException   
  9.     return freemarkerManager.buildTemplateModel(stack, action, servletContext, request, response, wrapper);   
  10. }  
protected TemplateModel createModel() throws TemplateModelException {
    ServletContext servletContext = ServletActionContext.getServletContext();
    HttpServletRequest request = ServletActionContext.getRequest();
    HttpServletResponse response = ServletActionContext.getResponse();
    ValueStack stack = ServletActionContext.getContext().getValueStack();

    Object action = null;
    if(invocation!= null ) action = invocation.getAction(); //Added for NullPointException
    return freemarkerManager.buildTemplateModel(stack, action, servletContext, request, response, wrapper);
}



有兴趣的读者可以顺着思路去看源码，看看这些Result到底是如何获取各种对象的值的。

控制输出行为

有的时候，针对同一种类型的View展示，我们可能会有不同的输出行为。具体来说，可能有时候，我们需要对输出流指定特定的BufferSize、Encoding等等。Result层，作为一个独立的层次，可以提供极大的扩展性，从而保证我们能够定义自己期望的输出类型。

以Struts2自带的HttpHeaderResult为例：

Java代码 复制代码
  1. public void execute(ActionInvocation invocation) throws Exception {   
  2.     HttpServletResponse response = ServletActionContext.getResponse();   
  3.   
  4.     if (status != -1) {   
  5.         response.setStatus(status);   
  6.     }   
  7.   
  8.     if (headers != null) {   
  9.         ValueStack stack = ActionContext.getContext().getValueStack();   
  10.   
  11.         for (Iterator iterator = headers.entrySet().iterator();   
  12.              iterator.hasNext();) {   
  13.             Map.Entry entry = (Map.Entry) iterator.next();   
  14.             String value = (String) entry.getValue();   
  15.             String finalValue = parse ? TextParseUtil.translateVariables(value, stack) : value;   
  16.             response.addHeader((String) entry.getKey(), finalValue);   
  17.         }   
  18.     }   
  19. }  
public void execute(ActionInvocation invocation) throws Exception {
    HttpServletResponse response = ServletActionContext.getResponse();

    if (status != -1) {
        response.setStatus(status);
    }

    if (headers != null) {
        ValueStack stack = ActionContext.getContext().getValueStack();

        for (Iterator iterator = headers.entrySet().iterator();
             iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String value = (String) entry.getValue();
            String finalValue = parse ? TextParseUtil.translateVariables(value, stack) : value;
            response.addHeader((String) entry.getKey(), finalValue);
        }
    }
}



我们可以在这里添加我们自定义的内容到HttpHeader中去，从而控制Http的输出。

Result的定义

让我们来看看Result的接口定义：

Java代码 复制代码
  1. public interface Result extends Serializable {   
  2.   
  3.     /**  
  4.      * Represents a generic interface for all action execution results, whether that be displaying a webpage, generating  
  5.      * an email, sending a JMS message, etc.  
  6.      */  
  7.     public void execute(ActionInvocation invocation) throws Exception;   
  8. }  
public interface Result extends Serializable {

    /**
     * Represents a generic interface for all action execution results, whether that be displaying a webpage, generating
     * an email, sending a JMS message, etc.
     */
    public void execute(ActionInvocation invocation) throws Exception;
}



这个接口定义非常简单，通过传入ActionInvocation，执行一段逻辑。我们来看看Struts2针对这个接口实现的一个抽象类，它规定了许多默认实现：

Java代码 复制代码
  1. public abstract class StrutsResultSupport implements Result, StrutsStatics {   
  2.   
  3.     private static final Log _log = LogFactory.getLog(StrutsResultSupport.class);   
  4.   
  5.     /** The default parameter */  
  6.     public static final String DEFAULT_PARAM = "location";   
  7.   
  8.     private boolean parse;   
  9.     private boolean encode;   
  10.     private String location;   
  11.     private String lastFinalLocation;   
  12.   
  13.     public StrutsResultSupport() {   
  14.         this(null, true, false);   
  15.     }   
  16.   
  17.     public StrutsResultSupport(String location) {   
  18.         this(location, true, false);   
  19.     }   
  20.   
  21.     public StrutsResultSupport(String location, boolean parse, boolean encode) {   
  22.         this.location = location;   
  23.         this.parse = parse;   
  24.         this.encode = encode;   
  25.     }   
  26.   
  27.     // setter method 省略   
  28.     
  29.     /**  
  30.      * Implementation of the <tt>execute</tt> method from the <tt>Result</tt> interface. This will call  
  31.      * the abstract method {@link #doExecute(String, ActionInvocation)} after optionally evaluating the  
  32.      * location as an OGNL evaluation.  
  33.      *  
  34.      * @param invocation the execution state of the action.  
  35.      * @throws Exception if an error occurs while executing the result.  
  36.      */  
  37.     public void execute(ActionInvocation invocation) throws Exception {   
  38.         lastFinalLocation = conditionalParse(location, invocation);   
  39.         doExecute(lastFinalLocation, invocation);   
  40.     }   
  41.   
  42.     /**  
  43.      * Parses the parameter for OGNL expressions against the valuestack  
  44.      *  
  45.      * @param param The parameter value  
  46.      * @param invocation The action invocation instance  
  47.      * @return The resulting string  
  48.      */  
  49.     protected String conditionalParse(String param, ActionInvocation invocation) {   
  50.         if (parse && param != null && invocation != null) {   
  51.             return TextParseUtil.translateVariables(param, invocation.getStack(),   
  52.                     new TextParseUtil.ParsedValueEvaluator() {   
  53.                         public Object evaluate(Object parsedValue) {   
  54.                             if (encode) {   
  55.                                 if (parsedValue != null) {   
  56.                                     try {   
  57.                                         // use UTF-8 as this is the recommended encoding by W3C to   
  58.                                         // avoid incompatibilities.   
  59.                                         return URLEncoder.encode(parsedValue.toString(), "UTF-8");   
  60.                                     }   
  61.                                     catch(UnsupportedEncodingException e) {   
  62.                                         _log.warn("error while trying to encode ["+parsedValue+"]", e);   
  63.                                     }   
  64.                                 }   
  65.                             }   
  66.                             return parsedValue;   
  67.                         }   
  68.             });   
  69.         } else {   
  70.             return param;   
  71.         }   
  72.     }   
  73.   
  74.     /**  
  75.      * Executes the result given a final location (jsp page, action, etc) and the action invocation  
  76.      * (the state in which the action was executed). Subclasses must implement this class to handle  
  77.      * custom logic for result handling.  
  78.      *  
  79.      * @param finalLocation the location (jsp page, action, etc) to go to.  
  80.      * @param invocation    the execution state of the action.  
  81.      * @throws Exception if an error occurs while executing the result.  
  82.      */  
  83.     protected abstract void doExecute(String finalLocation, ActionInvocation invocation) throws Exception;   
  84. }  
public abstract class StrutsResultSupport implements Result, StrutsStatics {

    private static final Log _log = LogFactory.getLog(StrutsResultSupport.class);

    /** The default parameter */
    public static final String DEFAULT_PARAM = "location";

    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;
    }

    // setter method 省略
 
    /**
     * 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 TextParseUtil.ParsedValueEvaluator() {
                        public Object evaluate(Object parsedValue) {
                            if (encode) {
                                if (parsedValue != null) {
                                    try {
                                        // use UTF-8 as this is the recommended encoding by W3C to
                                        // avoid incompatibilities.
                                        return URLEncoder.encode(parsedValue.toString(), "UTF-8");
                                    }
                                    catch(UnsupportedEncodingException e) {
                                        _log.warn("error while trying to encode ["+parsedValue+"]", e);
                                    }
                                }
                            }
                            return parsedValue;
                        }
            });
        } else {
            return param;
        }
    }

    /**
     * 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;
}



很显然，这个默认实现是为那些类似JSP，Freemarker或者Redirect这样的页面跳转的Result而准备的一个基类，它规定了Result将要跳转到的具体页面的位置、是否需要解析参数，等等。

如果我们试图编写自定义的Result，我们可以实现Result接口，并在struts.xml中进行声明：

Java代码 复制代码
  1. public class CustomerResult implements Result {   
  2.   
  3.     public void execute(ActionInvocation invocation) throws Exception {   
  4.     // write your code here   
  5. }   
  6. }  
public class CustomerResult implements Result {

    public void execute(ActionInvocation invocation) throws Exception {
    // write your code here
}
}


Xml代码 复制代码
  1. <result-type name="customerResult" class="com.javaeye.struts2.CustomerResult"/>  
<result-type name="customerResult" class="com.javaeye.struts2.CustomerResult"/>



常用的Result

接下来，大致介绍一下Struts2内部已经实现的Result，并看看他们是如何工作的。

dispatcher

Xml代码 复制代码
  1. <result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>  
<result-type name="dispatcher" class="org.apache.struts2.dispatcher.ServletDispatcherResult" default="true"/>



dispatcher主要用于返回JSP，HTML等以页面为基础View视图，这个也是Struts2默认的Result类型。

在使用dispatcher时，唯一需要指定的，是JSP或者HTML页面的位置，这个位置将被用于定位返回的页面：

Xml代码 复制代码
  1. <result name="success">/index.jsp</result>  
<result name="success">/index.jsp</result>



而Struts2本身也没有对dispatcher做出什么特殊的处理，只是简单的使用Servlet API进行forward。

freemarker / velocity

Xml代码 复制代码
  1. <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>  
  2. <result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>   
<result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult"/>
<result-type name="velocity" class="org.apache.struts2.dispatcher.VelocityResult"/>



随着模板技术的越来越流行，使用Freemarker或者Velocity模板进行View层展示的开发者越来越多。Struts2同样为模板作为Result做出了支持。由于模板的显示需要模板（Template）与数据（Model）的紧密配合，所以在Struts2中，这两个Result的主要工作是为模板准备数据。

以Freemarker为例，我们来看看它是如何为模板准备数据的：

Java代码 复制代码
  1. public void doExecute(String location, ActionInvocation invocation) throws IOException, TemplateException {   
  2.     this.location = location;   
  3.     this.invocation = invocation;   
  4.     this.configuration = getConfiguration();   
  5.     this.wrapper = getObjectWrapper();   
  6.   
  7.     // 获取模板的位置   
  8.     if (!location.startsWith("/")) {   
  9.         ActionContext ctx = invocation.getInvocationContext();   
  10.         HttpServletRequest req = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);   
  11.         String base = ResourceUtil.getResourceBase(req);   
  12.         location = base + "/" + location;   
  13.     }   
  14.   
  15.     // 得到模板   
  16.     Template template = configuration.getTemplate(location, deduceLocale());   
  17.     // 为模板准备数据   
  18.     TemplateModel model = createModel();   
  19.   
  20.     // 根据模板和数据进行输出   
  21.     // Give subclasses a chance to hook into preprocessing   
  22.     if (preTemplateProcess(template, model)) {   
  23.         try {   
  24.             // Process the template   
  25.             template.process(model, getWriter());   
  26.         } finally {   
  27.             // Give subclasses a chance to hook into postprocessing   
  28.             postTemplateProcess(template, model);   
  29.         }   
  30.     }   
  31. }  
public void doExecute(String location, ActionInvocation invocation) throws IOException, TemplateException {
    this.location = location;
    this.invocation = invocation;
    this.configuration = getConfiguration();
    this.wrapper = getObjectWrapper();

    // 获取模板的位置
    if (!location.startsWith("/")) {
        ActionContext ctx = invocation.getInvocationContext();
        HttpServletRequest req = (HttpServletRequest) ctx.get(ServletActionContext.HTTP_REQUEST);
        String base = ResourceUtil.getResourceBase(req);
        location = base + "/" + location;
    }

    // 得到模板
    Template template = configuration.getTemplate(location, deduceLocale());
    // 为模板准备数据
    TemplateModel model = createModel();

    // 根据模板和数据进行输出
    // Give subclasses a chance to hook into preprocessing
    if (preTemplateProcess(template, model)) {
        try {
            // Process the template
            template.process(model, getWriter());
        } finally {
            // Give subclasses a chance to hook into postprocessing
            postTemplateProcess(template, model);
        }
    }
}



从源码中，我们可以看到，createModel()方法真正为模板准备需要显示的数据。而之前，我们已经看到过这个方法的源码，这个方法所准备的数据不仅包含ValueStack中的数据，还包含了被封装过的HttpServletRequest，HttpSession等对象的数据。从而使得模板能够以它特定的语法输出这些数据。

Velocity的Result也是类似，有兴趣的读者可以顺着思路继续深究源码。

redirect

Xml代码 复制代码
  1. <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>  
  2. <result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>  
  3. <result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>   
<result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>
<result-type name="redirect" class="org.apache.struts2.dispatcher.ServletRedirectResult"/>
<result-type name="redirectAction" class="org.apache.struts2.dispatcher.ServletActionRedirectResult"/>



如果你在Action执行完毕后，希望执行另一个Action，有2种方式可供选择。一种是forward，另外一种是redirect。有关forward和redirect的区别，这里我就不再展开，这应该属于Java程序员的基本知识。在Struts2中，分别对应这两种方式的Result，就是chain和redirect。

先来谈谈redirect，既然是重定向，那么源地址与目标地址之间是2个不同的HttpServletRequest。所以目标地址将无法通过ValueStack等Struts2的特性来获取源Action中的数据。如果你需要对目标地址传递参数，那么需要在目标地址url或者配置文件中指出：

Xml代码 复制代码
  1. <!--   
  2.    The redirect-action url generated will be :   
  3.    /genReport/generateReport.jsp?reportType=pie&width=100&height=100  
  4.    -->  
  5.    <action name="gatherReportInfo" class="...">  
  6.       <result name="showReportResult" type="redirect">  
  7.          <param name="location">generateReport.jsp</param>  
  8.          <param name="namespace">/genReport</param>  
  9.          <param name="reportType">pie</param>  
  10.          <param name="width">${width}</param>  
  11.          <param name="height">${height}</param>  
  12.       </result>  
  13.    </action>   
<!--
   The redirect-action url generated will be :
   /genReport/generateReport.jsp?reportType=pie&width=100&height=100
   -->
   <action name="gatherReportInfo" class="...">
      <result name="showReportResult" type="redirect">
         <param name="location">generateReport.jsp</param>
         <param name="namespace">/genReport</param>
         <param name="reportType">pie</param>
         <param name="width">${width}</param>
         <param name="height">${height}</param>
      </result>
   </action>



同时，Redirect的Result支持在配置文件中，读取并解析源Action中ValueStack的值，并成为参数传递到Redirect的地址中。上面给出的例子中，width和height就是ValueStack中的值。

chain

Xml代码 复制代码
  1. <result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>  
<result-type name="chain" class="com.opensymphony.xwork2.ActionChainResult"/>



再来谈谈chain，之前提到，chain其实只是在一个action执行完毕之后，forward到另外一个action，所以他们之间是共享HttpServletRequest的。在使用chain作为Result时，往往会配合使用ChainingInterceptor。有关ChainingInterceptor，Struts2的Reference说明了其作用：

Struts2 Reference 写道
If you need to copy the properties from your previous Actions in the chain to the current action, you should apply the ChainingInterceptor. The Interceptor will copy the original parameters from the request, and the ValueStack is passed in to the target Action. The source Action is remembered by the ValueStack, allowing the target Action to access the properties of the preceding Action(s) using the ValueStack, and also makes these properties available to the final result of the chain, such as the JSP or Velocity page.



也就是说，ChainingInterceptor的作用是在Action直接传递数据。事实上，源Action中ValueStack的数据会被做一次Copy，这样，2个Action中的数据都在ValueStack中，使得对于前台来说，通过ValueStack来取数据，是透明而共享的。

chain这个Result有一些常用的使用情景，这点在Struts2的Reference中也有说明：

Struts2 Reference 写道

One common use of Action chaining is to provide lookup lists (like for a dropdown list of states). Since these Actions get put on the ValueStack, their properties will be available in the view. This functionality can also be done using the ActionTag to execute an Action from the display page.



比如说，一张页面中，你可能有许多数据要显示，而某些数据的获取方式可能被很多不同的页面共享（典型来说，“推荐文章”这个小栏目的数据获取，可能会被很多页面所共享）。这种情况下，可以把这部分逻辑抽取到一个独立Action中，并使用chain，将这个Action与主Action串联起来。这样，最后到达页面的时候，页面始终可以得到每个Action中的数据。

不过chain这种Result，是在使用时需要慎重考虑的一种Result：

Struts2 Reference 写道
As a rule, Action Chaining is not recommended. First explore other options, such as the Redirect After Post technique.



而Struts2也做出了理由上的说明：

Struts2 Reference 写道
Experience shows that chaining should be used with care. If chaining is overused, an application can turn into "spaghetti code". Actions should be treated as a Transaction Script, rather than as methods in a Business Facade. Be sure to ask yourself why you need to chain from one Action to another. Is a navigational issue, or could the logic in Action2 be pushed back to a support class or business facade so that Action1 can call it too?

Ideally, Action classes should be as short as possible. All the core logic should be pushed back to a support class or a business facade, so that Actions only call methods. Actions are best used as adapters, rather than as a class where coding logic is defined.



从实战上将，使用chain作为Result也的确存在着上面所说的许多问题，我个人也是非常不推崇滥用这种Result。尤其是，对于使用Spring和Hibernate的朋友来说，如果你开启OpenSessionInView模式，那么Hibernate的session是跟随HttpServletRequest的，所以session在整个action链中共享。这会为我们的编程带来极大的麻烦。因为我们知道Hibernate的session会保留一份一级缓存，在action链中，共享一级缓存无疑会为你的调试工作带来很大的不方便。

所以，谨慎使用chain作为你的Result，应该成为一条最佳实践。

stream

Xml代码 复制代码
  1. <result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>  
<result-type name="stream" class="org.apache.struts2.dispatcher.StreamResult"/>



StreamResult等价于在Servlet中直接输出Stream流。这种Result被经常使用于输出图片、文档等二进制流到客户端。通过使用StreamResult，我们只需要在Action中准备好需要输出的InputStream即可。

Xml代码 复制代码
  1. <result name="success" type="stream">  
  2.   <param name="contentType">image/jpeg</param>  
  3.   <param name="inputName">imageStream</param>  
  4.   <param name="contentDisposition">filename="document.pdf"</param>  
  5.   <param name="bufferSize">1024</param>  
  6. </result>   
<result name="success" type="stream">
  <param name="contentType">image/jpeg</param>
  <param name="inputName">imageStream</param>
  <param name="contentDisposition">filename="document.pdf"</param>
  <param name="bufferSize">1024</param>
</result>



同时，StreamResult支持许多参数，对输出的Stream流进行参数控制。具体每个参数的作用，可以参考：http://struts.apache.org/2.0.14/docs/stream-result.html

其他

Struts2的高度可扩展性保证了许多自定义的Result可以通过插件的形式发布出来。比较著名的有JSONResult，JFreeChartResult等等。有兴趣的读者可以在Struts2的官方网站上找到它们，并选择合适的加入到你的项目中去。

关于Result配置简化的思考

Struts2的Result，解决了“如何从Control层转向View层”的问题。不过看了上面介绍的这些由框架本身实现的Result，我们可以发现Result所涉及到的，基本上还停留在为Control层到View层搭建桥梁。

传统的，我们需要通过配置文件，来指定Action执行完毕之后，到底执行什么样的Result。不过在这样一个到处呼吁简化配置的年代，存在着许多方式，可以省略配置：

1. 使用Annotation

Struts2的一些插件提供了@Result和@Results的Annotation，可以通过Annotation来省略XML配置。具体请参考相关的文档。

2. Codebehind插件

Struts2自带了一个Codebehind插件（Struts2.1以后被合并到了其他的插件中）。Codebehind的基本思想是通过CoC的方式，使用

分享到：
| Struts2学习笔记3
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Struts2学习笔记

    根据给定的文件信息，以下是对Struts2学习笔记中涉及的关键知识点的详细解析： ### Struts2框架概览 #### MVC模式的理解与演进 Struts2是基于MVC（Model-View-Controller）模式设计的一种Java Web开发框架。在MVC...

    struts2学习笔记总结

    本笔记将全面总结Struts2的核心概念、主要功能以及实际开发中的应用。 一、Struts2概述 Struts2是Apache软件基金会下的一个开源项目，它继承了Struts1的优点并解决了其存在的问题，如性能和灵活性。Struts2的核心是...

    struts2学习笔记(完美总结)——转自OPEN经验库

    Struts2是一个强大的Java web应用程序开发框架，它遵循Model-View-Controller (MVC)设计模式，用于构建可维护性和可扩展性高的企业级应用。本文将深入探讨Struts2的核心概念，包括Action、Result、配置文件、OGNL与...

    struts2 学习重点笔记

    ### Struts2 学习重点知识点总结 #### 一、Struts2 概念与架构 **1.1 Struts2 简介** - **定义**：Struts2 是 Apache 组织提供的一个基于 MVC 架构模式的开源 Web 应用框架。 - **核心**：Struts2 的核心其实是 ...

    张龙圣思园struts2学习笔记word

    张龙圣思园的Struts2学习笔记，无疑为Java开发者提供了一份宝贵的参考资料，它可能涵盖了Struts2的基础概念、核心组件、配置方式以及实战技巧。 首先，让我们深入了解Struts2的核心特性。Struts2是MVC（Model-View-...

    struts2学习笔记.doc

    ### Struts2学习笔记知识点概览 #### 一、环境搭建 **1.1 Struts2简介** - **Struts2概述**：Struts2是一个开源的MVC框架，它结合了Struts 1.x、WebWork和其他一些框架的优点。Struts2的主要目标是简化Web应用程序...

    struts2学习笔记（1）

    ### Struts2学习笔记知识点详解 #### 一、Struts2框架的基本引入步骤 ##### 1. 导入Struts2相关Jar包 在引入Struts2框架时，首先需要将Struts2的相关Jar包导入到项目的类路径中。这些Jar包通常包括核心库以及其他...

    struts2学习笔记

    struts2学习笔记struts2学习笔记struts2学习笔记

    struts2学习笔记3数据类型转换

    struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换struts2学习笔记3数据类型转换

    struts2学习笔记黑马程序员

    ### Struts2学习笔记之文件上传与Ajax开发 #### Struts2文件上传 **文件上传简介** 文件上传是Web应用中常见的功能之一，Struts2框架内置了对文件上传的支持，使得开发者能够轻松地实现这一功能。为了确保文件...

    struts2四天的学习笔记

    13. ** strut2四天笔记**：这份学习笔记可能涵盖了以上所有知识点，包括如何创建Action，配置struts.xml，使用OGNL表达式，处理异常，以及实践中的各种技巧和最佳实践。 在四天的学习过程中，你应该通过实践和理解...

    struts2 学习笔记 实战

    Struts2是一个强大的MVC（Model-View-Controller）框架，它在Java Web开发中扮演着重要的角色。本文将深入探讨Struts2的核心概念，包括Namespace、标签、Action以及它们在实际开发中的应用。 一、Namespace ...

    struts2学习笔记(详细文字)

    structs2很详细的学习笔记，structs2的建造，工作原理，例子，逐步讲解，纯文字的

    struts 2 学习笔记

    在Struts2中，学习笔记通常会涵盖以下几个关键概念： 1. **源代码查看和Javadoc**：开发者可以通过查看源代码来理解Struts2的工作原理，而Javadoc则提供了API文档，帮助理解类和方法的功能。 2. **包（Package）和...

Magicbox
Global site tag (gtag.js) - Google Analytics