xwork的command模式 .

转载

http://blog.csdn.net/flyforlove/article/details/1661965

 

xwork中command模式中的几个类

命令的发出者：ActionProxy

命令的传送者：ActionInvaction

命令的执行者：Action

 

当然，xwork的内部调用没有这么简单，使用xml配置文件来联系各个类。

现在用程序模拟以下xwork的comman模式工作方式。

 

首先是ActionProxy

ActionProxy.java

 

publicinterface ActionProxy {

public String execute() throws Exception;

}

 

ActionProxy是命令的发出着，也就是说client并不是直接让Action执行的，而是让ActionProxy来代理执行（虽然这儿看起来有点儿像代理模式，但是不是）.

下面是ActionProxy的实现

package jp.co.wqf;

 

publicclass ActionProxyImpl implements ActionProxy {

 

Invocation invocation;

public ActionProxyImpl(Invocation invocation) {

this.invocation = invocation;

}

public String execute() throws Exception {

returninvocation.invoke();

}

 

}

要注入一个Invocation让其来传送命令。

 

接下来是ActionInvocation

ActionInvocation.java

public interface Invocation {

public String invoke() throws Exception;

}

定义一个调用方法。

它的实现为

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Map;

 

publicclass InvocationImpl implements Invocation {

Iterator interceptors;

Action action;

Map resultMap;

booleanexecuted = false;

String resultCode;

public InvocationImpl(ArrayList interceptors, Action action, Map resultMap){

this.interceptors = interceptors.iterator();

this.action = action;

this.resultMap = resultMap;

}

public String invoke() throws Exception {

if(executed){

thrownew Exception("Action has been execute!");

}

if(interceptors.hasNext()) {

Interceptor interceptor = (Interceptor) interceptors.next();

interceptor.intercept(InvocationImpl.this);

}else{

resultCode = action.exectute();

}

if(!executed){

Result result = (Result) resultMap.get(resultCode);

if(result!=null)

result.execute();

executed = true;

}

returnresultCode;

}

 

}

这是一个比较主要的类，很多处理都是通过这儿来中转的，首先它通过注入和递归调用来实现了方法拦截，然后再调用Action来执行真正的处理，并根据处理结果来调用不同的结果处理类（Result）

 

 

最后是Action接口

Action.java

publicinterface Action {

public String exectute();

}

Action接口里定义了一个execute方法，用来执行某种操作，例如，数据库的CRUD各个操作等，用一个String的返回值来表示执行结果，比如“success”，“error”等。实际上xwork支持任何的执行方法，不仅限于execute，只要在xwork.xml文件中指定执行哪个方法就可以了

 

以下是Action接口的实现类，这儿返回一个“error”字符串。

publicclass ActionImpl implements Action {

 

public String exectute() {

System.out.println("Action Execute");

//return "success";

return"error";

}

 

}

 

另外还有Interceptor和Result接口，实现类。

Interceptor.java

public interface Interceptor {

publicvoid intercept(Invocation invocation) throws Exception;

}

InterceptorImpl.java

public class InterceptorImpl implements Interceptor {

private String name;

public InterceptorImpl(String name){

this.name = name;

}

publicvoid intercept(Invocation invocation) throws Exception {

System.out.println(name+", start");

invocation.invoke();

System.out.println(name+", end");

}

 

}

Result.java

public interface Result {

publicvoid execute();

}

ResultImpl.java

public class ResultImpl implements Result {

private String name;

public ResultImpl(String name) {

this.name = name;

}

publicvoid execute() {

System.out.println("Result "+this.name+" execute!");

}

 

}

测试类如下：

public class Test {

 

/**

*@paramargs

*@throwsException

*/

publicstaticvoid main(String[] args) throws Exception {

// TODO Auto-generated method stub

ArrayList interceptors = new ArrayList();

for (int i = 0; i < 5; i++) {

Interceptor inter = new InterceptorImpl("Interceptor_"+i);

interceptors.add(inter);

}

Result result = null;

Map resultMap = new HashMap();

result = new ResultImpl("success");

resultMap.put("success", result);

result = new ResultImpl("error");

resultMap.put("error", result);

 

Action action = new ActionImpl();

Invocation invocation = new InvocationImpl(interceptors, action, resultMap);

 

ActionProxy actionProxy = new ActionProxyImpl(invocation);

actionProxy.execute();

}

 

}

 

要点：

1.comman模式

2.IOC注入

3.递归调用（使用递归调用来实现方法拦截是个比较新颖的方法）