手动的写一个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