BlogJava-kangdy-随笔分类-Structs

(转载)关于paramsPrepareParamsStack

AK47 — Wed, 16 Nov 2011 07:39:00 GMT

原帖地址：

http://hi.baidu.com/%CC%AB%C6%BD%D1%F31986/blog/item/110b13b1384e805e08230259.html

转贴

paramsPrepareParamsStack在Struts 2.0中是一个很奇妙的interceptor stack，以至于很多人疑问为何不将其设置为默认的interceptor stack。paramsPrepareParamsStack主要解决了ModelDriven和Preparable的配合问题，从字面上理解来说，这个stack的拦截器调用的顺序为：首先params，然后prepare，接下来modelDriven，最后再params。Struts 2.0的设计上要求modelDriven在params之前调用，而业务中prepare要负责准备model，准备model又需要参数，这就需要在 prepare之前运行params拦截器设置相关参数，这个也就是创建paramsPrepareParamsStack的原因。流程如下：
   1. params拦截器首先给action中的相关参数赋值，如id
   2. prepare拦截器执行prepare方法，prepare方法中会根据参数，如id，去调用业务逻辑，设置model对象
   3. modelDriven拦截器将model对象压入value stack，这里的model对象就是在prepare中创建的
   4. params拦截器再将参数赋值给model对象
   5. action的业务逻辑执行依据此stack，一个action的代码通常如下：

public class UserAction extends ActionSupport implements ModelDriven, Preparable {
   private User user;
   private int id;
   private UserService service; // user business service

   public void setId(int id) {
       this.id = id;
   }

   /**
   * create a new user if none exists, otherwise load the user with the
   * specified id
   */
   public void prepare() throws Exception {
       if (id == 0) {
           user = new User();
       } else {
           user = service.findUserById(id);
       }
   }

   public Object getModel() {
       return user;
   }

   /**
   * create or update the user and then view the created user
   */
   public String update() {
       if (id == 0) {
           service.create(user);
       } else {
           service.update(user);
       }
       return "redirect";
   }

   /**
   * delete the user and go to a default home page
   */
   public String delete() {
       service.deleteById(id);
       return "home";
   }

   /**
   * show the page allowing the user to view the existing data
   */
   public String view() {
       return "view";
   }

   /**
   * show the page allowing the user to view the existing data and change the
   * values
   */
   public String edit() {
       return "input";
   }

在上述代码中，edit和view都不需要根据id再为界面准备数据，因为prepare方法已经准备好了model，这些方法很简单。对于update 方法，prepare首先会从数据库中加载数据，然后params拦截器会将参数值付给model，在update直接更新就可以，不会出现数据被乱更新的情况。象Hibernate框架，会判断哪些字段更新了，然后进行更新，性能也不会损失。
通过paramsPrepareParamsStack可以让流程更明确，代码更简洁，也更利于大家的交流。

AK47 2011-11-16 15:39 发表评论

(转载) Struts 2杂谈（1）：ValueStack对象的传送带机制

AK47 — Fri, 11 Nov 2011 09:21:00 GMT

Struts 2杂谈（1）：ValueStack对象的传送带机制

作者：nokiaguy 原文地址：http://blog.csdn.net/nokiaguy/article/details/4684750

转贴

