Struts2入门---增删改查- 拦截器栈的应用

Struts2 应用拦截器 ModelDriven 和 Prepare 实现对数据库的增删改查功能.....

先看看效果图:

　　

jsp 静态代码我就不写了 ,以下是主要实现功能的java代码:

package com.struts.app;

import java.util.Map;

import org.apache.struts2.interceptor.RequestAware;

import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.Preparable;
public class EmployeeAction implements RequestAware, ModelDriven<Employee>, Preparable{
　　
    private Dao dao = new Dao();  //实例化数据操作对象
    
    private Employee employee;    
    public String update(){       //定义update()方法
        dao.update(employee);     
        return "success";
    }
    public void prepareUpdate(){  //定义 prepare 拦截器需要的方法(作用:需要用到数据对象的方法可以单一的实现)
        employee = new Employee();
    }
    public String edit(){
        return "edit";
    }
    public void prepareEdit(){
        employee = dao.get(employeeId);
    }
    public String save(){
        dao.save(employee);
        return "success";
    }
    public void prepareSave(){
        employee = new Employee();
    }
    public String delete(){
        dao.delete(employeeId);
        //返回结果的类型应为: redirectAction.
        //也可以是 chain: 实际上 chain 是没有必要的 . 因为不需要在下一个 Action 中保留当前 Action 的状态
        //还有, 若使用 chain , 则达到目标页面后, 地址栏显示的 依然是删除时的那个连接. 刷新时会重复提交.. 
        return "success";
    }
    
    public String list(){
        request.put("emps", dao.getEmployees());
        return "list";
    }

    private Map<String, Object> request;
    @Override
    public void setRequest(Map<String, Object> request) {
        this.request = request;
        
    }
    private Integer employeeId;
    public void setEmployeeId(Integer employeeId) {
        this.employeeId = employeeId;
    }
    @Override
    public Employee getModel() {    //这是实现 ModelDriven 重写的 getModel()方法.作用是:获取model(这样避免了在Action中定义model)
        return employee;
    }
    /*
     *  prepare() 方法的主要作用: 为getModel() 方法 准备model 的.(避免了在执行方法时导致加载浪费(有些方法不需要加载对象 但它也加载了 浪费资源))
     */
    @Override
    public void prepare() throws Exception {
        System.out.println("prepare...");
    }
}

那为什么要这么写呢?这需要了解 Struts2 拦截器栈的运行流程

 

一般情况下我们默认的是 defaultStack 这个拦截器栈 由上图看出里面定义了许多的拦截器. 而struts 在运行的时候,都会进入这些拦截器一遍.以上每个拦截器有他对应的作用,在这里我就不一一举例了.

上面的代码就是根据 prepare拦截器 与 modelDriven拦截器 的特性所写:

　　下面我们来看看 modelDriven 拦截器是怎么运行的:

　　　　1.  Action 类需要实现 ModelDriven接口 并重写getModel() 方法

　　　　2. ModelDriven 拦截器的运行流程:　

　　　　　　1). 先会执行 ModelDrivenIntercepptor 的 intercept 方法.

　------------------------------------源代码分析-----------------------------------------------
　　　　　　public String intercept(ActionInvocation invocation) throws Exception {
　　　　　　//获取 Action 对象: EmployeeAction 对象, 此时该 Action 已经实现了 ModelDriven 接口.
　　　　　　Object action = invocation.getAction();

　　　　　　//判断 action 是否 是 ModelDriven 的实例
　　　　　　if (action instanceof ModelDriven) {
　　　　　　　　//强制转换为 ModelDriven 类型
　　　　　　　   ModelDriven modelDriven = (ModelDriven) action;
　　　　　　　　//获取值栈
　　　　　　　　ValueStack stack = invocation.getStack();
　　　　　　　　//调用 ModelDriven 接口的 getModel()方法
　　　　　　　　Object model = modelDriven.getModel();
　　　　　　　　if (model != null) {
　　　　　　　　　　//把getModel()的返回值 压入到值栈的栈顶.
　　　　　　　　　　stack.push(model);
　　　　　　　　}
　　　　　　　　if (refreshModelBeforeResult) {
　　　　　　　　　　invocation.addPreResultListener(new RefreshModelBeforeResult(modelDriven, model));
　　　　　　　　}
　　　　　　}
　　　　　　return invocation.invoke();
　　　　　　}

　　　　　　2). 执行 ParametersInterceptor 的 intercept 方法:把请求参数的值赋给栈顶对象对应的属性 , 若栈顶对象没有对应的属性,
　　　　　　　　则查询值栈中下一个对象对应的属性.　　　

