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

需求:

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

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

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

entity层

  就一个User

  1. package cn.itcast.entity;
  2.  
  3. public class User {
  4.  
  5. private String name;
  6. private String pwd;
  7. public String getName() {
  8. return name;
  9. }
  10. public void setName(String name) {
  11. this.name = name;
  12. }
  13. public String getPwd() {
  14. return pwd;
  15. }
  16. public void setPwd(String pwd) {
  17. this.pwd = pwd;
  18. }
  19.  
  20. }

接着是到层

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

  1. package cn.itcast.dao;
  2.  
  3. import cn.itcast.entity.User;
  4.  
  5. public class UserDao {
  6.  
  7. // 模拟登陆
  8. public User login(User user){
  9. if ("tom".equals(user.getName()) && "888".equals(user.getPwd()) ){
  10. // 登陆成功
  11. return user;
  12. }
  13. // 登陆失败
  14. return null;
  15. }
  16.  
  17. // 模拟注册
  18. public void register(User user) {
  19. System.out.println("注册成功:用户," + user.getName());
  20. }
  21. }

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

  1. package cn.itcast.service;
  2.  
  3. import cn.itcast.dao.UserDao;
  4. import cn.itcast.entity.User;
  5.  
  6. public class UserService {
  7.  
  8. private UserDao ud = new UserDao();
  9.  
  10. // 模拟登陆
  11. public User login(User user){
  12. return ud.login(user);
  13. }
  14.  
  15. // 模拟注册
  16. public void register(User user) {
  17. ud.register(user);
  18. }
  19. }

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的配置文件如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <mystruts>
  3. <package>
  4. <!-- 配置请求路径,与处理action类的关系 -->
  5. <!--
  6. 1. 请求路径与处理Action的关系
  7. /login = LoginAction login
  8. success = /index.jsp 登陆成功(重定向)
  9. loginFaild = /login.jsp 登陆失败
  10.  
  11. -->
  12. <action name="login" class="cn.itcast.framework.action.LoginAction" method="login">
  13. <result name="loginSuccess" type="redirect">/index.jsp</result>
  14. <result name="loginFaild">/login.jsp</result>
  15. </action>
  16.  
  17. <action name="register" class="cn.itcast.framework.action.RegisterAction" method="register">
  18. <result name="registerSuccess">/login</result>
  19. </action>
  20.  
  21. </package>
  22.  
  23. </mystruts>

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

ActionMapping:

  1. package cn.itcast.framework.bean;
  2.  
  3. import java.util.Map;
  4.  
  5. /**
  6. * 封装action节点
  7. * <action name="login" class="cn.itcast.framework.action.LoginAction" method="login">
  8. <result name="success" type="redirect">/index.jsp</result>
  9. <result name="loginFaild">/login.jsp</result>
  10. </action>
  11.  
  12. * @author Jie.Yuan
  13. *
  14. */
  15. public class ActionMapping {
  16.  
  17. // 请求路径名称
  18. private String name;
  19. // 处理aciton类的全名
  20. private String className;
  21. // 处理方法
  22. private String method;
  23. // 结果视图集合
  24. private Map<String,Result> results;
  25.  
  26. public String getName() {
  27. return name;
  28. }
  29. public void setName(String name) {
  30. this.name = name;
  31. }
  32. public String getClassName() {
  33. return className;
  34. }
  35. public void setClassName(String className) {
  36. this.className = className;
  37. }
  38. public String getMethod() {
  39. return method;
  40. }
  41. public void setMethod(String method) {
  42. this.method = method;
  43. }
  44. public Map<String, Result> getResults() {
  45. return results;
  46. }
  47. public void setResults(Map<String, Result> results) {
  48. this.results = results;
  49. }
  50.  
  51. }

