struts2之拦截器栈paramsPrepareParamsStack

 

拦截器栈paramsPrepareParamsStack概述

 

1. 拦截器栈paramsPrepareParamsStack中三个重点的拦截器params，prepare和modelDriven。

 

params：com.opensymphony.xwork2.interceptor.ParametersInterceptor

prepare：com.opensymphony.xwork2.interceptor.PrepareInterceptor

modelDriven： com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor

 

2. paramsPrepareParamsStack拦截器栈的主流程为：

params->prepare->modelDriven->params

 

此流程为：

第一步params[参数]拦截器把表单数据注入到栈顶的Action对象中；

第二步prepare[准备]拦截器为modelDriven[模型驱动]拦截器准备向ValueStack[值栈]栈顶添加的对象，此对象作为第一步中Action对象的属性；

第三部modelDriven[模型驱动]拦截器把prepare[准备]拦截器创建的对象压入ValueStack[值栈]栈顶；

第四部params[参数]拦截器把表单数据注入到栈顶的Action的一个属性对象中；

 

通过以上的流程，Struts2可以简洁轻便并且高性能的完成业务的增删改查操作。

 

拦截器栈paramsPrepareParamsStack使用

 

下面，通过一个员工管理的案例来深入了解该拦截器栈的使用：

 

本案例通过四个版本不断优化，最终成为一个相对完美的解决方案。案例的处理难点是表单数据的提交与回填。 下面依次说明各个版本的实现方式和存在的缺点。

版本一：

实现方式：表单数据提交是把模型的属性直接添加到Action类中完成，表单回填测试在Action类中把数据写入request对象，在JSP页面中使用s:push标签将数据取出压入值栈完成回填；

存在缺点：Action类中加入模型类的属性以及get和set方法，造成代码大量冗余；

版本二：

实现方式：在版本一的基础上，直接办模型类作为Action类的属性，并把JSP页面中attr改为object.attr；

存在缺点：JSP页面获取数据代码不简洁，原来id变成employee.id；

版本三：

实现方式：使用拦截器栈paramsPrepareParamsStack,由系统自动把数据添加到值栈栈顶，从而简洁的完成数据映射；

存在缺点：执行每次请求到EmployeeAction执行view,add,edit,delete,create,update任意一个方法时，都会执行prepare方法。 其中，view,add,delete是不需要执行prepare方法的。特别是执行delete方法会执行"dao.selectEmployee(id);"代码浪费数据库资源。 view,add方法会产生不需要的对象，浪费内存。

解决办法：要解决资源浪费的问题，就需要程序能够做到在需要资源的时候执行prepare方法。幸运的是，struts2已经为此准备好了。 其解决办法是为每一个action方法提供了一个私人订制的prepare方法。其名称为prepare加原方法名首字符大写。因此，可以在此方法中完成必要的资源准备。 对于不使用的prepare方法，可以在struts.xml中配置使其不再被系统调用。

版本四：

实现方式：在版本三的基础上，禁用通用的prepare方法，使用每个方法自己的prepare方法。

 

拦截器栈paramsPrepareParamsStack详解 

 

ParametersInterceptor拦截器

 

作用：把action请求参数注入到值栈栈顶对象的对应属性中，没有对应属性则忽略。

源码：

 

 

    @Override
    public String doIntercept(ActionInvocation invocation) throws Exception {
        Object action = invocation.getAction();
        if (!(action instanceof NoParameters)) {
            ActionContext ac = invocation.getInvocationContext();
            //1. 获取请求参数
            final Map<String, Object> parameters = retrieveParameters(ac);

            if (LOG.isDebugEnabled()) {
                LOG.debug("Setting params " + getParameterLogMap(parameters));
            }

            if (parameters != null) {
                Map<String, Object> contextMap = ac.getContextMap();
                try {
                    ReflectionContextState.setCreatingNullObjects(contextMap, true);
                    ReflectionContextState.setDenyMethodExecution(contextMap, true);
                    ReflectionContextState.setReportingConversionErrors(contextMap, true);
                    //2. 获取值栈
                    ValueStack stack = ac.getValueStack();
                    //3. 向值栈栈顶对象注入参数
                    setParameters(action, stack, parameters);
                } finally {
                    ReflectionContextState.setCreatingNullObjects(contextMap, false);
                    ReflectionContextState.setDenyMethodExecution(contextMap, false);
                    ReflectionContextState.setReportingConversionErrors(contextMap, false);
                }
            }
        }
        return invocation.invoke();
    }