   众所周知，Strut 2的Action类通过属性可以获得所有相关的值，如请求参数、Action配置参数、向其他Action传递属性值（通过chain结果）等等。要获得这些参数值，我们要做的唯一一件事就是在Action类中声明与参数同名的属性，在Struts 2调用Action类的Action方法（默认是execute方法）之前，就会为相应的Action属性赋值。
    要完成这个功能，有很大程度上，Struts 2要依赖于ValueStack对象。这个对象贯穿整个Action的生命周期（每个Action类的对象实例会拥有一个ValueStack对象）。当 Struts 2接收到一个.action的请求后，会先建立Action类的对象实例，并且将Action类的对象实例压入ValueStack对象中（实际上，ValueStack对于相当一个栈），而ValueStack类的setValue和findValue方法可以设置和获得Action对象的属性值。Struts 2中的某些拦截器正是通过ValueStack类的setValue方法来修改Action类的属性值的。如params拦截器用于将请求参数值映射到相应成Action类的属性值。在params拦截器中在获得请求参数值后，会使用setValue方法设置相应的Action类的属性。
    从这一点可以看出，ValueStack对象就象一个传送带，当客户端请求.action时，Struts 2在创建相应用Action对象后就将Action对象放到了ValueStack传送带上，然后ValueStack传送带会带着Action对象经过若干拦截器，在每一拦截器中都可以通过ValueStack对象设置和获得Action对象中的属性值。实际上，这些拦截器就相当于流水线作业。如果要对 Action对象进行某项加工，再加一个拦截器即可，当不需要进行这项工作时，直接将该拦截器去掉即可。
    下面我们使用一个例子来演示这个过程。在这个例子中实现了一个拦截器，该拦截器的功能是将一个属性文件中的key-value对映射成相应的属性的值。如下面是一个属性文件的内容：

    name = 超人
    price = 10000

    我们可以在Action类中定义name和price属性，在Action中引用这个拦截器后，就会自动为属性赋值。
    在使用该拦截器有如下规则：
    1. 拦截器读取的属性文件路径由path参数指定。
    2. 属性文件的编码格式由encoding参数指定，默认值是UTF-8。
    3. 如果某个key中包含有“.”（该符号不能出现在标识符中），则有如下处理方法：
    （1）将Action类的属性名定义为去掉“.”的key。例如，key为person.name，而属性名可定义为personname。
    （2）将Action类的属性名定义为将“.”替换成其他字符的表示符号。例如，key为person.name，而属性名可定义为person_name，其中“_”由separator参数指定。
    4. 如果key太长，也可以直接使用Action参数进行映射，例如，key为country.person.name，可做如下映射：
      name
      要注意的是，name属性值不能包含“.”，因此，应将key值中的“.”去掉。现在就可以直接在Action类中定义名为name的属性的，name属性的值会与key值相同。
    5. 上面所有的规则可以同时使用。

拦截器的源代码：

package interceptors;

import java.util.Enumeration;
import java.util.Map;
import java.util.Properties;
import java.io.InputStream;
import java.io.FileInputStream;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.opensymphony.xwork2.util.ValueStack;

public class PropertyInterceptor extends AbstractInterceptor
{
    private static final String DEFAULT_PATH_KEY = "path";
    private static final String DEFAULT_ENCODING_KEY = "encoding";
    private static final String DEFAULT_SEPARATOR_KEY = "separator";

    protected String pathKey = DEFAULT_PATH_KEY;
    protected String encodingKey = DEFAULT_ENCODING_KEY;
    protected String separatorKey = DEFAULT_SEPARATOR_KEY;

    public void setPathKey(String pathKey)
    {
        this.pathKey = pathKey;
    }

    public void setEncodingKey(String encodingKey)
    {
        this.encodingKey = encodingKey;
    }

    public void setSeparatorKey(String separatorKey)
    {
        this.separatorKey = separatorKey;
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception
    {
        ActionConfig config = invocation.getProxy().getConfig();

        Map<String, String> parameters = config.getParams();
        if (parameters.containsKey(pathKey))
        {
            String path = parameters.get(pathKey);
            String encoding = parameters.get(encodingKey);
            String separator = parameters.get(separatorKey);
            if (encoding == null)
                encoding = "UTF-8";
            if (separator == null)
                separator = "";
            path = invocation.getAction().getClass().getResource(path)
                    .getPath();
            Properties properties = new Properties();
            InputStream is = new FileInputStream(path);
            java.io.Reader reader = new java.io.InputStreamReader(is, encoding);

            properties.load(reader);
            ActionContext ac = invocation.getInvocationContext();
            ValueStack stack = ac.getValueStack();
            System.out.println(stack.hashCode());
            Enumeration names = properties.propertyNames();
            while (names.hasMoreElements())
            {
                //  下面会使用setValue方法修改ValueStack对象中的相应属性值
                String name = names.nextElement().toString();
                if (!name.contains("."))
                    stack.setValue(name, properties.get(name));

                String newName = null;
                newName = parameters.get(name.replaceAll("//.", ""));
                if (newName != null)
                    stack.setValue(newName, properties.get(name));

                if (!separator.equals(""))
                {
                    newName = name.replaceAll("//.", "");
                    stack.setValue(newName, properties.get(name));
                }
                newName = name.replaceAll("//.", separator);
                stack.setValue(newName, properties.get(name));
            }
        }
        return invocation.invoke();
    }
}

用于测试的Action类的源代码：

package actions;

public class MyAction
{
    private String name;
    private Integer price;
    private String log4jappenderstdout;
    private String log4j_rootLogger;
    private String conversionPattern;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public Integer getPrice()
    {
        return price;
    }