Result:

  1. package cn.itcast.framework.bean;
  2.  
  3. /**
  4. * 封装结果视图
  5. * <result name="success" type="redirect">/index.jsp</result>
  6. * @author Jie.Yuan
  7. *
  8. */
  9. public class Result {
  10.  
  11. // 跳转的结果标记
  12. private String name;
  13. // 跳转类型,默认为转发; "redirect"为重定向
  14. private String type;
  15. // 跳转的页面
  16. private String page;
  17. public String getName() {
  18. return name;
  19. }
  20. public void setName(String name) {
  21. this.name = name;
  22. }
  23. public String getType() {
  24. return type;
  25. }
  26. public void setType(String type) {
  27. this.type = type;
  28. }
  29. public String getPage() {
  30. return page;
  31. }
  32. public void setPage(String page) {
  33. this.page = page;
  34. }
  35.  
  36. }

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

  1. package cn.itcast.framework.bean;
  2.  
  3. import java.io.InputStream;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8.  
  9. import org.dom4j.Document;
  10. import org.dom4j.Element;
  11. import org.dom4j.io.SAXReader;
  12.  
  13. /**
  14. * 加载配置文件, 封装所有的真个mystruts.xml
  15. * @author Jie.Yuan
  16. *
  17. */
  18. public class ActionMappingManager {
  19.  
  20. // 保存action的集合
  21. private Map<String,ActionMapping> allActions ;
  22.  
  23. public ActionMappingManager(){
  24. allActions = new HashMap<String,ActionMapping>();
  25. // 初始化
  26. this.init();
  27. }
  28.  
  29. /**
  30. * 根据请求路径名称,返回Action的映射对象
  31. * @param actionName 当前请求路径
  32. * @return 返回配置文件中代表action节点的AcitonMapping对象
  33. */
  34. public ActionMapping getActionMapping(String actionName) {
  35. if (actionName == null) {
  36. throw new RuntimeException("传入参数有误,请查看struts.xml配置的路径。");
  37. }
  38.  
  39. ActionMapping actionMapping = allActions.get(actionName);
  40. if (actionMapping == null) {
  41. throw new RuntimeException("路径在struts.xml中找不到,请检查");
  42. }
  43. return actionMapping;
  44. }
  45.  
  46. // 初始化allActions集合
  47. private void init() {
  48. /********DOM4J读取配置文件***********/
  49. try {
  50. // 1. 得到解析器
  51. SAXReader reader = new SAXReader();
  52. // 得到src/mystruts.xml 文件流
  53. InputStream inStream = this.getClass().getResourceAsStream("/mystruts.xml");
  54. // 2. 加载文件
  55. Document doc = reader.read(inStream);
  56.  
  57. // 3. 获取根
  58. Element root = doc.getRootElement();
  59.  
  60. // 4. 得到package节点
  61. Element ele_package = root.element("package");
  62.  
  63. // 5. 得到package节点下, 所有的action子节点
  64. List<Element> listAction = ele_package.elements("action");
  65.  
  66. // 6.遍历 ,封装
  67. for (Element ele_action : listAction) {
  68. // 6.1 封装一个ActionMapping对象
  69. ActionMapping actionMapping = new ActionMapping();
  70. actionMapping.setName(ele_action.attributeValue("name"));
  71. actionMapping.setClassName(ele_action.attributeValue("class"));
  72. actionMapping.setMethod(ele_action.attributeValue("method"));
  73.  
  74. // 6.2 封装当前aciton节点下所有的结果视图
  75. Map<String,Result> results = new HashMap<String, Result>();
  76.  
  77. // 得到当前action节点下所有的result子节点
  78. Iterator<Element> it = ele_action.elementIterator("result");
  79. while (it.hasNext()) {
  80. // 当前迭代的每一个元素都是 <result...>
  81. Element ele_result = it.next();
  82.  
  83. // 封装对象
  84. Result res = new Result();
  85. res.setName(ele_result.attributeValue("name"));
  86. res.setType(ele_result.attributeValue("type"));
  87. res.setPage(ele_result.getTextTrim());
  88.  
  89. // 添加到集合
  90. results.put(res.getName(), res);
  91. }
  92.  
  93. // 设置到actionMapping中
  94. actionMapping.setResults(results);
  95.  
  96. // 6.x actionMapping添加到map集合
  97. allActions.put(actionMapping.getName(), actionMapping);
  98. }
  99.  
  100. } catch (Exception e) {
  101. throw new RuntimeException("启动时候初始化错误",e);
  102. }
  103. }
  104. }

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

  LoginAction:

  1. package cn.itcast.framework.action;
  2.  
  3. import java.io.IOException;
  4.  
  5. import javax.servlet.ServletException;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8.  
  9. import cn.itcast.entity.User;
  10. import cn.itcast.service.UserService;
  11.  
  12. /**
  13. * Action表示动作类 1. 一个servlet对应一个action 2. action中负责处理具体的请求
  14. *
  15. * @author Jie.Yuan
  16. *
  17. */
  18. public class LoginAction {
  19.  
  20. public Object execute(HttpServletRequest request, HttpServletResponse response)
  21. throws ServletException, IOException {
  22. return null;
  23. }
  24.  
  25. /**
  26. * 处理登陆请求
  27. */
  28. public Object login(HttpServletRequest request, HttpServletResponse response)
  29. throws ServletException, IOException {
  30. Object uri = null;
  31.  
  32. // 1. 获取请求数据,封装
  33. String name = request.getParameter("name");
  34. String pwd = request.getParameter("pwd");
  35. User user = new User();
  36. user.setName(name);
  37. user.setPwd(pwd);
  38.  
  39. // 2. 调用Service
  40. UserService userService = new UserService();
  41. User userInfo = userService.login(user);
  42. // 3. 跳转
  43. if (userInfo == null) {
  44. // 登陆失败
  45. // request.getRequestDispatcher("/login.jsp").forward(request,
  46. // response);
  47. // uri = request.getRequestDispatcher("/login.jsp");
  48. uri = "loginFaild"; // loginFaild = /login.jsp
  49. } else {
  50. // 登陆成功
  51. request.getSession().setAttribute("userInfo", userInfo);
  52. // 首页
  53. // response.sendRedirect(request.getContextPath() + "/index.jsp");
  54. // uri = "/index.jsp";
  55. uri = "loginSuccess"; // loginSuccess = /index.jsp
  56. }
  57. return uri;
  58. }
  59. }

  Register类:

  1. package cn.itcast.framework.action;
  2.  
  3. import java.io.IOException;
  4.  
  5. import javax.servlet.ServletException;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8.  
  9. import cn.itcast.entity.User;
  10. import cn.itcast.service.UserService;
  11.  
  12. public class RegisterAction {
  13.  
  14. public Object register(HttpServletRequest request, HttpServletResponse response)
  15. throws ServletException, IOException {
  16. Object uri;
  17.  
  18. // 1. 获取请求数据,封装
  19. String name = request.getParameter("name");
  20. String pwd = request.getParameter("pwd");
  21. User user = new User();
  22. user.setName(name);
  23. user.setPwd(pwd);
  24.  
  25. // 2. 调用Service
  26. UserService userService = new UserService();
  27. userService.register(user);
  28. // 3. 跳转
  29. // request.getRequestDispatcher("/login.jsp").forward(request, response);
  30. //uri = request.getRequestDispatcher("/login.jsp");
  31. return "registerSuccess"; //返回注册的标记; registerSuccess = /login.jsp
  32.  
  33. }
  34. }

  中军主帅ActionServlet类:

  1. package cn.itcast.framework;
  2.  
  3. import java.io.IOException;
  4. import java.lang.reflect.Method;
  5.  
  6. import javax.servlet.ServletException;
  7. import javax.servlet.http.HttpServlet;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10.  
  11. import cn.itcast.framework.bean.ActionMapping;
  12. import cn.itcast.framework.bean.ActionMappingManager;
  13. import cn.itcast.framework.bean.Result;
  14.  
  15. /**
  16. * 核心控制器,此项目只有这一个servlet
  17. * 1. 拦截所有的*.action为后缀的请求
  18. * 2. 请求:http://localhost:8080/mystruts/login.action
  19. * http://localhost:8080/mystruts/register.action
  20.  
  21. * @author Jie.Yuan
  22. *
  23. */
  24. public class ActionServlet extends HttpServlet{
  25.  
  26. private ActionMappingManager actionMappingManager;
  27.  
  28. // 只执行一次 (希望启动时候执行)
  29. @Override
  30. public void init() throws ServletException {
  31. System.out.println("1111111111111111ActionServlet.init()");
  32. actionMappingManager = new ActionMappingManager();
  33. }
  34.  
  35. // http://localhost:8080/mystruts/login.action
  36. @Override
  37. protected void doGet(HttpServletRequest request, HttpServletResponse response)
  38. throws ServletException, IOException {
  39.  
  40. try {
  41. // 1. 获取请求uri, 得到请求路径名称 【login】
  42. String uri = request.getRequestURI();
  43. // 得到 login
  44. String actionName=uri.substring(uri.lastIndexOf("/")+1, uri.indexOf(".action"));
  45.  
  46. // 2. 根据路径名称,读取配置文件,得到类的全名 【cn..action.LoginAction】
  47. ActionMapping actionMapping = actionMappingManager.getActionMapping(actionName);
  48. String className = actionMapping.getClassName();
  49.  
  50. // 当前请求的处理方法 【method="login"】
  51. String method = actionMapping.getMethod();
  52.  
  53. // 3. 反射: 创建对象,调用方法; 获取方法返回的标记
  54. Class<?> clazz = Class.forName(className);
  55. Object obj = clazz.newInstance(); //LoginAction loginAction = new LoginAction();
  56. Method m = clazz.getDeclaredMethod(method, HttpServletRequest.class,HttpServletResponse.class );
  57. // 调用方法返回的标记
  58. String returnFlag = (String) m.invoke(obj, request, response);
  59.  
  60. // 4. 拿到标记,读取配置文件得到标记对应的页面 、 跳转类型
  61. Result result = actionMapping.getResults().get(returnFlag);
  62. // 类型
  63. String type = result.getType();
  64. // 页面
  65. String page = result.getPage();
  66.  
  67. // 跳转
  68. if ("redirect".equals(type)) {
  69. response.sendRedirect(request.getContextPath() + page);
  70. } else {
  71. request.getRequestDispatcher(page).forward(request, response);
  72. }
  73. } catch (Exception e) {
  74. e.printStackTrace();
  75. }
  76. }
  77.  
  78. @Override
  79. protected void doPost(HttpServletRequest req, HttpServletResponse resp)
  80. throws ServletException, IOException {
  81. doGet(req, resp);
  82. }
  83. }

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

  1. <!-- 核心控制器 -->
  2. <servlet>
  3. <servlet-name>ActionServlet</servlet-name>
  4. <servlet-class>cn.itcast.framework.ActionServlet</servlet-class>
  5. <!-- 启动时候执行servlet初始化方法 -->
  6. <load-on-startup>1</load-on-startup>
  7. </servlet>
  8. <servlet-mapping>
  9. <servlet-name>ActionServlet</servlet-name>
  10. <url-pattern>*.action</url-pattern>
  11. </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

