从源代码分析modelDriven拦截器和params拦截器和拦截器prepare 和paramsPrepareParamsStack拦截器栈（让你的Struts2代码更简洁——如何培养框架设计能力

源代码文件：Web App Libraries/struts2-core-2.3.15.3.jar/struts-default.xml

拦截器modelDriven：

<interceptor
name="modelDriven"
class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/>

拦截器params：

<interceptor
name="params"
class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>

拦截器prepare：

<interceptor
name="prepare"
class="com.opensymphony.xwork2.interceptor.PrepareInterceptor"/>

拦截器栈：

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

ModelDriven拦截器的作用：

当用户触发每一个请求时，ModelDriven拦截器将调用JavaBean对象的getModel()方法，并把返回值类型压入到ValueStack栈

Params拦截器的作用：

将表单的字段映射到ValueStack栈的栈顶对象的各个属性中。由于此时ValueStack栈的栈顶元素是刚被压入的模型（JavaBean）对象（先用到ModelDriven拦截器，才有这句话），所以该模型将被填充，假设每一个字段在模型里没有匹配的属性，Params拦截器将尝试ValueStack栈中的下一个对象。

PrepareInterceptor拦截器的作用：

u  若Action实现Preparable接口，则Action方法需实现prepare()方法

u  PrepareInterceptor拦截器将调用prepare()方法、prepareActionMethodName()方法和prepareDoActionMethodName()方法

u  PrepareInterceptor拦截器依据firstCallPrepareDo属性决定获取prepareActionMethodName、prepareDoActionNam的顺序。默认情况下先获取prepareDoActionName(),假设没有该方法，就寻找prepareDoActionMethodName()。

假设找到了相应的方法就调用该方法。

u  PrepareInterceptor拦截器会依据alwaysInvokePrepare属性决定是否运行prepare()方法

paramsPrepareParamsStack拦截器栈的作用：（參考struts-default.xml配置文件的结构。就知道具体的含义了）。如今具体解析一下：

u  paramsPrepareParamsStack从字面上理解来说。这里Stack的拦截器调用的顺序为：首先params,然后prepare,接下来modelDriven。最后在params

u  Struts2.0的设计上要求modelDriven在params之前调用，而业务中prepare要负责准备model，准备model又须要參数，这就须要在prepare之前执行params拦截器设置相关參数，这个也就是创建paramsPrepareParamsStack的原因。

u  流程例如以下：

A.       Params拦截器首先给action中的相关參数赋值。如id

B.       Prepare拦截器运行prepare方法，prepare方法中会依据參数，如id，去调用业务逻辑，设置model对象

C.       ModelDriver拦截器将model对象压入ValueStack，这里的model对象就是在prepare中创建的

D.       Params拦截器再将參数赋值给model对象

E.        Action的业务逻辑运行

请參考以下源码解析：（第一部分是PrepareInterceptor拦截器的操作流程）

package com.opensymphony.xwork2.interceptor;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.Preparable;

import com.opensymphony.xwork2.util.logging.Logger;

import com.opensymphony.xwork2.util.logging.LoggerFactory;

import java.lang.reflect.InvocationTargetException;

public
class PrepareInterceptor extends MethodFilterInterceptor {

private
static final
long serialVersionUID = -5216969014510719786L;

private
final static String PREPARE_PREFIX =
"prepare";

private
final static String ALT_PREPARE_PREFIX =
"prepareDo";

private
boolean alwaysInvokePrepare =
true;

private
boolean firstCallPrepareDo =
false;

public
void setAlwaysInvokePrepare(String alwaysInvokePrepare) {

this.alwaysInvokePrepare = Boolean.parseBoolean(alwaysInvokePrepare);

}

public
void setFirstCallPrepareDo(String firstCallPrepareDo) {

this.firstCallPrepareDo = Boolean.parseBoolean(firstCallPrepareDo);

}

@Override

public String doIntercept(ActionInvocation invocation)
throws Exception {

    //获取Action对象

Object action = invocation.getAction();

//推断Action是否实现了preparable接口

if (action
instanceof Preparable) {

try {

String[] prefixes;

//依据当前拦截器的 firstCallPrepareDo(默觉得 false)
属性确定 prefixes

if (firstCallPrepareDo) {

prefixes = new String[] {ALT_PREPARE_PREFIX,
PREPARE_PREFIX};

} else {

prefixes = new String[] {PREPARE_PREFIX,
ALT_PREPARE_PREFIX};

}

//若为 false,
则 prefixes: prepare, prepareDo

            //调用前缀方法.

PrefixMethodInvocationUtil.invokePrefixMethod(invocation, prefixes);

}

catch (InvocationTargetException e) {

Throwable cause = e.getCause();

if (cause
instanceof Exception) {

throw (Exception) cause;

} else
if(cause instanceof Error) {

throw (Error) cause;

} else {

throw e;

}

}

//依据当前拦截器的 alwaysInvokePrepare(默认是 true)
决定是否调用 Action
的 prepare
方法

if (alwaysInvokePrepare) {

((Preparable) action).prepare();

}

}

return invocation.invoke();

}

}

PrefixMethodInvocationUtil.invokePrefixMethod(invocation, prefixes) 方法:

package com.opensymphony.xwork2.interceptor;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.util.logging.Logger;

import com.opensymphony.xwork2.util.logging.LoggerFactory;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

public
class PrefixMethodInvocationUtil {

private
static final Logger LOG = LoggerFactory.getLogger(PrefixMethodInvocationUtil.class);

private
static final String DEFAULT_INVOCATION_METHODNAME =
"execute";

private
static final Class[] EMPTY_CLASS_ARRAY =
new Class[0];

public
static void invokePrefixMethod(ActionInvocation actionInvocation, String[] prefixes)
throws InvocationTargetException, IllegalAccessException {

//获取 Action
实例

Object action = actionInvocation.getAction();

//获取要调用的 Action
方法的名字(update)

String methodName = actionInvocation.getProxy().getMethod();

if (methodName ==
null) {

// if null returns (possible according to the docs), use the default execute

methodName = DEFAULT_INVOCATION_METHODNAME;

}

//获取前缀方法

Method method = getPrefixedMethod(prefixes, methodName, action);

//若方法不为 null,
则通过反射调用前缀方法

if (method !=
null) {

method.invoke(action, new Object[0]);

}

}

public
static Method getPrefixedMethod(String[] prefixes, String methodName, Object action) {

assert(prefixes !=
null);

//把方法的首字母变为大写

String capitalizedMethodName =capitalizeMethodName(methodName);

//遍历前缀数组

for (String prefixe : prefixes) {

String prefixedMethodName = prefixe + capitalizedMethodName;

//通过拼接的方式,
得到前缀方法名:
第一次 prepareUpdate,
第二次prepareDoUpdate

try {

//利用反射获从 action
中获取相应的方法,
若有直接返回. 并结束循环.

return action.getClass().getMethod(prefixedMethodName,
EMPTY_CLASS_ARRAY);

}

catch (NoSuchMethodException e) {

// hmm -- OK, try next prefix

if (LOG.isDebugEnabled()) {

LOG.debug("cannot find method [#0] in action [#1]", prefixedMethodName, action.toString());

}

}

}

return
null;

}

public
static String capitalizeMethodName(String methodName) {

assert(methodName !=
null);

return methodName.substring(0, 1).toUpperCase() + methodName.substring(1);

}

}

第二部分（ModelDriver拦截器的源码解析）

package com.opensymphony.xwork2.interceptor;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.ModelDriven;

import com.opensymphony.xwork2.util.CompoundRoot;

import com.opensymphony.xwork2.util.ValueStack;

public
class ModelDrivenInterceptor
extends AbstractInterceptor {

protected
boolean refreshModelBeforeResult =
false;

public
void setRefreshModelBeforeResult(boolean val) {

this.refreshModelBeforeResult = val;

}

@Override

public String intercept(ActionInvocation invocation)
throws Exception {

//获取 Action
对象: EmployeeAction
对象,
此时该 Action
已经实现了 ModelDriven
接口

    //public class EmployeeAction implements RequestAware, ModelDriven<Employee>

Object action = invocation.getAction();

//推断 action
是否是 ModelDriven
的实例

if (action
instanceof ModelDriven) {

//强制转换为 ModelDriven
类型

ModelDriven modelDriven = (ModelDriven) action;

//获取值栈

ValueStack stack = invocation.getStack();

//调用 ModelDriven
接口的 getModel()
方法

            //即调用 EmployeeAction
的 getModel()
方法

            /*

            public Employee getModel() {

              employee = new Employee();

              return employee;

           }

            */

Object model = modelDriven.getModel();

if (model != 
null) {

//把 getModel()
方法的返回值压入到值栈的栈顶.
实际压入的是 EmployeeAction
的 employee
成员变量

stack.push(model);

}

if (refreshModelBeforeResult) {

invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model));

}

}

return invocation.invoke();

}

/**

* Refreshes the model instance on the value stack, if it has changed

*/

protected
static class RefreshModelBeforeResult
implements PreResultListener {

private Object
originalModel = null;

protected ModelDriven
action;

public RefreshModelBeforeResult(ModelDriven action, Object model) {

this.originalModel = model;

this.action = action;

}

public
void beforeResult(ActionInvocation invocation, String resultCode) {

ValueStack stack = invocation.getStack();

CompoundRoot root = stack.getRoot();

boolean needsRefresh =
true;

Object newModel = action.getModel();

// Check to see if the new model instance is already on the stack

for (Object item : root) {

if (item.equals(newModel)) {

needsRefresh = false;

}

}

// Add the new model on the stack

if (needsRefresh) {

// Clear off the old model instance

if (originalModel !=
null) {

root.remove(originalModel);

}

if (newModel !=
null) {

stack.push(newModel);

}

}

}

}

}

细节凝视：

细节一：运行 ParametersInterceptor 的 intercept 方法: 把请求參数的值赋给栈顶对象相应的属性. 若栈顶对象没有相应的属性, 则查询值栈中下一个对象相应的属性...

细节二：getModel 方法不能提供下面实现. 的确会返回一个 Employee 对象到值栈的栈顶. 但当前 Action 的 employee 成员变量却是 null.

@Override

public
Employee getModel() {

return
new Employee();

}

版权声明：本文博客原创文章，博客，未经同意，不得转载。