    public void setPrice(Integer price)
    {
        this.price = price;
    }

    public String getLog4jappenderstdout()
    {
        return log4jappenderstdout;
    }

    public void setLog4jappenderstdout(String log4jappenderstdout)
    {
        this.log4jappenderstdout = log4jappenderstdout;
    }

    public String getLog4j_rootLogger()
    {
        return log4j_rootLogger;
    }

    public void setLog4j_rootLogger(String log4j_rootLogger)
    {
        this.log4j_rootLogger = log4j_rootLogger;
    }

    public String getConversionPattern()
    {
        return conversionPattern;
    }

    public void setConversionPattern(String conversionPattern)
    {
        this.conversionPattern = conversionPattern;
    }

    public String execute()
    {
        System.out.println("name:" + name);
        System.out.println("price:" + price);
        System.out.println("log4jappenderstdout:" + log4jappenderstdout);
        System.out.println("log4j_rootLogger:" + log4j_rootLogger);
        System.out.println("conversionPattern:" + conversionPattern);
        return null;
    }
}

Action类的配置代码如：

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"
    "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
    <package name="struts" extends="struts-default">

        <interceptors>
            <interceptor name="property"
                class="interceptors.PropertyInterceptor" />
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack" />
                <interceptor-ref name="property" />
            interceptor-stack>
        interceptors>
        <action name="test" class="actions.MyAction">
            <interceptor-ref name="myStack" />
            <param name="path">/log4j.propertiesparam>
            <param name="encoding">UTF-8param>
            <param name="separator">_param>
            <param name="log4jappenderstdoutlayoutConversionPattern">
                conversionPattern
            param>

        action>
    package>
struts>

请将log4j.properties文件复制到WEB-INF/classes目录，并在该文件中加入name和price属性。

测试结果：

name:中国
price:34
log4jappenderstdout:org.apache.log4j.ConsoleAppender
log4j_rootLogger:error, stdout
conversionPattern:%d{ABSOLUTE} %5p %c{1}:%L - %m%n

由于property拦截器在defaultStack后引用，因此，在该拦截器中设置的属性值是最终结果，如果将property拦截器放在 defaultStack前面（将两个元素掉换一下），就可以通过同名胜Action配置参数或请求参数来干预最终究输出结果了。

AK47 2011-11-11 17:21 发表评论

(转贴)Struts2数据传输的背后机制：ValueStack（值栈）

AK47 — Fri, 11 Nov 2011 08:19:00 GMT

摘要: （转）Struts2数据传输的背后机制：ValueStack（值栈）原文地址：http://blog.csdn.net/li_tengfei/article/details/6098134转载 1. 数据传输背后机制：ValueStack(值栈) 在这一切的背后，是因为有了ValueStack（值栈）！ Valu... 阅读全文

AK47 2011-11-11 16:19 发表评论

structs2配置UrlRewriteFilter

AK47 — Wed, 09 Nov 2011 09:22:00 GMT

转载每个网页或请求都是一个url地址，一般，这个地址可能是.do,.page,.action之类的并加上'?'号、'&'号查询串等构成的一个长长的的url。很urgly。

一般的url----------------------------------------------------------较好的url
http://www.xxx.net/user/profile.do?id=20001   ====> http://www.xxx.net/user/20001
http://www.xxx.net/forum/board.do?name=java   ====> http://www.xxx.net/forum/java
http://www.xxx.net/forum/thread.do?id=29923   ====> http://www.xxx.net/thread/29923

后者明显较为直观和漂亮。

使用url rewrite可以很好的改善这个状况。网站url rewrite应用是非常广泛的，良好的url设计给用户带来的非常好的体验，同时也能吸引搜索引擎的注意。

原文地址：http://www.iteye.com/topic/53834
使用方式：
1 配置web.xml文件
样例：

org.springframework.web.context.ContextLoaderListener

encodingFilter

org.springframework.web.filter.CharacterEncodingFilter

encoding

UTF-8

encodingFilter

osivFilter

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

org.springframework.web.context.request.RequestContextListener

osivFilter

UrlRewriteFilter

org.tuckey.web.filters.urlrewrite.UrlRewriteFilter

UrlRewriteFilter

*.html