protected void setParameters(final Object action, ValueStack stack, final Map<String, Object> parameters) {
        Map<String, Object> params;
        Map<String, Object> acceptableParameters;
        if (ordered) {
            params = new TreeMap<String, Object>(getOrderedComparator());
            acceptableParameters = new TreeMap<String, Object>(getOrderedComparator());
            params.putAll(parameters);
        } else {
            params = new TreeMap<String, Object>(parameters);
            acceptableParameters = new TreeMap<String, Object>();
        }
        //3.1 过滤可接受的参数 
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            String name = entry.getKey();
            if (isAcceptableParameter(name, action)) {
                acceptableParameters.put(name, entry.getValue());
            }
        }
        //3.2 基于目前值栈生成一个新的值栈
        ValueStack newStack = valueStackFactory.createValueStack(stack);
        boolean clearableStack = newStack instanceof ClearableValueStack;
        if (clearableStack) {
            //if the stack's context can be cleared, do that to prevent OGNL
            //from having access to objects in the stack, see XW-641
            ((ClearableValueStack)newStack).clearContextValues();
            Map<String, Object> context = newStack.getContext();
            ReflectionContextState.setCreatingNullObjects(context, true);
            ReflectionContextState.setDenyMethodExecution(context, true);
            ReflectionContextState.setReportingConversionErrors(context, true);

            //keep locale from original context
            context.put(ActionContext.LOCALE, stack.getContext().get(ActionContext.LOCALE));
        }

        boolean memberAccessStack = newStack instanceof MemberAccessValueStack;
        if (memberAccessStack) {
            //block or allow access to properties
            //see WW-2761 for more details
            MemberAccessValueStack accessValueStack = (MemberAccessValueStack) newStack;
            accessValueStack.setAcceptProperties(acceptParams);
            accessValueStack.setExcludeProperties(excludeParams);
            if (action instanceof ParameterNameAware)
            accessValueStack.setPropertiesJudge(new PropertiesJudge() {
                public boolean acceptProperty(String propertyName) {
                    return ((ParameterNameAware) action).acceptableParameterName(propertyName);
                }
            });
        }
        //3.3 遍历将每个参数注入值栈栈顶属性中
        for (Map.Entry<String, Object> entry : acceptableParameters.entrySet()) {
            String name = entry.getKey();
            Object value = entry.getValue();
            try {
                //3.4 将参数注入值栈栈顶属性中
                newStack.setParameter(name, value);
            } catch (RuntimeException e) {
                if (devMode) {
                    String developerNotification = LocalizedTextUtil.findText(ParametersInterceptor.class, "devmode.notification", ActionContext.getContext().getLocale(), "Developer Notification:\n{0}", new Object[]{
                             "Unexpected Exception caught setting '" + name + "' on '" + action.getClass() + ": " + e.getMessage()
                    });
                    LOG.error(developerNotification, e);
                    if (action instanceof ValidationAware) {
                        ((ValidationAware) action).addActionMessage(developerNotification);
                    }
                }
            }
        }

        if (clearableStack && (stack.getContext() != null) && (newStack.getContext() != null))
            stack.getContext().put(ActionContext.CONVERSION_ERRORS, newStack.getContext().get(ActionContext.CONVERSION_ERRORS));

        addParametersToContext(ActionContext.getContext(), acceptableParameters);
    }

 

 

PrepareInterceptor拦截器

 

作用：为ModelDrivenInterceptor拦截器准备/创建准备压入值栈栈顶的对象。

源码：

 

 

    @Override
    public String doIntercept(ActionInvocation invocation) throws Exception {
        //1. 获取请求action
        Object action = invocation.getAction();
        //2. 判断请求Action是否实现Preparable接口
        if (action instanceof Preparable) {
            try {
                String[] prefixes;
                //3. 判断先执行目标方法的prepareDoXxx方法还是prepareXxx,这两个方法只执行一个，默认执行prepareXxx方法
                if (firstCallPrepareDo) {
                    prefixes = new String[] {ALT_PREPARE_PREFIX, PREPARE_PREFIX};
                } else {
                    prefixes = new String[] {PREPARE_PREFIX, ALT_PREPARE_PREFIX};
                }
                PrefixMethodInvocationUtil.invokePrefixMethod(invocation, prefixes);
            }
            catch (InvocationTargetException e) {
                /*
                 * The invoked method threw an exception and reflection wrapped it
                 * in an InvocationTargetException.
                 * If possible re-throw the original exception so that normal
                 * exception handling will take place.
                 */
                Throwable cause = e.getCause();
                if (cause instanceof Exception) {
                    throw (Exception) cause;
                } else if(cause instanceof Error) {
                    throw (Error) cause;
                } else {
                    /*
                     * The cause is not an Exception or Error (must be Throwable) so
                     * just re-throw the wrapped exception.
                     */
                    throw e;
                }
            }
            //4. 判断是否执行action类实现的prepare方法，默认执行
            if (alwaysInvokePrepare) {
                ((Preparable) action).prepare();
            }
        }

        return invocation.invoke();
    }

 

 

