6. ModelDriven拦截器、Preparable 拦截器

2021-07-27 01:27:42

1. 问题

Struts2 的 Action 我们将它定义为一个控制器，但是由于在 Action 中也可以来编写一些业务逻辑，也有人会在 Action 输入业务逻辑层。
但是在企业开发中，我们一般会将业务逻辑层单独编写，而不是将它与 action 层写到一起。
之前的练习中，我们一直将属性如 username 、 password 等保存在了 action 中。
这样做了以后导致我们在调用业务逻辑层时可能需要将Action的对象传过去。
但是这样做无异于直接将 Servlet 传给 Service，导致两层之间的耦合，而且我们也不希望其他对象可以直接使用Action对象。
要解决这个问题，我们可以采用的一种方式是，专门在Action中定义一个属性，用来封装信息。然后只需要将这个对象传个service即可。
但是这样又带来了一个新问题，谁来将属性封装进对象呢？答案就是ModelDriven拦截器
拦截器：
- 拦截器的作用和过滤器类似。
- 拦截器可以在请求到达Action之前进行拦截，希望在请求到达Action之前通过拦截器做一些准备工作。

Struts2 简单的运行流程:
- 请求首先到达StrutsPrepareAndExecuteFilter.doFilter()
- 在doFilter方法中，先获取ActionMapping
  - 判断：如果ActionMapping为null，不是Struts请求，直接放行
  - 如果ActionMapping不为null，是Struts请求，继续处理
- 通过configurationManager加载Struts的配置信息，找到请求对应的Action对象
  - 根据配置信息创建ActionProxy代理类。
- 在StrutsActionProxy.execute()方法中调用DefaultActionInvocation.invoke()方法
- 对所有的拦截器进行迭代在去分别调用拦截器intercept方法，进行拦截请求
- intercept方法我们对请求进行一些处理，处理完毕以后继续DefaultActionInvocation.invoke()方法
- 如此反复直到所有的拦截器都被调用
- 最后才去执行Action的方法。

2. 请求参数在哪封装的：

请求参数在到达Action之前，会先经过ParametersInterceptor拦截器，
在该拦截器中会自动对将请求参数封装进值栈的栈顶对象，
他会根据属性名将属性值设置进栈顶对象的相应属性中，
如果栈顶中没有该属性，则继续向第二对象进行封装。

<!-- 查看 ParametersInterceptor 源码-->

@Override

public String doIntercept(ActionInvocation invocation) throws Exception {

    Object action = invocation.getAction();

    if (!(action instanceof NoParameters)) {

        ActionContext ac = invocation.getInvocationContext();

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

                ValueStack stack = ac.getValueStack();

                setParameters(action, stack, parameters); // 在这方法中设置参数到对象中

            } finally {

                ReflectionContextState.setCreatingNullObjects(contextMap, false);

                ReflectionContextState.setDenyMethodExecution(contextMap, false);

                ReflectionContextState.setReportingConversionErrors(contextMap, false);

            }

        }

    }

    return invocation.invoke();

}

3. ModelDriven拦截器

虽然我们知道了参数是从什么地方压入栈顶对象的，但是我们还是无法更好的处理方式把参数封装成对象，放到对象中去。
所以我们需要使用ModelDriven 拦截器
我们查看 ModelDrivenInterceptor 源码能发现，在该拦截器中，对于实现了 ModelDriven 接口的Action ，会调用getModel() 方法把，getModel() 返回的对象压入值栈栈顶，所以对于我们来说，可以使用一个JavaBean 作为参数的分装

@Override

public String intercept(ActionInvocation invocation) throws Exception {

    Object action = invocation.getAction();

    if (action instanceof ModelDriven) {

        ModelDriven modelDriven = (ModelDriven) action;

        ValueStack stack = invocation.getStack();

        Object model = modelDriven.getModel();

        if (model !=  null) {

           stack.push(model);

        }

        if (refreshModelBeforeResult) {

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

        }

    }

    return invocation.invoke();

}

当用户触发 add 请求时, ModelDriven 拦截器将调用 EmployeeAction 对象的 getModel() 方法, 并把返回的模型(Employee实例)压入到 ValueStack 栈.
接下来 Parameters 拦截器将把表单字段映射到 ValueStack 栈的栈顶对象的各个属性中. 因为此时 ValueStack 栈的栈顶元素是刚被压入的模型(Employee)对象, 所以该模型将被填充. 如果某个字段在模型里没有匹配的属性, Param 拦截器将尝试 ValueStack 栈中的下一个对象

