手动的写一个structs

为了更好的学习框架的运行机制，这里开始学习框架之前，介绍一个简单的自定义的框架。

需求：

　　登录：id：aaa，pwd:888登录成功之后，跳转到，index.jsp页面并显示，欢迎你，aaa

　　注册，页面，输入用户名密码，点击注册。注册成功之后，将会跳转到登录界面。

　　重在了解前后的这个逻辑，所以把后天是写死的。

entity层

　　就一个User

package cn.itcast.entity;

public class User {

    private String name;
    private String pwd;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

}

接着是到层

　　就一个UserDao，模拟了注册，登录，没有都是写死的

 package cn.itcast.dao;

 import cn.itcast.entity.User;

 public class UserDao {

     // 模拟登陆
     public User login(User user){
         if ("tom".equals(user.getName()) && "888".equals(user.getPwd()) ){
             // 登陆成功
             return user;
         }
         // 登陆失败
         return null;
     }

     // 模拟注册
     public void register(User user) {
         System.out.println("注册成功：用户，" + user.getName());
     }
 }

service层还和以前一样，没有什么区别，直接使用就可以了这里也就一个UserService

 package cn.itcast.service;

 import cn.itcast.dao.UserDao;
 import cn.itcast.entity.User;

 public class UserService {

     private UserDao ud = new UserDao();

     // 模拟登陆
     public User login(User user){
         return ud.login(user);
     }

     // 模拟注册
     public void register(User user) {
         ud.register(user);
     }
 }

framewoek层，

　　这是手动缩写的这个，mystructs的核心部分。

　　以往在ervlet层中写servlet，反观一下，servlet层在mvc中负责control的角色：获取参数，调用service，跳转页面。无非就这三大块。

　　不同的页面请求提交到不同的servt，但最终从宏观上来说无非是上面的三块内容。于是我们想做到的是，值写一个servlet这里我们命名为ActionServlet，这个类的功能，就是统筹全局请求的分配，针对比如像http:localhost:8080/mystucets/login.action的请求，ActionServlet解析出login，把这个请求，交给LoginAction类处理，类似于register.action的请求交给对应的RegisterAction处理。　　

　　要想完成这种准确无误的转发关系，或者说是一种映射。那么ActionServlet要一个根据，这个根据就是一个ActionSerlet可以查找的表。我们先来看一个，上面设想的架构的时序流

1.就收请求，http:localhost:8080/mystucets/login.action，解析出login

2。转发给LoginAction处理，LoginAction调用login（）方法，这个方法执行完成之后返回一个returnFlag标志，loginSuccess表示登陆成功，loginFial表示登录失败，

3.ActionServlet根据返回的returnFlag判断跳转的页面，当然要先查询配置（映射表）文件，获取对应的跳转page，以及跳转的方式（转发或者重定向）

我们需要一个配置文件，这个配置文件是一个xml文件，这个文件我们根据，login或者register找到所对应的Action类，进一步找到跳转的可能，设计这个mystructs.xml的配置文件如下:

 <?xml version="1.0" encoding="UTF-8"?>
 <mystruts>
     <package>
         <!-- 配置请求路径，与处理action类的关系 -->
         <!--
             1. 请求路径与处理Action的关系
                  /login = LoginAction                          login
                         success = /index.jsp                     登陆成功(重定向)
                         loginFaild  = /login.jsp                 登陆失败

          -->
         <action name="login" class="cn.itcast.framework.action.LoginAction" method="login">
             <result name="loginSuccess" type="redirect">/index.jsp</result>
             <result name="loginFaild">/login.jsp</result>
         </action>

         <action name="register" class="cn.itcast.framework.action.RegisterAction" method="register">
             <result name="registerSuccess">/login</result>
         </action>

     </package>

 </mystruts>

　　对于一个项目而言，要处理的请求有很多，也就说有很多的XxxAction，这是需要我们，那么对应的mystructs.xml文件就会很大，我们不会每次都来查找解析这个xml文件，而且对于需要同时管理很多信息时，常见的做法是把这若干信息封装到一些bean中，讲分页的时候已经使用过这种策略了。每个<action>封装到对应的ActionMapping类中，每个<result>封装到Result类中，因为每个<action>中包含若干的<result>所以每个ActionMapping总包含若干的<Result>。ActionMapping和Result的设计如下：

ActionMapping：

 package cn.itcast.framework.bean;

 import java.util.Map;

 /**
  * 封装action节点
  *      <action name="login" class="cn.itcast.framework.action.LoginAction" method="login">
             <result name="success" type="redirect">/index.jsp</result>
             <result name="loginFaild">/login.jsp</result>
         </action>

  * @author Jie.Yuan
  *
  */
 public class ActionMapping {

     // 请求路径名称
     private String name;
     // 处理aciton类的全名
     private String className;
     // 处理方法
     private String method;
     // 结果视图集合
     private Map<String,Result> results;

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getClassName() {
         return className;
     }
     public void setClassName(String className) {
         this.className = className;
     }
     public String getMethod() {
         return method;
     }
     public void setMethod(String method) {
         this.method = method;
     }
     public Map<String, Result> getResults() {
         return results;
     }
     public void setResults(Map<String, Result> results) {
         this.results = results;
     }

 }