配置：可以通过以下配置改变此拦截器中和属性的默认值，其他方式可以查阅struts2文档。

 

 

    <package name="employee-manage-v4" extends="struts-default">
    
                <!-- 配置使用 paramsPrepareParamsStack 作为默认的拦截器栈 -->
		<!-- 修改 PrepareInterceptor 拦截器的 alwaysInvokePrepare 属性值为 false,Struts2将不执行Preparable接口的prepare方法 -->
		<interceptors>
		    <interceptor-stack name="rabbitx-paramsPrepareParamsStack">
		        <interceptor-ref name="paramsPrepareParamsStack">
                            <!--使用拦截器在struts.xml中配置的name的值加点号再加属性值的方式设置属性的值-->
		            <param name="prepare.alwaysInvokePrepare">false</param>
		            <param name="prepare.firstCallPrepareDo">true</param>
		        </interceptor-ref>
		    </interceptor-stack>
		</interceptors>
 
		<default-interceptor-ref name="rabbitx-paramsPrepareParamsStack"/>
		
        <action name="employee-v4-*"
                class="org.rabbitx.web.struts2.paramsPrepareParamsStack.action.v4.EmployeeAction"
                method="{1}">
            <result name="{1}">/v4/{1}.jsp</result>
            <result name="success" type="redirectAction">employee-v4-view</result>
        </action>
        
    </package>

 

 

 

ModelDrivenInterceptor拦截器

作用：把PrepareInterceptor拦截器准备好的或其他方式准备好的对象压入值栈栈顶。

源码：

 

 

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        //1. 获取请求Action对象
        Object action = invocation.getAction();
        //2. 判断Action对象是否实现ModelDriven接口
        if (action instanceof ModelDriven) {
            ModelDriven modelDriven = (ModelDriven) action;
            //3. 获取值栈
            ValueStack stack = invocation.getStack();
            //4. 获取Action对象中创建好的对象；
            Object model = modelDriven.getModel();
            if (model !=  null) {
                //5. 把对象压入值栈栈顶
            	stack.push(model);
            }
            if (refreshModelBeforeResult) {
                invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model));
            }
        }
        return invocation.invoke();
    }

 

 

 

拦截器栈paramsPrepareParamsStack执行流程

 

下面以员工管理案例中修改用户信息为例分析拦截器栈paramsPrepareParamsStack的处理流程：

 

<interceptor-stack name="paramsPrepareParamsStack">
                <interceptor-ref name="exception"/>
                <interceptor-ref name="alias"/>
                <interceptor-ref name="i18n"/>
                <interceptor-ref name="checkbox"/>
                <interceptor-ref name="multiselect"/>
                <interceptor-ref name="params">
                    <param name="excludeParams">dojo\..*,^struts\..*,^session\..*,^request\..*,^application\..*,^servlet(Request|Response)\..*,parameters\...*</param>
                </interceptor-ref>
                <interceptor-ref name="servletConfig"/>
                <interceptor-ref name="prepare"/>
                <interceptor-ref name="chain"/>
                <interceptor-ref name="modelDriven"/>
                <interceptor-ref name="fileUpload"/>
                <interceptor-ref name="staticParams"/>
                <interceptor-ref name="actionMappingParams"/>
                <interceptor-ref name="params">
                    <param name="excludeParams">dojo\..*,^struts\..*,^session\..*,^request\..*,^application\..*,^servlet(Request|Response)\..*,parameters\...*</param>
                </interceptor-ref>
                <interceptor-ref name="conversionError"/>
                <interceptor-ref name="validation">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
                <interceptor-ref name="workflow">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
            </interceptor-stack>

  

01) 用户点击编辑按钮发送employee-v4-edit.action?id=10001请求；

02) params拦截器把请求参数id:10001注入到EmployeeAction对象的属性id中；

03) prepare拦截器调用EmployeeAction的edit对应的prepare方法perpareEdit，此方法根据id获取Employee对象并赋值给EmployeeAction的employee属性；

04) modelDriven拦截器把赋值好的employee对象压入值栈栈顶；

05) params拦截器把请求参数id:10001注入到employee对象的id属性中(此步骤无意义)；

06) 拦截器执行完毕；

07) 执行对应action[EmployeeAction]方法edit；

08) 返回edit.jsp，页面根据栈顶对象employee的属性值回填表单；

 

到此，一个完整的paramsPrepareParamsStack拦截器栈执行流程完毕。