深入理解Struts2原理之自己实现Struts2框架

作为struts2的初学者，有时候理解struts框架的原理，网上看教程会一头雾水，所以要是能自己体会实现struts框架的整个过程，对理解struts思路会更加清晰一些，下面就来尝试自己实现这个过程。

先看一下struts2的官方框架结构图

上面那个图好复杂，看不懂没关系，我们先简化一下过程方便理解，因为作为初学者不能一下子就实现了整个框架的所有功能，只能实现他的核心功能，如下图：

这样图就好看很多了，大概意思是我们发送的request请求先经过过滤器筛选，然后到达ActionInvocation，通过这个类加载拦截器，再去找到对应的action，再找到action要返回的jsp界面，然后响应（response）返回显示数据。
官方的图里有Actionproxy，这是个action代理对象，通过他找到ConfigManager读取配置文件然后发送需要的数据到ActionInvocation中，本文是自己实现struts框架，没必要弄的这么复杂，就把这部分融合到ActionInvocation中去了，其他部分就不介绍了，因为我也不懂是啥

---

下面实现过程，每一个类希望大家参考这个图边看边实现，这样才好理解

接下来要说的就是需要具备的技术:

1. XML解析,Xpath表达式.(dom4j)
2. Servlet技术
3. java内省(BeanUtils)(参数拦截器)
4. ThreadLocal线程本地化类
5. 递归调用

需要用到的jar包：
（jar其他版本的自己找了）
commons-beanutils-1.8.3.jar
commons-logging-1.1.1.jar
dom4j-1.6.1.jar
jaxen-1.1-beta-6.jar

步骤1：
创建web项目，然后导入jar包

步骤2：
创建struts.xml文件，放在src目录下

<?xml version="1.0" encoding="UTF-8" ?><struts>        <interceptor  class="com.test.interceptor.ParamInterceptor" />         <constant name="struts.action.extension" value="action" />        <action name="HelloAction" method="regist"                  class="com.test.action.HelloAction" >            <result name="success"  >/index.jsp</result>        </action>        <action name="registAction" method="regist"                     class="com.test.action.RegistAction" >            <result name="regist"  >/home.jsp</result>        </action></struts>

步骤3：
创建读取XML配置文件的解析类(ConfigurationManager)