       REQUEST
       FORWARD
       INCLUDE

struts-prepare

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareFilter

actionPackages

com.secneo.action.*.*

struts2

org.apache.struts2.dispatcher.FilterDispatcher

struts-execute

org.apache.struts2.dispatcher.ng.filter.StrutsExecuteFilter

struts-cleanup

org.apache.struts2.dispatcher.ActionContextCleanUp

struts2

*.jsp

struts2

*.action

       REQUEST
       FORWARD
       INCLUDE

struts2

*.tld

struts2

*.tag

struts-prepare

*.jsp

struts-prepare

*.action

struts-prepare

*.tld

struts-execute

*.jsp

struts-execute

*.action

struts-execute

*.tld

struts-cleanup

*.jsp

struts-cleanup

*.action

struts-cleanup

*.tld

org.springframework.web.util.IntrospectorCleanupListener

2 在WEB-INF目录下添加urlrewrite.xml 文件，根据具体需要写规则。
样例：

       ^/(.*).html$
       /$1.action


       ^/(.*).html?(.*)$
       /$1.action?$2

AK47 2011-11-09 17:22 发表评论

structs2 filter的执行顺序

AK47 — Wed, 09 Nov 2011 07:44:00 GMT

根据servlet2.3规范filter执行是按照web.xml配置的filter-mapping先后顺序进行执行。
所以自己配置的过滤器放在structs2的过滤器之前。

AK47 2011-11-09 15:44 发表评论

structs2拦截器

AK47 — Tue, 08 Nov 2011 10:35:00 GMT

深入struct2拦截器 这篇文章很好，细致讲解了structs2和拦截器的原理。

http://zhanghong.iteye.com/blog/452465

转载在每次对你的 Action的 execute()方法请求时，系统会生成一个 ActionInvocation对象，这个对象保存了 action和你所配置的所有的拦截器以及一些状态信息。比如你的应用使用的是 defaultStack，系统将会以拦截器栈配置的顺序将每个拦截器包装成一个个 InterceptorMapping(包含拦截器名字和对应的拦截器对象 )组成一个 Iterator保存在 ActionInvocation中。在执行 ActionInvocation的 invoke()方法时会对这个 Iterator进行迭代，每次取出一个 InterceptorMapping，然后执行对应 Interceptor的 intercept(ActionInVocation inv)方法，而 intercept(ActionInInvocation inv)方法又包含当前的 ActionInInvcation对象作为参数，而在每个拦截器中又会调用 inv的 invoke()方法，这样就会进入下一个拦截器执行了，这样直到最后一个拦截器执行完，然后执行 Action的 execute()方法 (假设你没有配置访问方法，默认执行 Action的 execute()方法 )。在执行完 execute()方法取得了 result后又以相反的顺序走出拦截器栈，这时可以做些清理工作。最后系统得到了一个 result，然后根据 result的类型做进一步操作。

配置拦截器：Struts2中提供了大量的拦截器，多个拦截器可以组成一个拦截器栈，系统配置了一个默认的拦截器栈 defaultStack，具体包括那些拦截器以及顺序可以在struts-default.xml中找到。
1)






         class="tutorial.Login">