　　　　　　3). 注意: Struts2.5版本后 通配符的写法: Action 中的方法需要被允许.
　　　　　　　　<action name="emp-*"
　　　　　　　　class="com.struts.app.EmployeeAction"
　　　　　　　　method="{1}">
　　　　　　　　　　<result name="{1}">/emp-{1}.jsp</result>
　　　　　　　　　　<result name="success" type="redirectAction">emp-list</result>
　　　　　　　　　　<allowed-methods>list,save,edit,update,delete</allowed-methods>
　　　　　　　　</action>

　　同理 (prepare) PrepareInterceptor拦截器运行流程:

---------------------------------源代码解析--------------------------------------

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) 方法:
 
public static void invokePrefixMethod(ActionInvocation actionInvocation, String[] prefixes)
 throws InvocationTargetException, IllegalAccessException {
    //获取 Action 实例
    Object action = actionInvocation.getAction();
    //获取调用的 Action 中的 方法名(update)
    String methodName = actionInvocation.getProxy().getMethod();
    
    //如果方法名为空 默认为 execute
    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);
    if (method != null) {
        method.invoke(action, new Object[0]);
    }
}

PrefixMethodInvocationUtil.getPrefixedMethod 方法:

public static Method getPrefixedMethod(String[] prefixes, String methodName, Object action) {
    assert(prefixes != null);
    //将方法名首字母置为大写(Update)
    String capitalizedMethodName = capitalizeMethodName(methodName);
    //遍历前缀数组
    for (String prefixe : prefixes) {
        //通过拼接的方式得到 前缀方法名 : 第一次prepareUpdate,第二次prepareDoUpdate
        String prefixedMethodName = prefixe + capitalizedMethodName;
        try {
            //利用反射从 action 中 获取对应的方法, 若有直接返回. 并结束循环.
            return action.getClass().getMethod(prefixedMethodName, EMPTY_CLASS_ARRAY);
        }
        catch (NoSuchMethodException e) {
            // hmm -- OK, try next prefix
            LOG.debug("Cannot find method [{}] in action [{}]", prefixedMethodName, action);
        }
    }
    return null;
}

　　　　解析源代码得出结论:

　　　　　　若 Action 实现了 Preparable 接口 则 Struts2 将尝试执行 prepare[ActionMethodName] 方法,
　　　　　　若 prepare[ActionMethodName] 不存在,则将尝试执行 prepareDo[ActionMethodName] 方法.
　　　　　　若都不存在,就都不执行.

　　　　　　若 PrepareInterceptor 的 alwaysInvokePrepare 属性为 false,
　　　　　　则Struts2 将不会调用该实现了 Preparable 的 Action 的 prepare() 方法.

　　　　　　可以为每一个 ActionMethod 准备 prepare[ActionMethodName] 方法, 而抛弃掉原来的 prepare() 方法
　　　　　　将 PrepareInterceptor 的 alwaysInvokePrepare 属性设置为 false, 避免 Struts2 框架再调用 prepare() 方法.

　　　　　　如何在配置文件中为拦截器栈的属性赋值:参看 /struts-2.5.12/docs/docs/interceptors.html

　　　　　<interceptors>
            <interceptor-stack name="myStack">
                <interceptor-ref name="paramsPrepareParamsStack">
                    <param name="prepare.alwaysInvokePrepare">false</param>
                </interceptor-ref>
            </interceptor-stack>
         </interceptors>
        <default-interceptor-ref name="myStack"/>

这个项目中我们需要用struts 的  paramsPrepareParamsStack 这个栈.

使用 paramsPrepareParamsStack 拦截器栈后的运行流程

1). paramsPrepareParamsStack 和 defaultStack 一样都是拦截器栈, 而 struts-default 包默认使用的是 defaultStack

2). 可以在struts 配置文件中通过以下方式修改默认的拦截器栈:
<default-interceptor-ref name="paramsPrepareParamsStack"></default-interceptor-ref>

3). paramsPrepareParamsStack 拦截器栈 特殊之处:
params ->ModelDriven -> params
这样可以先把请求参数赋值给 Action 对应的属性, 再根据赋给 Action 的那个属性值决定 压入到值栈栈顶的对象, 最后再为栈顶对象的属性赋值.(用于表单发送请求参数不同给出不同的响应结果)

4). 关于回显: Struts2 表单标签会从值栈中获取对应的属性值进行回显.

以上就是关于struts 增删改查 与拦截器的简单应用..