/**

 * 实现 ModelDriven 接口

 */

public class EmployeeAction extends ActionSupport implements RequestAware, ModelDriven<Employee> 

//=================

// 重写实现 getModel 方法

@Override

public Employee getModel() {

	System.out.println("  getModel() Method， ............");

	if (employee == null) {

		employee = new Employee();

	}

	// 如果通过 return new Employee() 的方式,虽然栈顶对象是Employee,但是在Action 中的Employee为Null

	return employee;

}

但是我们还有一个问题需要解决，我们去修改表单数据的时候。通常需要使用Id 去数据库中查询出来对象。如果我们直接用下面的方式，在修改页面是无法获取到对应的值。
- 示例中我们只是使得 employee 引用复制了一份，并且指向了给 employeeDao.getEmpById(employee.getId());对象，实际上我们在栈顶兑现给的值并没有改变

public String input() {

	// 因为点击修改的时候，会put Id值到栈顶对象Employee 中，所以我们查询出来的employee 并不会放到栈顶

	// 如果这样的话 我们把指向 ValueStack 栈顶的引用，改为了从数据库查询出来的值。

	// 所以 ValueStack 中的 employee 并没有被赋值

	employee = employeeDao.getEmpById(employee.getId());

	System.out.println(employee);

	return "input";

}

但是我们如果一个个的去赋值属性又特别麻烦.。如果使用获取ValueStack 的方式去重新放入栈顶再弹出的方式也不是一个好的方法。

Employee emp = employeeDao.getEmpById(employee.getId());

employee.setName(emp.getName());

employee.setRole(emp.getRole());

employee.setDept(emp.getDept());

employee.setAge(emp.getAge());

所以我们最好的方式，是在 getModel() 方法中，根据 Action 的属性 id 去数据库中获取资源。但是程序中默认使用的是 defaultStack 拦截器栈。在defaultStack拦截器栈中，modelDriven 拦截器之前并没有 params 拦截器，如果需要对Action 参数赋值的话，就需要在 modelDriven 拦截器之前设置params 拦截器

 <interceptor-stack name="defaultStack">

    <interceptor-ref name="exception"/>

    <interceptor-ref name="alias"/>

    <interceptor-ref name="servletConfig"/>

    <interceptor-ref name="i18n"/>

    <interceptor-ref name="prepare"/>

    <interceptor-ref name="chain"/>

    <interceptor-ref name="scopedModelDriven"/>

    <interceptor-ref name="modelDriven"/>

    <interceptor-ref name="fileUpload"/>

    <interceptor-ref name="checkbox"/>

    <interceptor-ref name="datetime"/>

    <interceptor-ref name="multiselect"/>

    <interceptor-ref name="staticParams"/>

    <interceptor-ref name="actionMappingParams"/>

    <interceptor-ref name="params"/>

    <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-ref name="debugging"/>

    <interceptor-ref name="deprecation"/>

</interceptor-stack>

根据上面的结果，我们需要做的操作是：
1. 先调用 param 拦截器封装一部分属性进入Action
2. 再调用modelDriven 拦截器进入值栈
3. 在 getModel() 方法中判断id 是否为空，然后再返回不同的结果
于是，我们可以使用 paramsPrepareParamsStack 拦截器栈，paramsPrepareParamsStack 这个拦截器栈中params拦截器会执行两次，
- 一次在ModelDriven之前，一次在ModelDriven之后，
- 这样我们就可以根据不同的请求参数，给值栈栈顶放入不同对象。
在 struts.xml 修改默认的拦截器栈

<!-- 修改拦截器栈 -->

<interceptors>

	<interceptor-stack name="myInterceptorStck" >

		<interceptor-ref name="paramsPrepareParamsStack"></interceptor-ref>

	</interceptor-stack>

</interceptors>

<!-- 设置使用的拦截器为 我们设置的拦截器栈： myInterceptorStck  -->

<default-interceptor-ref name="myInterceptorStck"></default-interceptor-ref>

使用paramsPrepareParamsStack 拦截器栈后，修改后的 getModel() 和 input 方法

@Override

public Employee getModel() {

	System.out.println(" getModel() Method ............");

	if (id == null) {

		employee = new Employee();

	} else {

		employee = employeeDao.getEmpById(id);

	}

	return employee;

}

// ====================

public String input() {

	return "input";

}

这样使得代码就更加的简洁了一些

4. 新的问题

在使用 paramsPrepareParamsStack 拦截器栈之后，虽然已经很简洁了，但是我们出现了新的问题。
- 在我们做 CRUD 操作是， delete 和 update 方法都带有 id
  - 一个根据 id 删除用户
  - 一个是更新用户信息