     class="tutuorial.Login">

拦截器执行顺序：

执行顺序：
thisWillRunFirstInterceptor
thisWillRunNextInterceptor
    followedByThisInterceptor
      thisWillRunLastInterceptor
        MyAction1
        MyAction2 (chain)
        MyPreResultListener
        MyResult (result)
      thisWillRunLastInterceptor
    followedByThisInterceptor
thisWillRunNextInterceptor
thisWillRunFirstInterceptor

自定义拦截器:必须实现 com.opensymphony.xwork2.interceptor.Interceptor 也可以继承 AbstractInterceptor

拦截器要保证线程安全。因为structs2中拦截器会在请求间共享

AK47 2011-11-08 18:35 发表评论

(转贴)struts2 工作原理图

AK47 — Tue, 08 Nov 2011 07:10:00 GMT

摘要: 原贴地址：http://blog.csdn.net/qjyong/article/details/1795833转贴最近学习struts2，其实它就是webwork2.2的升级版，现附上原理图上图来源于Struts2官方站点，是Struts 2 的整体结构。一个请求在Struts2框架中的处理大概分为以下几个步骤1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求2 ... 阅读全文

AK47 2011-11-08 15:10 发表评论

Structs的线程安全问题

AK47 — Thu, 29 Oct 2009 08:26:00 GMT

以前做过Structs 的项目,可是一直没做太深的研究,尤其是关于线程安全的
在网上搜了一下很多这方面的资料,引用了一些,总结了一下:

总结：Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
Struts2 Action可以使用原型模式scope=prototype,这样对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

这篇文章对什么是线程安全的代码和如何使用线程安全的代码做了详细阐述
http://hi.baidu.com/niujunkai/blog/item/021964adc130660a4a36d6ab.html
下面是它内容的引用:

引用:

1.什么是线程安全的代码
在多线程环境下能正确执行的代码就是线程安全的。
安全的意思是能正确执行，否则后果是程序执行错误，可能出现各种异常情况。

2.如何编写线程安全的代码
很多书籍里都详细讲解了如何这方面的问题，他们主要讲解的是如何同步线程对共享资源的使用的问题。主要是对synchronized关键字的各种用法，以及锁的概念。Java1.5中也提供了如读写锁这类的工具类。这些都需要较高的技巧，而且相对难于调试。

但是，线程同步是不得以的方法,是比较复杂的,而且会带来性能的损失。等效的代码中，不需要同步在编写容易度和性能上会更好些。
我这里强调的是什么代码是始终为线程安全的、是不需要同步的。如下:
1)常量始终是线程安全的，因为只存在读操作。
2)对构造器的访问(new 操作)是线程安全的，因为每次都新建一个实例，不会访问共享的资源。
3)最重要的是:局部变量是线程安全的。因为每执行一个方法，都会在独立的空间创建局部变量，它不是共享的资源。局部变量包括方法的参数变量。
struts user guide里有：
Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables , in your Action class.
译:只使用用局部变量。--编写线程安全的代码最重要的原则就是，在Action类中只使用局部变量，不使用实例变量。

总结：
在Java的Web服务器环境下开发，要注意线程安全的问题。最简单的实现方式就是在Servlet和Struts Action里不要使用类变量、实例变量，但可以使用类常量和实例常量。如果有这些变量，可以将它们转换为方法的参数传入，以消除它们。
注意一个容易混淆的地方：被Servlet或Action调用的类中(如值对象、领域模型类)中是否可以安全的使用实例变量？如果你在每次方法调用时
新建一个对象，再调用它们的方法，则不存在同步问题---因为它们不是多个线程共享的资源，只有共享的资源才需要同步---而Servlet和Action的实例对于多个线程是共享的。
换句话说，Servlet和Action的实例会被多个线程同时调用，而过了这一层,如果在你自己的代码中没有另外启动线程，且每次调用后续业务对象时都是先新建一个实例再调用，则都是线程安全的。

如果想加深理解servlet的多线程可以读读此文，阐述的很详细。
http://hi.baidu.com/platon/blog/item/64a20ff3f96e7fce0b46e031.html

AK47 2009-10-29 16:26 发表评论