public class ConfigurationManager {    /**     * 读取Interceptor     * @return     */    public static List<String> getInterceptors(){        List<String> interceptors = null;        //1创建解析器        SAXReader reader = new SAXReader();        //2.加载配置文件=>document        //获得配置文件流        InputStream is = ConfigurationManager.class.getResourceAsStream("/struts.xml");        Document doc = null;        try{            doc = reader.read(is);        }catch(DocumentException e){            e.printStackTrace();            throw new RuntimeException("配置文件加载失败！");        }        //3.书写xpath        String xpath = "//interceptor";        //4.根据xpath获得拦截器配置        List<Element> list = doc.selectNodes(xpath);        //5.将配置信息封装到list集合中        if(list != null && list.size()>0){            interceptors = new ArrayList<String>();            for(Element ele : list){                String className = ele.attributeValue("class");                interceptors.add(className);            }        }        //返回        return interceptors;    }    /**     * 读取action     * @return     */    public static Map<String,ActionConfig> getActionConfig() {        Map<String, ActionConfig> actionMap;        Document doc = getDocument();        String xpath = "//action";        List<Element> list = doc.selectNodes(xpath);        if(list == null || list.size() ==0){            return null;        }        actionMap = new HashMap<String,ActionConfig>();        for(Element e : list){            ActionConfig action = new ActionConfig();            action.setName(e.attributeValue("name"));            action.setClassName(e.attributeValue("class"));            String method = e.attributeValue("method");            action.setMethod(method==null||method.trim().equals("")?"execute":method);            List<Element> results = e.elements("result");            for(Element result : results){                action.getResult().put(result.attributeValue("name"), result.getText());            }            actionMap.put(action.getName(),action);        }        return actionMap;    }    private static Document getDocument()  {        Map<String,ActionConfig> actionMap =null;        //1创建解析器        SAXReader reader = new SAXReader();        //2.加载配置文件=>document        //获得配置文件流        InputStream is = ConfigurationManager.class.getResourceAsStream("/struts.xml");        Document doc;        try {            doc = reader.read(is);            return doc;        } catch (DocumentException e) {            e.printStackTrace();            throw new RuntimeException("加载配置文件失败!");        }    }    /**     * 读取constant     * @param key     * @return     */    public static String getConstant(String key) {        Document doc = getDocument();        String path = "//constant[@name='"+key+"']";        Element constant = (Element) doc.selectSingleNode(path);        if(constant!=null){            return constant.attributeValue("value");        }else{            return null;        }    }}

创建需要的ActionConfig类：

public class ActionConfig {    /**     * <action name="" method=""                         class="" >            <result name="success"  >/index.jsp</result>        </action>     */    private String name;//对应的是action中的name    private String method;//对应的是action中的method    private String className;//对应的是action中的class    private Map<String,String> result = new HashMap<String, String>();//对应的是action中的result    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getMethod() {        return method;    }    public void setMethod(String method) {        this.method = method;    }    public String getClassName() {        return className;    }    public void setClassName(String className) {        this.className = className;    }    public Map<String, String> getResult() {        return result;    }    public void setResult(Map<String, String> result) {        this.result = result;    }}

步骤4：
创建Struts2的数据中心(ActionContext)

public class ActionContext implements Serializable{    private static final long serialVersionUID = 1294441883362417229L;    //为了保证能获得ActionContext    public static ThreadLocal<ActionContext> tl = new ThreadLocal<ActionContext>();    ///用于存放各个域    private Map<String, Object> context;    public ActionContext(Map<String, Object> context) {        this.context = context;    }    public ActionContext(HttpServletRequest request,            HttpServletResponse response, Object action) {        // 准备域        context = new HashMap<String, Object>();        // 1.request        context.put(Constant.REQUEST, request);        // 2. response        context.put(Constant.RESPONSE, response);        // 3. param        context.put(Constant.PARAM, request.getParameterMap());        // 4.session        context.put(Constant.SESSION, request.getSession());        // 5.application        context.put(Constant.APPLICATION, request.getSession()                .getServletContext());        // ---------------------------------------------------        // 6.valuestack 值栈        ValueStack vs = new ValueStack();        // 将action压入栈顶        vs.push(action);        // 将值栈放入request域        request.setAttribute(Constant.VALUE_STACK, vs);        // 将值栈放入数据中心        context.put(Constant.VALUE_STACK, vs);        // -----------------------------------------------------------------        tl.set(this);    }    //下面提供域的获取方法    public HttpServletRequest getRequest() {        return (HttpServletRequest) context.get(Constant.REQUEST);    }    public HttpServletResponse getResponse() {        return (HttpServletResponse) context.get(Constant.RESPONSE);    }    public HttpSession getSession() {        return (HttpSession) context.get(Constant.SESSION);    }    public ServletContext getApplication() {        return (ServletContext) context.get(Constant.APPLICATION);    }    public Map<String, String[]> getParam() {        return (Map<String, String[]>) context.get(Constant.PARAM);    }    public ValueStack getStack() {        return (ValueStack) context.get(Constant.VALUE_STACK);    }    public static ActionContext getActionContext(){        return tl.get();    }    ｝

需要用到的类(Constant )：

public class Constant {    /**     * request域     */    public static final String REQUEST = "com.test.request";    /**     * response域     */    public static final String RESPONSE = "com.test.response";    /**     * session域     */    public static final String SESSION = "com.test.session";    /**     * application域     */    public static final String APPLICATION = "com.test.application";    /**     * param域     */    public static final String PARAM = "com.test.param";    /**     * value_stack域     */    public static final String VALUE_STACK = "com.test.stack";}

需要用到的类（值栈）：

public class ValueStack {    private List<Object> list = new ArrayList<Object>();    //弹栈    public Object pop(){        return list.remove(0);    }    //压栈    public void push(Object o){        list.add(0, o);    }    //取出顶部对象    public Object seek(){        return list.get(0);    }}

需要用到的接口（Interceptor）：

public interface Interceptor extends Serializable{    /**     * 初始化     */    public void init();    /**     * 拦截     * @param invocation     * @return     */    public String interceptor(ActionInvocation invocation);    /**     * 销毁     */    public void destory();}

步骤5：
创建ActionInvocation
ActionInvocation负责完成拦截器链状调用以及action调用,以及数据中心(ActionContext)的提供

public class ActionInvocation {    //过滤器链    private Iterator<Interceptor> interceptors;    //即将调用的action实例    private Object action;    //action配置信息    private ActionConfig config;    //数据中心    private ActionContext ac;    public ActionInvocation(List<String> InterceptorClassNames,ActionConfig config,HttpServletRequest request,HttpServletResponse response) {        //1 准备Interceptor链        List<Interceptor> interceptorList = null;        if(InterceptorClassNames!=null && InterceptorClassNames.size()>0){             interceptorList = new ArrayList<Interceptor>();            for(String className : InterceptorClassNames){                Interceptor interceptor;                try {                    //获取实例                    interceptor = (Interceptor) Class.forName(className).newInstance();                    interceptor.init();//初始化                } catch (Exception e) {                    e.printStackTrace();                    throw new RuntimeException("创建Interceptor失败!!"+className);                }                 interceptorList.add(interceptor);            }            this.interceptors = interceptorList.iterator();        }        //2 准备action实例        this.config = config;        try {            action = Class.forName(config.getClassName()).newInstance();//获取action对象        } catch (Exception e) {            e.printStackTrace();            throw new RuntimeException("action创建失败!"+config.getClassName());        }         //3 准备数据中心actionContext         ac = new ActionContext(request, response, action);    }    public ActionContext getActionContext() {        return ac;    }    /**     * 递归调用拦截器链     * @param invocation     * @return     */    public String invoke(ActionInvocation invocation){        //1 准备一个变量接受action运行结果的路由串        String result = null;        //2 判断拦截器链中是否有下一个拦截器&&变量是否被赋值        if(interceptors!= null  && interceptors.hasNext() && result==null ){            //有=>调用下一个拦截的拦截方法            Interceptor it = interceptors.next();            result = it.interceptor(invocation);        }else{            //没有=> 调用action实例的处理方法            //获得将要调用的action方法名称            String methodName = config.getMethod(); // execute            //根据action对象和方法名称获得方法对应的Method对象            try {                Method executeMethod = action.getClass().getMethod(methodName);                //调用目标方法                result = (String) executeMethod.invoke(action);            } catch (Exception e) {                e.printStackTrace();                throw new RuntimeException("您配置的action方法不存在!");            }         }        //3将action的结果路由串返回        return result;    }

步骤6：
创建StrutsPrepareAndExecuteFilter 过滤器类：

public class StrutsPrepareAndExcuteFilter implements Filter{    //配置文件中的过滤器配置信息    private List<String> InterceptorList;    //struts处理的action后缀    private String extension;    // 配置文件中action配置信息    private Map<String, ActionConfig> actionConfigs;    /**     * 初始化     */    public void init(FilterConfig arg0) throws ServletException {        //1> 准备过滤器链配置        InterceptorList = ConfigurationManager.getInterceptors();        //2> 准备constant配置=> 访问后缀的配置信息        extension = ConfigurationManager.getConstant("struts.action.extension");        //3> 加载action配置        actionConfigs = ConfigurationManager.getActionConfig();    }    /**     * 过滤器处理     */    public void doFilter(ServletRequest request, ServletResponse response,            FilterChain chain) throws IOException, ServletException {        //0  强转request和response为 HttpServletRequest 和 HttpServletResponse        HttpServletRequest req = (HttpServletRequest) request;        HttpServletResponse  resp = (HttpServletResponse) response;        //1 获得请求路径        // http://localhost:8080/MyStruts/HellAction.action        String path = req.getServletPath(); //  /HellAction.action        //2 判断请求是否需要访问action            if(!path.endsWith(extension)){                // 后缀不以".action"结尾 => 不需要访问action资源 => chain.doFIlter()放行                chain.doFilter(request, response);                return;            }else{                // 后缀以".action"结尾 => 需要访问action                 //3 获得需要访问的action名称=>提取需要访问的action名称                path = path.substring(1);// HellAction.action                path = path.replace("."+extension, "");// HellAction                //4 查找action对应的配置信息                ActionConfig config = actionConfigs.get(path);                if(config == null){                    //未找到配置信息 => 抛出异常提示访问的action不存在                    throw new RuntimeException("访问的action不存在!");                }                //找到配置信息  => 获得到配置信息=>继续                //5 创建actionInvocation实例,完成对拦截器器链以及action的方法                ActionInvocation invocation = new ActionInvocation(InterceptorList,config,req,resp);                //6 获得结果串                 String result = invocation.invoke(invocation); //success                //7 从配置信息找到结果串对应的路径                String dispatcherPath = config.getResult().get(result);                //找不到结果路径=> 抛出异常提示返回的路径找不到对应页面                if(dispatcherPath ==null || "".equals(dispatcherPath)){                    throw new RuntimeException("您要访问的结果没有找到配置!");                }                //8 将请求转发到配置的路径                req.getRequestDispatcher(dispatcherPath).forward(req, resp);                //释放资源                ActionContext.tl.remove();            }    }    /**     * 销毁     */    public void destroy() {        // TODO Auto-generated method stub    }}

步骤7：
将Filter配置到web.xml中

步骤8：
struts经典之参数封装拦截器创建：
以后自己写的每一个拦截器操作步骤都是这样的

public class ParamInterceptor implements Interceptor{       public void init() {        }    public String interceptor(ActionInvocation invocation) {        //1 获得参数        //2 获得action对象        //ActionContext ac = ActionContext.getActionContext().getStack();//第一种获得ActionContext对象        ActionContext ac =  invocation.getActionContext();//第二种获得ActionContext对象        ValueStack vs = ac.getStack();        Object action = vs.seek();        //3 封装        try {            BeanUtils.populate(action, ac.getRequest().getParameterMap());        } catch (IllegalAccessException e) {            e.printStackTrace();        } catch (InvocationTargetException e) {            e.printStackTrace();        }        //4 放行        return invocation.invoke(invocation);    }    public void destory() {    }}

然后在struts.xml里加上：

<interceptor  class="com.test.interceptor.ParamInterceptor" /> 

---

测试一：
新建一个action：
地址栏测试get请求

public class HelloAction {    private String name;    private String password;    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String execute(){                System.out.println("hello world!"+name+"==>"+password);             return "success";    }}

然后在struts.xml里配置对应的action：

<action name="HelloAction" method="execute"                         class="com.test.action.HelloAction" >            <result name="success"  >/index.jsp</result>        </action>

把项目部署到tomcat运行起来，然后在浏览器地址栏输入
http://localhost:8080/MyStruts2/HelloAction.action?name=marry&password=123456

会看到控制台输出

测试二：
表单（post）提交数据返回界面
新建一个RegistAction：

public class RegistAction implements Serializable{    private static final long serialVersionUID = -793621223468025885L;      private String name;    private String password;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    public String regist(){        System.out.println("注册的用户名：" + name+" ==> 密码："+password);    ActionContext.getActionContext().getRequest().setAttribute("name", name);        return "regist";    } }

然后在struts.xml里配置对于的action：

<action name="registAction" method="regist"                         class="com.test.action.RegistAction" >            <result name="regist"  >/home.jsp</result>        </action>

再创建一个regist.jsp，下面是body的代码：

<body>    <form action="registAction.action" method="post">    <table>    <tr>    <td>用户名：</td>    <td><input type="text" id="name" name="name"></td>    </tr>    <tr>    <td>密码：</td>    <td><input type="password" id="password" name="password"></td>    </tr>     <tr>      <td colspan="2"><input type="submit" value="提交"></td>    </tr>    </table>       </form>  </body>

然后创建一个home.jsp，下面是body的代码：

<body>    欢迎您：${requestScope.name}  </body>

最后部署到tomcat运行起来
在浏览器访问地址：

输入参数后，运行结果如下：

到此说明已经成功实现了
下面是整个项目的结构图：

本文的源码地址：
http://download.csdn.net/detail/u014204541/9842176

写在最后，本文可能存在不足之处，但愿大神看到后有不足之处可以提出，方便后期学习，如果实现过程看不懂，建议多看图，边看边实现这个过程。