- 都有 id 就会导致调用getModel会去数据库中查询员工信息。
- 但是实际业务上我们并没有这样的需求
- 所以我们引出了 Preparable拦截器

5. Preparable 拦截器

Struts 2.0 中的 modelDriven 拦截器负责把 Action 类以外的一个对象压入到值栈栈顶
而 prepare 拦截器负责准备为 getModel() 方法准备 model，并且在 modelDriven 拦截器之前
PrepareInterceptor拦截器使用方法
- 若 Action 实现 Preparable 接口，则 Action 方法需实现 prepare() 方法
- PrepareInterceptor 拦截器将调用 prepare() 方法，prepareActionMethodName()方法或 prepareDoActionMethodName ()方法
- PrepareInterceptor 拦截器根据 firstCallPrepareDo 属性决定获取 prepareActionMethodName 、prepareDoActionMethodName 的顺序。默认情况下先获取 prepareActionMethodName (), 如果没有该方法，就寻找prepareDoActionMethodName()。如果找到对应的方法就调用该方法
- PrepareInterceptor 拦截器会根据 alwaysInvokePrepare 属性决定是否执行 prepare() 方法

// com.opensymphony.xwork2.interceptor.PrepareInterceptor

private final static String PREPARE_PREFIX = "prepare";

private final static String ALT_PREPARE_PREFIX = "prepareDo";

private boolean alwaysInvokePrepare = true;

private boolean firstCallPrepareDo = false;

//===============

@Override

public String doIntercept(ActionInvocation invocation) throws Exception {

    Object action = invocation.getAction();

    if (action instanceof Preparable) {

        try {

            String[] prefixes;

             //根据 firstCallPrepareDo 的值（默认为false）来决定调用两个prepare 方法，可以在struts.xml 中修改

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

            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();

}

方法执行顺序：
- action.prepareXxx方法
- action.prepare方法
- action.getModel
- action.action方法
我们可以在prepareXxx方法做一个个性化的处理，可以在prepare方法做一些统一的处理。

public String add() {

	employeeDao.save(employee);

	return SUCCESS;

}

/**

 * 该方法会在add方法执行之前执行

 * 也会在getModel方法执行之前执行，放到值栈栈顶中

 */

public void prepareDoAdd() {

	System.out.println("prepareDoAdd............");

	employee = new Employee();

}

//======================================================

public String del() {

	employeeDao.delete(employee.getId());

	return SUCCESS;

}

//======================================================

public String input() {

	return "input";

}

public void prepareInput() {

	System.out.println("prepareInput.........");

	employee = employeeDao.getEmpById(id);

}

//======================================================

public String update() {

	employeeDao.update(employee);

	return SUCCESS;

}

/**

 * 在update方法之前，初始化employ,然后由 getModel 方法放到栈顶

 */

public void prepareUpdate() {

	System.out.println("prepareUpdate..............");

	employee = new Employee();

}

//======================================================

@Override

public Employee getModel() {

	System.out.println("getModel。。。。。。。。。。。");

	return employee;

}

//======================================================

/**

 * 该方法中，可以做一些统一的处理

 */

@Override

public void prepare() throws Exception {

	System.out.println("prepare..................");

	/*

	 *  例如：对于 delete 方法，虽然该方法只需要使用 id，

	 *  	但是我们调用该方法之前，调用 getModel() 返回的是个 null

	 *  	所以我们可以在这 做一次判断

	 */

	if (employee == null) {

		employee = new Employee();

	}

}

对于我们如果想修改 PrepareInterceptor拦截器 中的一些参数。
- 修改 prepareXxx 和 prepareDoXxxx 调用的顺序
- 修改 alwaysInvokePrepare 的值，使得 Action 不调用 prepare() 方法
- 参考 docs 中 Interceptor Parameter Overriding

<!-- 修改拦截器栈 -->

<interceptors>

	<interceptor-stack name="myInterceptorStck" >

		<interceptor-ref name="paramsPrepareParamsStack">

			<!-- 修改拦截器栈属性值，name.filed -->

			<param name="prepare.alwaysInvokePrepare">false</param>

			<param name="prepare.firstCallPrepareDo">true</param>

		</interceptor-ref>

	</interceptor-stack>

</interceptors>

码农公寓

1. 问题

2. 请求参数在哪封装的：

3. ModelDriven拦截器

4. 新的问题

5. Preparable 拦截器

相关文章