拦截器栈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拦截器栈执行流程完毕。