注：这是一个“重复造*”的过程，不对框架做任何讲解
在JavaEE中的MVC（三）中，我在Servlet中引入了命令模式的使用，采用Xml配置的方式，实现了一个Servlet调用多个不同的Action类，但是还不能实现页面地跳转，这一篇博客从之前的代码上，进一步地封装，实现Action跳转Jsp的功能，并且介绍一下如何将我们客户端的参数，传给我们的Action。
改进思路
我们要想办法解决这些问题：
- Action内部不应该只有excute()一个方法，还可以有add()、delete()、update()等等，而且在执行完这些方法之后，能进行页面跳转，比如：执行完add()的时候，跳转到add.jsp页面；
- 在Xml配置文件上，我们应该为我们的Action节点，添加一个或者多个子节点，这个子节点可以命名为result，用以表示Action期望跳转的Jsp页面；
- 有对应的Javabean，解析完Xml配置之后，需要存储数据，自然需要Javabean。因为一个Action可能有多个Result，因此还要有对应的数据结构。
整体的流程就如下所示：客户端发送请求，Servlet负责解析Url，根据Url调用指定的Action，执行Action中相应的操作，执行完这一部分操作之后，会有一个返回值，根据返回值再跳转Jsp页面：
配置文件Plus
重新设计我们的配置文件，在Action节点下添加Result节点，Result拥有3个属性：
- name：当我们执行Action中的某一个方法的时候，会有一个返回值，返回值与name的值相对应；
- page：所要跳转的目标页面；
- redirect：跳转目标页面所用的方法是否是重定向。
<?xml version="1.0" encoding="UTF-8"?>
<mystruts>
<action name="HiAction" class="com.action.HiAction">
<result name="success" page="Hello.jsp" redirect="true" />
<result name="add" page="Hi.jsp" />
<result name="delete" page="Hi.jsp" />
</action>
<action name="HelloAction" class="com.action.HelloAction">
<result name="error" page="Hello.jsp" />
</action>
</mystruts>Action类
这两个Action都继承自MyAction接口，其中HiAction中包含excute()以外的其它方法。
public interface MyAction {
String SUCCESS = "success";
String NONE = "none";
String ERROR = "error";
String INPUTE = "inpute";
String LOGIN = "login";
String excute() throws Exception;
}
public class HelloAction implements MyAction{
@Override
public String excute() {
System.out.println("this is helloAction");
return ERROR;
}
}
public class HiAction implements MyAction{
@Override
public String excute() {
System.out.println("this is hiAction:ERROR");
return ERROR;
}
public String add() {
System.out.println("this is hiAction:add");
return "add";
}
public String delete() {
System.out.println("this is hiAction:delete");
return "delete";
}
}设计Javabean
ActionDifinition
我们原先的Javabean是Action，但是现在，我们的节点更加多样化，所以重新设计Javabean，取名叫ActionDifinition，ActionDifinition内部封装了Action和一个Result，因为Action和Jsp是一对多的关系，因此，将Result封装在Map中。
注：其中invoke(String methodName)和createAction()两个方法可以提取，单独创建工具类。
public class ActionDifinition {
private MyAction mAction;
private Map<String, Result> mResulteMap = new HashMap<String, Result>();
public void putResult(String key, Result value) {
mResulteMap.put(key, value);
}
public Result getResult(String key){
return mResulteMap.get(key);
}
public void setAction(MyAction action) {
this.mAction = action;
}
/**
* 寻找并执行由Uri中指定的，Action中的方法，并且将返回值return
*/
public String invoke(String methodName) {
try {
if (methodName == null)
return mAction.excute();
MyAction action=createAction();
Method[] methods = action.getClass().getDeclaredMethods();
for (Method method : methods) {
if (methodName.equals(method.getName())) {
return (String) method.invoke(action);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 生成Action的备份，这一点前面提到了，因为希望不同用户的相同业务使用不同的Action
*/
private MyAction createAction() {
try {
return mAction.getClass().newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}Result
这个Javabean封装了我们希望跳转的Jsp页面的相关信息，内容与Xml配置文件相对应。
public class Result {
private String name;
private String page;
private boolean redirect;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPage() {
return page;
}
public void setPage(String page) {
this.page = page;
}
public boolean isRedirect() {
return redirect;
}
public void setRedirect(boolean redirect) {
this.redirect = redirect;
}
}ActionFactory改进
既然Xml配置文件换掉了，解析用的类自然也要换，原先内部所封装的Action，现在要替换成ActionDifinition。这个类是解析Xml文件的核心类，内部包含一个Map，用于存储Xml文件解析的Javabean。
public class ActionFactory {
private static Map<String, ActionDifinition> actions = new HashMap<>();
private static ActionFactory factory;
/**
* 在静态块儿中就开始解析配置文件
*/
static {
parseFile("/my_struts.xml");
System.out.println(actions.toString());
}
private ActionFactory() {
//这个类中构造器反而是最后才执行的
System.out.println("======================");
System.out.println("信息:ActionFactory is OK");
}
/**
* 单例模式,构造器私有化
*/
public static void init() {
if (factory == null) {
synchronized (ActionFactory.class) {
if (factory == null) {
factory = new ActionFactory();
}
}
}
}
public static ActionDifinition getAction(String actionName) throws Exception {
return actions.get(actionName);
}
/**
* 根据路径解析
*/
private static void parseFile(String path) {
try {
InputStream inputStream = ActionFactory.class.getResourceAsStream(path);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(inputStream);
NodeList beanNodeList = document.getElementsByTagName("action");
for (int i = 0; i < beanNodeList.getLength(); i++) {
Node bean = beanNodeList.item(i);
parseActionNodes(bean);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 解析Action
*/
private static void parseActionNodes(Node node) {
try {
Element element = (Element) node;
String name = element.getAttribute("name");
String className = element.getAttribute("class");
MyAction action = (MyAction) Class.forName(className).newInstance();
//往Map中加入ActionDifinition
ActionDifinition actionDifinition=new ActionDifinition();
actionDifinition.setAction(action);
//解析Result节点
parseResultNodes(actionDifinition, node);
actions.put(name, actionDifinition);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 解析Result节点
*/
private static void parseResultNodes(ActionDifinition actionDifinition, Node node) {
NodeList resultNodeList = node.getChildNodes();
for (int j = 0; j < resultNodeList.getLength(); j++) {
Node propertyNode = resultNodeList.item(j);
if (propertyNode.getNodeType() == Node.ELEMENT_NODE && "result".equals(propertyNode.getNodeName())) {
Element resultElement = (Element) propertyNode;
String name = resultElement.getAttribute("name");
String page = resultElement.getAttribute("page");
String redirectStr = resultElement.getAttribute("redirect");
boolean redirect = redirectStr != null && "true".equals(redirectStr);
Result result = new Result();
result.setName(name);
result.setPage(page);
result.setRedirect(redirect);
actionDifinition.putResult(name, result);
}
}
}
}*控制器（Servlet）
和原先差不多，因为代码都封装掉了，这里的逻辑依旧很简单，就和开始说得一样，解析客户端传来的Url，根据Url然后找到Action，执行Action的方法，根据方法执行的结果，判断要跳转到哪一个Jsp页面。
//urlPatterns拦截规则我替换成action了
@WebServlet(name = "PrepareAndExcuteServlet", urlPatterns = "/action/*")
public class PrepareAndExcuteServlet extends HttpServlet {
private static final long serialVersionUID = 1965314831568094829L;
/**
* 初始化的时候，顺带地把ActionFactory初始化好
*/
@Override
public void init() throws ServletException {
super.init();
ActionFactory.init();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
// 对解析URI进行调整
String pathInfo = request.getPathInfo();
int index = pathInfo.indexOf('!');
String actionUri = pathInfo.substring(1, index == -1 ? pathInfo.length() : index);
String resultUri = index == -1 ? null : pathInfo.substring(index + 1);
// 根据URI找到对应的ActionDifinition，ActionDifinition内部封装了Action和Result
ActionDifinition actionDifinition = ActionFactory.getAction(actionUri);
// 执行Action中的方法，并且获取返回值
String resultStr = actionDifinition.invoke(resultUri);
// 根据返回值，跳转指定的页面
Result result = actionDifinition.getResult(resultStr);
if (result.isRedirect()) {
response.sendRedirect("/" + result.getPage());
} else {
request.getRequestDispatcher("/" + result.getPage()).forward(request, response);
}
} catch (Exception e) {
e.printStackTrace();
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}测试效果：
hi.jsp代码我就不发了，下面是测试的结果，客户端发送请求要在结尾加上：“action/HiAction!add”，action是过滤标志，HiAction是我们希望调用的那个Action，而add是Action中的方法，感叹号作为分隔符。
最后呢，蛮发一下我的工程目录吧。
Action接收参数
要想实现Action接收客户端传来的参数，其实通过之前提到的IOC即可，给我们的Action添加属性，然后写它的Set方法，然后注入值即可，需要注意的就是编码问题。
下面是遍历请求体的参数列表的方法
Enumeration<String> map = request.getParameterNames();
while (map.hasMoreElements()) {
String param = (String) map.nextElement();
//Set方式注入值
setProperty(action, param, request.getParameter(param));
}
关于Set参数注入值的代码如下，其实这一段代码已经发过很多次了。
public void setProperty(Object instance, String name, String value) throws Exception {
Class<?> clazz = instance.getClass();
Method[] methods = clazz.getMethods();
for (Method method : methods) {
String methodName = method.getName();
if (("set" + name.substring(0, 1).toUpperCase() + name.substring(1)).equals(methodName)) {
System.out.println("methodName" + methodName);
method.invoke(instance, value);
}
}
}假如说我们的客户端会传来一个值，叫name，我们的Action想要接收这个值，我们的Action就要变成这样了：
public class HelloAction implements MyAction{
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public String excute() {
System.out.println("this is helloAction");
return ERROR;
}
}