Result：

 package cn.itcast.framework.bean;

 /**
  * 封装结果视图
  * <result name="success" type="redirect">/index.jsp</result>
  * @author Jie.Yuan
  *
  */
 public class Result {

     // 跳转的结果标记
     private String name;
     // 跳转类型，默认为转发； "redirect"为重定向
     private String type;
     // 跳转的页面
     private String page;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getType() {
         return type;
     }
     public void setType(String type) {
         this.type = type;
     }
     public String getPage() {
         return page;
     }
     public void setPage(String page) {
         this.page = page;
     }

 }

为了避免每次查询mystructs.xml问价（这样使很消耗时间的），我们的做法是在首次访问ActionServlet的时候，也就是在ActionServlet的init（）函数中把mystructs.xml中的内容全部读取出来（在后面的ActionServlet的代码可以看到），读取出来之后我们使用一个ActionMappingManager进行管理，下面是ActionMappingManager类：

 package cn.itcast.framework.bean;

 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.dom4j.Document;
 import org.dom4j.Element;
 import org.dom4j.io.SAXReader;

 /**
  * 加载配置文件, 封装所有的真个mystruts.xml
  * @author Jie.Yuan
  *
  */
 public class ActionMappingManager {

     // 保存action的集合
     private Map<String,ActionMapping> allActions ;

     public ActionMappingManager(){
         allActions = new HashMap<String,ActionMapping>();
         // 初始化
         this.init();
     }

     /**
      * 根据请求路径名称，返回Action的映射对象
      * @param actionName   当前请求路径
      * @return             返回配置文件中代表action节点的AcitonMapping对象
      */
     public ActionMapping getActionMapping(String actionName) {
         if (actionName == null) {
             throw new RuntimeException("传入参数有误，请查看struts.xml配置的路径。");
         }

         ActionMapping actionMapping = allActions.get(actionName);
         if (actionMapping == null) {
             throw new RuntimeException("路径在struts.xml中找不到，请检查");
         }
         return actionMapping;
     }

     // 初始化allActions集合
     private void init() {
         /********DOM4J读取配置文件***********/
         try {
             // 1. 得到解析器
             SAXReader reader = new SAXReader();
             // 得到src/mystruts.xml  文件流
             InputStream inStream = this.getClass().getResourceAsStream("/mystruts.xml");
             // 2. 加载文件
             Document doc = reader.read(inStream);

             // 3. 获取根
             Element root = doc.getRootElement();

             // 4. 得到package节点
             Element ele_package = root.element("package");

             // 5. 得到package节点下，  所有的action子节点
             List<Element> listAction = ele_package.elements("action");

             // 6.遍历 ，封装
             for (Element ele_action : listAction) {
                 // 6.1 封装一个ActionMapping对象
                 ActionMapping actionMapping = new ActionMapping();
                 actionMapping.setName(ele_action.attributeValue("name"));
                 actionMapping.setClassName(ele_action.attributeValue("class"));
                 actionMapping.setMethod(ele_action.attributeValue("method"));

                 // 6.2 封装当前aciton节点下所有的结果视图
                 Map<String,Result> results = new HashMap<String, Result>();

                 // 得到当前action节点下所有的result子节点
                  Iterator<Element> it = ele_action.elementIterator("result");
                  while (it.hasNext()) {
                      // 当前迭代的每一个元素都是 <result...>
                      Element ele_result = it.next();

                      // 封装对象
                      Result res = new Result();
                      res.setName(ele_result.attributeValue("name"));
                      res.setType(ele_result.attributeValue("type"));
                      res.setPage(ele_result.getTextTrim());

                      // 添加到集合
                      results.put(res.getName(), res);
                  }

                 // 设置到actionMapping中
                 actionMapping.setResults(results);

                 // 6.x actionMapping添加到map集合
                 allActions.put(actionMapping.getName(), actionMapping);
             }

         } catch (Exception e) {
             throw new RuntimeException("启动时候初始化错误",e);
         }
     }
 }

　　我们说了，ActionServlet位居中枢相当于行军主将，居中调遣需要冲锋陷阵的士卒（XxxAction），这里就是LoginAction和RegisterAction，下面是他们的定义：