手动的写一个structs的更多相关文章

  1. 如何手动写一个Python脚本自动爬取Bilibili小视频

    如何手动写一个Python脚本自动爬取Bilibili小视频 国庆结束之余,某个不务正业的码农不好好干活,在B站瞎逛着,毕竟国庆嘛,还让不让人休息了诶-- 我身边的很多小伙伴们在朋友圈里面晒着出去游玩 ...

  2. 【转】手动写一个Behavior Designer任务节点

    http://blog.csdn.net/qq_33747722/article/details/53539532 自己手写一个类似于CanSeeObject.Seek等任务节点并不是一件难事 下面我 ...

  3. 原来热加载如此简单,手动写一个 Java 热加载吧

    1. 什么是热加载 热加载是指可以在不重启服务的情况下让更改的代码生效,热加载可以显著的提升开发以及调试的效率,它是基于 Java 的类加载器实现的,但是由于热加载的不安全性,一般不会用于正式的生产环 ...

  4. 手动写一个类支持foreach循环

    之前初学时看过可以实现Iterable接口实现Iterator迭代器的支持,并且也支持foreach循环.现在学习了数据结构,手动写一个单链表支持foreach循环吧. 手写foreach循环步骤: ...

  5. 一起写一个JSON解析器

    [本篇博文会介绍JSON解析的原理与实现,并一步一步写出来一个简单但实用的JSON解析器,项目地址:SimpleJSON.希望通过这篇博文,能让我们以后与JSON打交道时更加得心应手.由于个人水平有限 ...

  6. 写一个迷你版Smarty模板引擎,对认识模板引擎原理非常好(附代码)

    前些时间在看创智博客韩顺平的Smarty模板引擎教程,再结合自己跟李炎恢第二季开发中CMS系统写的tpl模板引擎.今天就写一个迷你版的Smarty引擎,虽然说我并没有深入分析过Smarty的源码,但是 ...

  7. 从零开始写一个武侠冒险游戏-8-用GPU提升性能(3)

    从零开始写一个武侠冒险游戏-8-用GPU提升性能(3) ----解决因绘制雷达图导致的帧速下降问题 作者:FreeBlues 修订记录 2016.06.23 初稿完成. 2016.08.07 增加对 ...

  8. javascript如何用递归写一个简单的树形结构

    现在有一个数据,需要你渲染出对应的列表出来: var data = [ {"id":1}, {"id":2}, {"id":3}, {&qu ...

  9. 写一个ORM框架的第一步

    新一次的内部提升开始了,如果您想写一个框架从Apache Commons DbUtils开始学习是一种不错的选择,我们先学习应用这个小“框架”再把源代码理解,然后写一个属于自己的ORM框架不是梦. 一 ...

随机推荐

  1. 访问 Neutron 外部网络 - 每天5分钟玩转 OpenStack(143)

    前面我们学习了位于不同 Neutron subnet 的 instance 可以通过 router 通信,今天开始讨论 instance 如何访问外部网络. 这里的外部网络是指的租户网络以外的网络.租 ...

  2. CF 752C. Santa Claus and Robot

    C. Santa Claus and Robot time limit per test 2 seconds memory limit per test 256 megabytes input sta ...

  3. MyBatis 源码分析——介绍

    笔者第一次接触跟MyBatis框架是在2009年未的时候.不过那个时候的他并不叫MyBatis,而是叫IBatis.2010年的时候改为现在的名字--MyBatis.这几年过去了,对于笔者来讲有一点陌 ...

  4. iOS核心笔记—MapKit框架-基础

    1.MapKit框架简介: ✨了解:MapKit框架使用须知:①.MapKit框架中所有的数据类型的前缀都是MK:②.需要导入#import <MapKit/MapKit.h>头文件:③. ...

  5. linux c语言定时器

    原文来自于:http://hi.baidu.com/opetrhsxszbckzd/item/126966cae5f9524aa9ba94f5 我只是把其重新排版标注一下. linux c语言定时器 ...

  6. C++编程练习(3)----“实现简单的栈的顺序存储结构“

    栈(stack)是限定仅在表尾进行插入和删除操作的线性表. 允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom). 栈又称为后进先出(Last In First Out)的线性表,简 ...

  7. Python自然语言处理学习笔记之选择正确的特征(错误分析 error analysis)

    选择合适的特征(features)对机器学习的效率非常重要.特征的提取是一个不断摸索的过程(trial-and-error),一般靠直觉来发现哪些特征对研究的问题是相关的. 一种做法是把你能想到的所有 ...

  8. io的四个分类

    1.首先是字节操作:InputStream和OutputStream 2.字符操作:Reader和Writer 3.磁盘操作:File 4.网络操作:scoket(不在java.io包)

  9. Swift 实现俄罗斯方块详细思路解析(附完整项目)

    一:写在开发前 俄罗斯方块,是一款我们小时候都玩过的小游戏,我自己也是看着书上的思路,学着用 Swift 来写这个小游戏,在写这个游戏的过程中,除了一些位置的计算,数据模型和理解 Swift 语言之外 ...

  10. python之字典常用语法

    1. 创建字典 描述:生成字典 语法: dic={'k1':'v1'} 样例: dic=dict(k1='v1',k2='v2') dic={'k1':'v1','k2':'v2'} 2. 取键值ge ...