　　LoginAction：

 package cn.itcast.framework.action;

 import java.io.IOException;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import cn.itcast.entity.User;
 import cn.itcast.service.UserService;

 /**
  * Action表示动作类 1. 一个servlet对应一个action 2. action中负责处理具体的请求
  *
  * @author Jie.Yuan
  *
  */
 public class LoginAction {

     public Object execute(HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
         return null;
     }

     /**
      * 处理登陆请求
      */
     public Object login(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         Object uri = null;

         // 1. 获取请求数据，封装
         String name = request.getParameter("name");
         String pwd = request.getParameter("pwd");
         User user = new User();
         user.setName(name);
         user.setPwd(pwd);

         // 2. 调用Service
         UserService userService = new UserService();
         User userInfo = userService.login(user);
         // 3. 跳转
         if (userInfo == null) {
             // 登陆失败
 //            request.getRequestDispatcher("/login.jsp").forward(request,
 //                    response);
 //            uri = request.getRequestDispatcher("/login.jsp");
             uri = "loginFaild";   // loginFaild  = /login.jsp
         } else {
             // 登陆成功
             request.getSession().setAttribute("userInfo", userInfo);
             // 首页
 //            response.sendRedirect(request.getContextPath() + "/index.jsp");
 //            uri = "/index.jsp";
             uri = "loginSuccess";  // loginSuccess = /index.jsp
         }
         return uri;
     }
 }

　　Register类：

package cn.itcast.framework.action;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.itcast.entity.User;
import cn.itcast.service.UserService;

public class RegisterAction {

    public Object register(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Object uri;

        // 1. 获取请求数据，封装
        String name = request.getParameter("name");
        String pwd = request.getParameter("pwd");
        User user = new User();
        user.setName(name);
        user.setPwd(pwd);

        // 2. 调用Service
        UserService userService = new UserService();
        userService.register(user);
        // 3. 跳转
//        request.getRequestDispatcher("/login.jsp").forward(request, response);
        //uri = request.getRequestDispatcher("/login.jsp");
        return "registerSuccess"; //返回注册的标记；   registerSuccess = /login.jsp

    }
}

　　中军主帅ActionServlet类：

 package cn.itcast.framework;

 import java.io.IOException;
 import java.lang.reflect.Method;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import cn.itcast.framework.bean.ActionMapping;
 import cn.itcast.framework.bean.ActionMappingManager;
 import cn.itcast.framework.bean.Result;

 /**
  * 核心控制器,此项目只有这一个servlet
  * 1. 拦截所有的*.action为后缀的请求
  * 2. 请求:http://localhost:8080/mystruts/login.action
  *           http://localhost:8080/mystruts/register.action

  * @author Jie.Yuan
  *
  */
 public class ActionServlet extends HttpServlet{

     private ActionMappingManager actionMappingManager;

     // 只执行一次  (希望启动时候执行)
     @Override
     public void init() throws ServletException {
         System.out.println("1111111111111111ActionServlet.init()");
         actionMappingManager = new ActionMappingManager();
     }

     // http://localhost:8080/mystruts/login.action
     @Override
     protected void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {

         try {
             // 1. 获取请求uri, 得到请求路径名称   【login】
             String uri = request.getRequestURI();
             // 得到 login
             String actionName=uri.substring(uri.lastIndexOf("/")+1, uri.indexOf(".action"));

             // 2. 根据路径名称，读取配置文件，得到类的全名   【cn..action.LoginAction】
             ActionMapping actionMapping = actionMappingManager.getActionMapping(actionName);
             String className = actionMapping.getClassName();

             // 当前请求的处理方法   【method="login"】
             String method = actionMapping.getMethod();

             // 3. 反射： 创建对象，调用方法； 获取方法返回的标记
             Class<?> clazz = Class.forName(className);
             Object obj = clazz.newInstance();  //LoginAction loginAction = new LoginAction();
             Method m = clazz.getDeclaredMethod(method, HttpServletRequest.class,HttpServletResponse.class );
             // 调用方法返回的标记
             String returnFlag =  (String) m.invoke(obj, request, response);

             // 4. 拿到标记，读取配置文件得到标记对应的页面 、 跳转类型
             Result result = actionMapping.getResults().get(returnFlag);
             // 类型
             String type = result.getType();
             // 页面
             String page = result.getPage();

             // 跳转
             if ("redirect".equals(type)) {
                 response.sendRedirect(request.getContextPath() + page);
             } else {
                 request.getRequestDispatcher(page).forward(request, response);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
             throws ServletException, IOException {
         doGet(req, resp);
     }
 }

注意了，这里只有一个ActionServlet处理所有的页面请求，将处理所有的http:localhost:8080/mystructs/*.action请求，那么就要在web.xml中配置ActionServlet的<pattern-url>时使用模糊匹配具体如下：

 <!-- 核心控制器 -->
   <servlet>
     <servlet-name>ActionServlet</servlet-name>
     <servlet-class>cn.itcast.framework.ActionServlet</servlet-class>
     <!-- 启动时候执行servlet初始化方法 -->
     <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
     <servlet-name>ActionServlet</servlet-name>
     <url-pattern>*.action</url-pattern>
   </servlet-mapping>

为了保证启动时执行ActionServlet的init(）方法，还用了一个参数<load-on-startup>1</load-on-startup>，使用这个参数，init函数将会在启动服务器之后调用，不然的第一次访问ActionServlet，ActionServlet创建对象时才会执行init函数。

到这里，这个简单的模拟项目就结束了，就可以开始测试了。我们访问http://localhost:8080/mystructs/login.jsp,然后输入用户名aaa和密码888，点击登录于是请求login.action,然后跳转到index.jsp页面看到欢迎你，aaa